#include <torrentscontroller.h>

Inheritance diagram for TorrentsController:

Collaboration diagram for TorrentsController:

[legend]

Public Member Functions
	APIController (ISessionManager sessionManager, QObject parent=nullptr)

Public Member Functions inherited from APIController
	APIController (ISessionManager sessionManager, QObject parent=nullptr)

QVariant	run (const QString &action, const StringMap &params, const DataMap &data={})

ISessionManager *	sessionManager () const

Private Slots
void	infoAction ()

void	propertiesAction ()

void	trackersAction ()

void	webseedsAction ()

void	filesAction ()

void	pieceHashesAction ()

void	pieceStatesAction ()

void	resumeAction ()

void	pauseAction ()

void	recheckAction ()

void	reannounceAction ()

void	renameAction ()

void	setCategoryAction ()

void	createCategoryAction ()

void	editCategoryAction ()

void	removeCategoriesAction ()

void	categoriesAction ()

void	addTagsAction ()

void	removeTagsAction ()

void	createTagsAction ()

void	deleteTagsAction ()

void	tagsAction ()

void	addAction ()

void	deleteAction ()

void	addTrackersAction ()

void	editTrackerAction ()

void	removeTrackersAction ()

void	addPeersAction ()

void	filePrioAction ()

void	uploadLimitAction ()

void	downloadLimitAction ()

void	setUploadLimitAction ()

void	setDownloadLimitAction ()

void	setShareLimitsAction ()

void	increasePrioAction ()

void	decreasePrioAction ()

void	topPrioAction ()

void	bottomPrioAction ()

void	setLocationAction ()

void	setSavePathAction ()

void	setDownloadPathAction ()

void	setAutoManagementAction ()

void	setSuperSeedingAction ()

void	setForceStartAction ()

void	toggleSequentialDownloadAction ()

void	toggleFirstLastPiecePrioAction ()

void	renameFileAction ()

void	renameFolderAction ()

Additional Inherited Members
Protected Member Functions inherited from APIController
const StringMap &	params () const

const DataMap &	data () const

void	requireParams (const QVector< QString > &requiredParams) const

void	setResult (const QString &result)

void	setResult (const QJsonArray &result)

void	setResult (const QJsonObject &result)

Detailed Description

Definition at line 33 of file torrentscontroller.h.

Member Function Documentation

◆ addAction

void TorrentsController::addAction ( )

privateslot

Definition at line 635 of file torrentscontroller.cpp.

 {
     const QString urls = params()["urls"];
     const QString cookie = params()["cookie"];
  
     const bool skipChecking = parseBool(params()["skip_checking"]).value_or(false);
     const bool seqDownload = parseBool(params()["sequentialDownload"]).value_or(false);
     const bool firstLastPiece = parseBool(params()["firstLastPiecePrio"]).value_or(false);
     const std::optional<bool> addPaused = parseBool(params()["paused"]);
     const QString savepath = params()["savepath"].trimmed();
     const QString downloadPath = params()["downloadPath"].trimmed();
     const std::optional<bool> useDownloadPath = parseBool(params()["useDownloadPath"]);
     const QString category = params()["category"];
     const QStringList tags = params()["tags"].split(',', Qt::SkipEmptyParts);
     const QString torrentName = params()["rename"].trimmed();
     const int upLimit = parseInt(params()["upLimit"]).value_or(-1);
     const int dlLimit = parseInt(params()["dlLimit"]).value_or(-1);
     const double ratioLimit = parseDouble(params()["ratioLimit"]).value_or(BitTorrent::Torrent::USE_GLOBAL_RATIO);
     const int seedingTimeLimit = parseInt(params()["seedingTimeLimit"]).value_or(BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME);
     const std::optional<bool> autoTMM = parseBool(params()["autoTMM"]);
  
     const QString contentLayoutParam = params()["contentLayout"];
     const std::optional<BitTorrent::TorrentContentLayout> contentLayout = (!contentLayoutParam.isEmpty()
             ? Utils::String::toEnum(contentLayoutParam, BitTorrent::TorrentContentLayout::Original)
             : std::optional<BitTorrent::TorrentContentLayout> {});
  
     QList<QNetworkCookie> cookies;
     if (!cookie.isEmpty())
     {
         const QStringList cookiesStr = cookie.split("; ");
         for (QString cookieStr : cookiesStr)
         {
             cookieStr = cookieStr.trimmed();
             int index = cookieStr.indexOf('=');
             if (index > 1)
             {
                 QByteArray name = cookieStr.left(index).toLatin1();
                 QByteArray value = cookieStr.right(cookieStr.length() - index - 1).toLatin1();
                 cookies += QNetworkCookie(name, value);
             }
         }
     }
  
     BitTorrent::AddTorrentParams addTorrentParams;
     // TODO: Check if destination actually exists
     addTorrentParams.skipChecking = skipChecking;
     addTorrentParams.sequential = seqDownload;
     addTorrentParams.firstLastPiecePriority = firstLastPiece;
     addTorrentParams.addPaused = addPaused;
     addTorrentParams.contentLayout = contentLayout;
     addTorrentParams.savePath = savepath;
     addTorrentParams.downloadPath = downloadPath;
     addTorrentParams.useDownloadPath = useDownloadPath;
     addTorrentParams.category = category;
     addTorrentParams.tags.insert(tags.cbegin(), tags.cend());
     addTorrentParams.name = torrentName;
     addTorrentParams.uploadLimit = upLimit;
     addTorrentParams.downloadLimit = dlLimit;
     addTorrentParams.seedingTimeLimit = seedingTimeLimit;
     addTorrentParams.ratioLimit = ratioLimit;
     addTorrentParams.useAutoTMM = autoTMM;
  
     bool partialSuccess = false;
     for (QString url : asConst(urls.split('\n')))
     {
         url = url.trimmed();
         if (!url.isEmpty())
         {
             Net::DownloadManager::instance()->setCookiesFromUrl(cookies, QUrl::fromEncoded(url.toUtf8()));
             partialSuccess |= BitTorrent::Session::instance()->addTorrent(url, addTorrentParams);
         }
     }
  
     for (auto it = data().constBegin(); it != data().constEnd(); ++it)
     {
         const nonstd::expected<BitTorrent::TorrentInfo, QString> result = BitTorrent::TorrentInfo::load(it.value());
         if (!result)
         {
             throw APIError(APIErrorType::BadData
                            , tr("Error: '%1' is not a valid torrent file.").arg(it.key()));
         }
  
         partialSuccess |= BitTorrent::Session::instance()->addTorrent(result.value(), addTorrentParams);
     }
  
     if (partialSuccess)
         setResult(QLatin1String("Ok."));
     else
         setResult(QLatin1String("Fails."));
 }

Here is the call graph for this function:

◆ addPeersAction

void TorrentsController::addPeersAction ( )

privateslot

Definition at line 815 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "peers"});
  
     const QStringList hashes = params()["hashes"].split('|');
     const QStringList peers = params()["peers"].split('|');
  
     QVector<BitTorrent::PeerAddress> peerList;
     peerList.reserve(peers.size());
     for (const QString &peer : peers)
     {
         const BitTorrent::PeerAddress addr = BitTorrent::PeerAddress::parse(peer.trimmed());
         if (!addr.ip.isNull())
             peerList.append(addr);
     }
  
     if (peerList.isEmpty())
         throw APIError(APIErrorType::BadParams, "No valid peers were specified");
  
     QJsonObject results;
  
     applyToTorrents(hashes, [peers, peerList, &results](BitTorrent::Torrent *const torrent)
     {
         const int peersAdded = std::count_if(peerList.cbegin(), peerList.cend(), [torrent](const BitTorrent::PeerAddress &peer)
         {
             return torrent->connectPeer(peer);
         });
  
         results[torrent->id().toString()] = QJsonObject
         {
             {"added", peersAdded},
             {"failed", (peers.size() - peersAdded)}
         };
     });
  
     setResult(results);
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), BadParams, BitTorrent::Torrent::id(), BitTorrent::PeerAddress::ip, APIController::params(), BitTorrent::PeerAddress::parse(), APIController::requireParams(), APIController::setResult(), and Digest32< N >::toString().

Here is the call graph for this function:

◆ addTagsAction

void TorrentsController::addTagsAction ( )

privateslot

Definition at line 1290 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "tags"});
  
     const QStringList hashes {params()["hashes"].split('|')};
     const QStringList tags {params()["tags"].split(',', Qt::SkipEmptyParts)};
  
     for (const QString &tag : tags)
     {
         const QString tagTrimmed {tag.trimmed()};
         applyToTorrents(hashes, [&tagTrimmed](BitTorrent::Torrent *const torrent)
         {
             torrent->addTag(tagTrimmed);
         });
     }
 }

References BitTorrent::Torrent::addTag(), anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), and APIController::requireParams().

Here is the call graph for this function:

◆ addTrackersAction

void TorrentsController::addTrackersAction ( )

privateslot

Definition at line 726 of file torrentscontroller.cpp.

 {
     requireParams({"hash", "urls"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     QVector<BitTorrent::TrackerEntry> trackers;
     for (const QString &urlStr : asConst(params()["urls"].split('\n')))
     {
         const QUrl url {urlStr.trimmed()};
         if (url.isValid())
             trackers.append({url.toString()});
     }
     torrent->addTrackers(trackers);
 }

References BitTorrent::Torrent::addTrackers(), asConst(), BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), NotFound, APIController::params(), and APIController::requireParams().

Here is the call graph for this function:

◆ APIController()

APIController::APIController

explicit

Definition at line 53 of file apicontroller.cpp.

     : QObject {parent}
     , m_sessionManager {sessionManager}
 {
 }

◆ bottomPrioAction

void TorrentsController::bottomPrioAction ( )

privateslot

Definition at line 1068 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     if (!BitTorrent::Session::instance()->isQueueingSystemEnabled())
         throw APIError(APIErrorType::Conflict, tr("Torrent queueing must be enabled"));
  
     const QStringList hashes {params()["hashes"].split('|')};
     BitTorrent::Session::instance()->bottomTorrentsQueuePos(toTorrentIDs(hashes));
 }

References BitTorrent::Session::bottomTorrentsQueuePos(), Conflict, BitTorrent::Session::instance(), APIController::params(), APIController::requireParams(), and anonymous_namespace{torrentscontroller.cpp}::toTorrentIDs().

Here is the call graph for this function:

◆ categoriesAction

void TorrentsController::categoriesAction ( )

privateslot

Definition at line 1273 of file torrentscontroller.cpp.

 {
     const auto session = BitTorrent::Session::instance();
  
     QJsonObject categories;
     const QStringList categoriesList = session->categories();
     for (const auto &categoryName : categoriesList)
     {
         const BitTorrent::CategoryOptions categoryOptions = session->categoryOptions(categoryName);
         QJsonObject category = categoryOptions.toJSON();
         category.insert(QLatin1String("name"), categoryName);
         categories[categoryName] = category;
     }
  
     setResult(categories);
 }

References BitTorrent::Session::instance(), APIController::setResult(), and BitTorrent::CategoryOptions::toJSON().

Here is the call graph for this function:

◆ createCategoryAction

void TorrentsController::createCategoryAction ( )

privateslot

Definition at line 1217 of file torrentscontroller.cpp.

 {
     requireParams({"category"});
  
     const QString category = params()["category"];
     if (category.isEmpty())
         throw APIError(APIErrorType::BadParams, tr("Category cannot be empty"));
  
     if (!BitTorrent::Session::isValidCategoryName(category))
         throw APIError(APIErrorType::Conflict, tr("Incorrect category name"));
  
     const QString savePath = params()["savePath"];
     const auto useDownloadPath = parseBool(params()["downloadPathEnabled"]);
     BitTorrent::CategoryOptions categoryOptions;
     categoryOptions.savePath = savePath;
     if (useDownloadPath.has_value())
     {
         const QString downloadPath = params()["downloadPath"];
         categoryOptions.downloadPath = {useDownloadPath.value(), downloadPath};
     }
  
     if (!BitTorrent::Session::instance()->addCategory(category, categoryOptions))
         throw APIError(APIErrorType::Conflict, tr("Unable to create category"));
 }

References BadParams, Conflict, BitTorrent::CategoryOptions::downloadPath, BitTorrent::Session::instance(), BitTorrent::Session::isValidCategoryName(), APIController::params(), Utils::String::parseBool(), APIController::requireParams(), and BitTorrent::CategoryOptions::savePath.

Here is the call graph for this function:

◆ createTagsAction

void TorrentsController::createTagsAction ( )

privateslot

Definition at line 1332 of file torrentscontroller.cpp.

 {
     requireParams({"tags"});
  
     const QStringList tags {params()["tags"].split(',', Qt::SkipEmptyParts)};
  
     for (const QString &tag : tags)
         BitTorrent::Session::instance()->addTag(tag.trimmed());
 }

References BitTorrent::Session::addTag(), BitTorrent::Session::instance(), APIController::params(), and APIController::requireParams().

Here is the call graph for this function:

◆ decreasePrioAction

void TorrentsController::decreasePrioAction ( )

privateslot

Definition at line 1046 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     if (!BitTorrent::Session::instance()->isQueueingSystemEnabled())
         throw APIError(APIErrorType::Conflict, tr("Torrent queueing must be enabled"));
  
     const QStringList hashes {params()["hashes"].split('|')};
     BitTorrent::Session::instance()->decreaseTorrentsQueuePos(toTorrentIDs(hashes));
 }

References Conflict, BitTorrent::Session::decreaseTorrentsQueuePos(), BitTorrent::Session::instance(), APIController::params(), APIController::requireParams(), and anonymous_namespace{torrentscontroller.cpp}::toTorrentIDs().

Here is the call graph for this function:

◆ deleteAction

void TorrentsController::deleteAction ( )

privateslot

Definition at line 1022 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "deleteFiles"});
  
     const QStringList hashes {params()["hashes"].split('|')};
     const DeleteOption deleteOption = parseBool(params()["deleteFiles"]).value_or(false)
             ? DeleteTorrentAndFiles : DeleteTorrent;
     applyToTorrents(hashes, [deleteOption](const BitTorrent::Torrent *torrent)
     {
         BitTorrent::Session::instance()->deleteTorrent(torrent->id(), deleteOption);
     });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), DeleteTorrent, BitTorrent::Session::deleteTorrent(), DeleteTorrentAndFiles, BitTorrent::Torrent::id(), BitTorrent::Session::instance(), APIController::params(), Utils::String::parseBool(), and APIController::requireParams().

Here is the call graph for this function:

◆ deleteTagsAction

void TorrentsController::deleteTagsAction ( )

privateslot

Definition at line 1342 of file torrentscontroller.cpp.

 {
     requireParams({"tags"});
  
     const QStringList tags {params()["tags"].split(',', Qt::SkipEmptyParts)};
     for (const QString &tag : tags)
         BitTorrent::Session::instance()->removeTag(tag.trimmed());
 }

References BitTorrent::Session::instance(), APIController::params(), BitTorrent::Session::removeTag(), and APIController::requireParams().

Here is the call graph for this function:

◆ downloadLimitAction

void TorrentsController::downloadLimitAction ( )

privateslot

Definition at line 928 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     const QStringList idList {params()["hashes"].split('|')};
     QJsonObject map;
     for (const QString &id : idList)
     {
         int limit = -1;
         const BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(BitTorrent::TorrentID::fromString(id));
         if (torrent)
             limit = torrent->downloadLimit();
         map[id] = limit;
     }
  
     setResult(map);
 }

References BitTorrent::Torrent::downloadLimit(), BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), APIController::params(), APIController::requireParams(), and APIController::setResult().

Here is the call graph for this function:

◆ editCategoryAction

void TorrentsController::editCategoryAction ( )

privateslot

Definition at line 1242 of file torrentscontroller.cpp.

 {
     requireParams({"category", "savePath"});
  
     const QString category = params()["category"];
     if (category.isEmpty())
         throw APIError(APIErrorType::BadParams, tr("Category cannot be empty"));
  
     const QString savePath = params()["savePath"];
     const auto useDownloadPath = parseBool(params()["downloadPathEnabled"]);
     BitTorrent::CategoryOptions categoryOptions;
     categoryOptions.savePath = savePath;
     if (useDownloadPath.has_value())
     {
         const QString downloadPath = params()["downloadPath"];
         categoryOptions.downloadPath = {useDownloadPath.value(), downloadPath};
     }
  
     if (!BitTorrent::Session::instance()->editCategory(category, categoryOptions))
         throw APIError(APIErrorType::Conflict, tr("Unable to edit category"));
 }

References BadParams, Conflict, BitTorrent::CategoryOptions::downloadPath, BitTorrent::Session::instance(), APIController::params(), Utils::String::parseBool(), APIController::requireParams(), and BitTorrent::CategoryOptions::savePath.

Here is the call graph for this function:

◆ editTrackerAction

void TorrentsController::editTrackerAction ( )

privateslot

Definition at line 745 of file torrentscontroller.cpp.

 {
     requireParams({"hash", "origUrl", "newUrl"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     const QString origUrl = params()["origUrl"];
     const QString newUrl = params()["newUrl"];
  
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     const QUrl origTrackerUrl(origUrl);
     const QUrl newTrackerUrl(newUrl);
     if (origTrackerUrl == newTrackerUrl)
         return;
     if (!newTrackerUrl.isValid())
         throw APIError(APIErrorType::BadParams, "New tracker URL is invalid");
  
     QVector<BitTorrent::TrackerEntry> trackers = torrent->trackers();
     bool match = false;
     for (BitTorrent::TrackerEntry &tracker : trackers)
     {
         const QUrl trackerUrl(tracker.url);
         if (trackerUrl == newTrackerUrl)
             throw APIError(APIErrorType::Conflict, "New tracker URL already exists");
         if (trackerUrl == origTrackerUrl)
         {
             match = true;
             tracker.url = newTrackerUrl.toString();
         }
     }
     if (!match)
         throw APIError(APIErrorType::Conflict, "Tracker not found");
  
     torrent->replaceTrackers(trackers);
  
     if (!torrent->isPaused())
         torrent->forceReannounce();
 }

References BadParams, Conflict, BitTorrent::Session::findTorrent(), BitTorrent::Torrent::forceReannounce(), BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), BitTorrent::Torrent::isPaused(), NotFound, APIController::params(), BitTorrent::Torrent::replaceTrackers(), APIController::requireParams(), and BitTorrent::Torrent::trackers().

Here is the call graph for this function:

◆ filePrioAction

void TorrentsController::filePrioAction ( )

privateslot

Definition at line 869 of file torrentscontroller.cpp.

 {
     requireParams({"hash", "id", "priority"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     bool ok = false;
     const auto priority = static_cast<BitTorrent::DownloadPriority>(params()["priority"].toInt(&ok));
     if (!ok)
         throw APIError(APIErrorType::BadParams, tr("Priority must be an integer"));
  
     if (!BitTorrent::isValidDownloadPriority(priority))
         throw APIError(APIErrorType::BadParams, tr("Priority is not valid"));
  
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
     if (!torrent->hasMetadata())
         throw APIError(APIErrorType::Conflict, tr("Torrent's metadata has not yet downloaded"));
  
     const int filesCount = torrent->filesCount();
     QVector<BitTorrent::DownloadPriority> priorities = torrent->filePriorities();
     bool priorityChanged = false;
     for (const QString &fileID : params()["id"].split('|'))
     {
         const int id = fileID.toInt(&ok);
         if (!ok)
             throw APIError(APIErrorType::BadParams, tr("File IDs must be integers"));
         if ((id < 0) || (id >= filesCount))
             throw APIError(APIErrorType::Conflict, tr("File ID is not valid"));
  
         if (priorities[id] != priority)
         {
             priorities[id] = priority;
             priorityChanged = true;
         }
     }
  
     if (priorityChanged)
         torrent->prioritizeFiles(priorities);
 }

References BadParams, Conflict, BitTorrent::Torrent::filePriorities(), BitTorrent::AbstractFileStorage::filesCount(), BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), BitTorrent::Torrent::hasMetadata(), BitTorrent::Session::instance(), BitTorrent::isValidDownloadPriority(), NotFound, APIController::params(), BitTorrent::Torrent::prioritizeFiles(), and APIController::requireParams().

Here is the call graph for this function:

◆ filesAction

void TorrentsController::filesAction ( )

privateslot

Definition at line 517 of file torrentscontroller.cpp.

 {
     requireParams({"hash"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     const BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     const int filesCount = torrent->filesCount();
     QVector<int> fileIndexes;
     const auto idxIt = params().constFind(QLatin1String("indexes"));
     if (idxIt != params().cend())
     {
         const QStringList indexStrings = idxIt.value().split('|');
         fileIndexes.reserve(indexStrings.size());
         std::transform(indexStrings.cbegin(), indexStrings.cend(), std::back_inserter(fileIndexes)
                        , [&filesCount](const QString &indexString) -> int
         {
             bool ok = false;
             const int index = indexString.toInt(&ok);
             if (!ok || (index < 0))
                 throw APIError(APIErrorType::Conflict, tr("\"%1\" is not a valid file index.").arg(indexString));
             if (index >= filesCount)
                 throw APIError(APIErrorType::Conflict, tr("Index %1 is out of bounds.").arg(indexString));
             return index;
         });
     }
     else
     {
         fileIndexes.reserve(filesCount);
         for (int i = 0; i < filesCount; ++i)
             fileIndexes.append(i);
     }
  
     QJsonArray fileList;
     if (torrent->hasMetadata())
     {
         const QVector<BitTorrent::DownloadPriority> priorities = torrent->filePriorities();
         const QVector<qreal> fp = torrent->filesProgress();
         const QVector<qreal> fileAvailability = torrent->availableFileFractions();
         const BitTorrent::TorrentInfo info = torrent->info();
         for (const int index : asConst(fileIndexes))
         {
             QJsonObject fileDict =
             {
                 {KEY_FILE_INDEX, index},
                 {KEY_FILE_PROGRESS, fp[index]},
                 {KEY_FILE_PRIORITY, static_cast<int>(priorities[index])},
                 {KEY_FILE_SIZE, torrent->fileSize(index)},
                 {KEY_FILE_AVAILABILITY, fileAvailability[index]},
                 {KEY_FILE_NAME, Utils::Fs::toUniformPath(torrent->filePath(index))}
             };
  
             const BitTorrent::TorrentInfo::PieceRange idx = info.filePieces(index);
             fileDict[KEY_FILE_PIECE_RANGE] = QJsonArray {idx.first(), idx.last()};
  
             if (index == 0)
                 fileDict[KEY_FILE_IS_SEED] = torrent->isSeed();
  
             fileList.append(fileDict);
         }
     }
  
     setResult(fileList);
 }

Here is the call graph for this function:

◆ increasePrioAction

void TorrentsController::increasePrioAction ( )

privateslot

Definition at line 1035 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     if (!BitTorrent::Session::instance()->isQueueingSystemEnabled())
         throw APIError(APIErrorType::Conflict, tr("Torrent queueing must be enabled"));
  
     const QStringList hashes {params()["hashes"].split('|')};
     BitTorrent::Session::instance()->increaseTorrentsQueuePos(toTorrentIDs(hashes));
 }

References Conflict, BitTorrent::Session::increaseTorrentsQueuePos(), BitTorrent::Session::instance(), APIController::params(), APIController::requireParams(), and anonymous_namespace{torrentscontroller.cpp}::toTorrentIDs().

Here is the call graph for this function:

◆ infoAction

void TorrentsController::infoAction ( )

privateslot

Definition at line 256 of file torrentscontroller.cpp.

 {
     const QString filter {params()["filter"]};
     const QString category {params()["category"]};
     const QString tag {params()["tag"]};
     const QString sortedColumn {params()["sort"]};
     const bool reverse {parseBool(params()["reverse"]).value_or(false)};
     int limit {params()["limit"].toInt()};
     int offset {params()["offset"].toInt()};
     const QStringList hashes {params()["hashes"].split('|', Qt::SkipEmptyParts)};
  
     TorrentIDSet idSet;
     for (const QString &hash : hashes)
         idSet.insert(BitTorrent::TorrentID::fromString(hash));
  
     const TorrentFilter torrentFilter(filter, (hashes.isEmpty() ? TorrentFilter::AnyID : idSet), category, tag);
     QVariantList torrentList;
     for (const BitTorrent::Torrent *torrent : asConst(BitTorrent::Session::instance()->torrents()))
     {
         if (torrentFilter.match(torrent))
             torrentList.append(serialize(*torrent));
     }
  
     if (torrentList.isEmpty())
     {
         setResult(QJsonArray {});
         return;
     }
  
     if (!sortedColumn.isEmpty())
     {
         if (!torrentList[0].toMap().contains(sortedColumn))
             throw APIError(APIErrorType::BadParams, tr("'sort' parameter is invalid"));
  
         const auto lessThan = [](const QVariant &left, const QVariant &right) -> bool
         {
             Q_ASSERT(left.type() == right.type());
  
             switch (static_cast<QMetaType::Type>(left.type()))
             {
             case QMetaType::Bool:
                 return left.value<bool>() < right.value<bool>();
             case QMetaType::Double:
                 return left.value<double>() < right.value<double>();
             case QMetaType::Float:
                 return left.value<float>() < right.value<float>();
             case QMetaType::Int:
                 return left.value<int>() < right.value<int>();
             case QMetaType::LongLong:
                 return left.value<qlonglong>() < right.value<qlonglong>();
             case QMetaType::QString:
                 return left.value<QString>() < right.value<QString>();
             default:
                 qWarning("Unhandled QVariant comparison, type: %d, name: %s", left.type()
                     , QMetaType::typeName(left.type()));
                 break;
             }
             return false;
         };
  
         std::sort(torrentList.begin(), torrentList.end()
             , [reverse, &sortedColumn, &lessThan](const QVariant &torrent1, const QVariant &torrent2)
         {
             const QVariant value1 {torrent1.toMap().value(sortedColumn)};
             const QVariant value2 {torrent2.toMap().value(sortedColumn)};
             return reverse ? lessThan(value2, value1) : lessThan(value1, value2);
         });
     }
  
     const int size = torrentList.size();
     // normalize offset
     if (offset < 0)
         offset = size + offset;
     if ((offset >= size) || (offset < 0))
         offset = 0;
     // normalize limit
     if (limit <= 0)
         limit = -1; // unlimited
  
     if ((limit > 0) || (offset > 0))
         torrentList = torrentList.mid(offset, limit);
  
     setResult(QJsonArray::fromVariantList(torrentList));
 }

References TorrentFilter::AnyID, asConst(), BadParams, BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), TorrentFilter::match(), APIController::params(), Utils::String::parseBool(), serialize(), and APIController::setResult().

Here is the call graph for this function:

◆ pauseAction

void TorrentsController::pauseAction ( )

privateslot

Definition at line 853 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     const QStringList hashes = params()["hashes"].split('|');
     applyToTorrents(hashes, [](BitTorrent::Torrent *const torrent) { torrent->pause(); });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), BitTorrent::Torrent::pause(), and APIController::requireParams().

Here is the call graph for this function:

◆ pieceHashesAction

void TorrentsController::pieceHashesAction ( )

privateslot

Definition at line 586 of file torrentscontroller.cpp.

 {
     requireParams({"hash"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     QJsonArray pieceHashes;
     if (torrent->hasMetadata())
     {
         const QVector<QByteArray> hashes = torrent->info().pieceHashes();
         for (const QByteArray &hash : hashes)
             pieceHashes.append(QString(hash.toHex()));
     }
  
     setResult(pieceHashes);
 }

References BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), BitTorrent::Torrent::hasMetadata(), BitTorrent::Torrent::info(), BitTorrent::Session::instance(), NotFound, APIController::params(), BitTorrent::TorrentInfo::pieceHashes(), APIController::requireParams(), and APIController::setResult().

Here is the call graph for this function:

◆ pieceStatesAction

void TorrentsController::pieceStatesAction ( )

privateslot

Definition at line 611 of file torrentscontroller.cpp.

 {
     requireParams({"hash"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     QJsonArray pieceStates;
     const QBitArray states = torrent->pieces();
     for (int i = 0; i < states.size(); ++i)
         pieceStates.append(static_cast<int>(states[i]) * 2);
  
     const QBitArray dlstates = torrent->downloadingPieces();
     for (int i = 0; i < states.size(); ++i)
     {
         if (dlstates[i])
             pieceStates[i] = 1;
     }
  
     setResult(pieceStates);
 }

References BitTorrent::Torrent::downloadingPieces(), BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), NotFound, APIController::params(), BitTorrent::Torrent::pieces(), APIController::requireParams(), and APIController::setResult().

Here is the call graph for this function:

◆ propertiesAction

void TorrentsController::propertiesAction ( )

privateslot

Definition at line 378 of file torrentscontroller.cpp.

 {
     requireParams({"hash"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     QJsonObject dataDict;
  
     dataDict[KEY_TORRENT_INFOHASHV1] = torrent->infoHash().v1().toString();
     dataDict[KEY_TORRENT_INFOHASHV2] = torrent->infoHash().v2().toString();
     dataDict[KEY_PROP_TIME_ELAPSED] = torrent->activeTime();
     dataDict[KEY_PROP_SEEDING_TIME] = torrent->finishedTime();
     dataDict[KEY_PROP_ETA] = static_cast<double>(torrent->eta());
     dataDict[KEY_PROP_CONNECT_COUNT] = torrent->connectionsCount();
     dataDict[KEY_PROP_CONNECT_COUNT_LIMIT] = torrent->connectionsLimit();
     dataDict[KEY_PROP_DOWNLOADED] = torrent->totalDownload();
     dataDict[KEY_PROP_DOWNLOADED_SESSION] = torrent->totalPayloadDownload();
     dataDict[KEY_PROP_UPLOADED] = torrent->totalUpload();
     dataDict[KEY_PROP_UPLOADED_SESSION] = torrent->totalPayloadUpload();
     dataDict[KEY_PROP_DL_SPEED] = torrent->downloadPayloadRate();
     const qlonglong dlDuration = torrent->activeTime() - torrent->finishedTime();
     dataDict[KEY_PROP_DL_SPEED_AVG] = torrent->totalDownload() / ((dlDuration == 0) ? -1 : dlDuration);
     dataDict[KEY_PROP_UP_SPEED] = torrent->uploadPayloadRate();
     const qlonglong ulDuration = torrent->activeTime();
     dataDict[KEY_PROP_UP_SPEED_AVG] = torrent->totalUpload() / ((ulDuration == 0) ? -1 : ulDuration);
     dataDict[KEY_PROP_DL_LIMIT] = torrent->downloadLimit() <= 0 ? -1 : torrent->downloadLimit();
     dataDict[KEY_PROP_UP_LIMIT] = torrent->uploadLimit() <= 0 ? -1 : torrent->uploadLimit();
     dataDict[KEY_PROP_WASTED] = torrent->wastedSize();
     dataDict[KEY_PROP_SEEDS] = torrent->seedsCount();
     dataDict[KEY_PROP_SEEDS_TOTAL] = torrent->totalSeedsCount();
     dataDict[KEY_PROP_PEERS] = torrent->leechsCount();
     dataDict[KEY_PROP_PEERS_TOTAL] = torrent->totalLeechersCount();
     const qreal ratio = torrent->realRatio();
     dataDict[KEY_PROP_RATIO] = ratio > BitTorrent::Torrent::MAX_RATIO ? -1 : ratio;
     dataDict[KEY_PROP_REANNOUNCE] = torrent->nextAnnounce();
     dataDict[KEY_PROP_TOTAL_SIZE] = torrent->totalSize();
     dataDict[KEY_PROP_PIECES_NUM] = torrent->piecesCount();
     dataDict[KEY_PROP_PIECE_SIZE] = torrent->pieceLength();
     dataDict[KEY_PROP_PIECES_HAVE] = torrent->piecesHave();
     dataDict[KEY_PROP_CREATED_BY] = torrent->creator();
     dataDict[KEY_PROP_ADDITION_DATE] = static_cast<double>(torrent->addedTime().toSecsSinceEpoch());
     if (torrent->hasMetadata())
     {
         dataDict[KEY_PROP_LAST_SEEN] = torrent->lastSeenComplete().isValid() ? torrent->lastSeenComplete().toSecsSinceEpoch() : -1;
         dataDict[KEY_PROP_COMPLETION_DATE] = torrent->completedTime().isValid() ? torrent->completedTime().toSecsSinceEpoch() : -1;
         dataDict[KEY_PROP_CREATION_DATE] = static_cast<double>(torrent->creationDate().toSecsSinceEpoch());
     }
     else
     {
         dataDict[KEY_PROP_LAST_SEEN] = -1;
         dataDict[KEY_PROP_COMPLETION_DATE] = -1;
         dataDict[KEY_PROP_CREATION_DATE] = -1;
     }
     dataDict[KEY_PROP_SAVE_PATH] = Utils::Fs::toNativePath(torrent->savePath());
     dataDict[KEY_PROP_DOWNLOAD_PATH] = Utils::Fs::toNativePath(torrent->downloadPath());
     dataDict[KEY_PROP_COMMENT] = torrent->comment();
  
     setResult(dataDict);
 }

Here is the call graph for this function:

◆ reannounceAction

void TorrentsController::reannounceAction ( )

privateslot

Definition at line 1195 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     const QStringList hashes {params()["hashes"].split('|')};
     applyToTorrents(hashes, [](BitTorrent::Torrent *const torrent) { torrent->forceReannounce(); });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), BitTorrent::Torrent::forceReannounce(), APIController::params(), and APIController::requireParams().

Here is the call graph for this function:

◆ recheckAction

void TorrentsController::recheckAction ( )

privateslot

Definition at line 1187 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     const QStringList hashes {params()["hashes"].split('|')};
     applyToTorrents(hashes, [](BitTorrent::Torrent *const torrent) { torrent->forceRecheck(); });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), BitTorrent::Torrent::forceRecheck(), APIController::params(), and APIController::requireParams().

Here is the call graph for this function:

◆ removeCategoriesAction

void TorrentsController::removeCategoriesAction ( )

privateslot

Definition at line 1264 of file torrentscontroller.cpp.

 {
     requireParams({"categories"});
  
     const QStringList categories {params()["categories"].split('\n')};
     for (const QString &category : categories)
         BitTorrent::Session::instance()->removeCategory(category);
 }

References BitTorrent::Session::instance(), APIController::params(), BitTorrent::Session::removeCategory(), and APIController::requireParams().

Here is the call graph for this function:

◆ removeTagsAction

void TorrentsController::removeTagsAction ( )

privateslot

Definition at line 1307 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     const QStringList hashes {params()["hashes"].split('|')};
     const QStringList tags {params()["tags"].split(',', Qt::SkipEmptyParts)};
  
     for (const QString &tag : tags)
     {
         const QString tagTrimmed {tag.trimmed()};
         applyToTorrents(hashes, [&tagTrimmed](BitTorrent::Torrent *const torrent)
         {
             torrent->removeTag(tagTrimmed);
         });
     }
  
     if (tags.isEmpty())
     {
         applyToTorrents(hashes, [](BitTorrent::Torrent *const torrent)
         {
             torrent->removeAllTags();
         });
     }
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), BitTorrent::Torrent::removeAllTags(), BitTorrent::Torrent::removeTag(), and APIController::requireParams().

Here is the call graph for this function:

◆ removeTrackersAction

void TorrentsController::removeTrackersAction ( )

privateslot

Definition at line 786 of file torrentscontroller.cpp.

 {
     requireParams({"hash", "urls"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     const QStringList urls = params()["urls"].split('|');
  
     const QVector<BitTorrent::TrackerEntry> trackers = torrent->trackers();
     QVector<BitTorrent::TrackerEntry> remainingTrackers;
     remainingTrackers.reserve(trackers.size());
     for (const BitTorrent::TrackerEntry &entry : trackers)
     {
         if (!urls.contains(entry.url))
             remainingTrackers.push_back(entry);
     }
  
     if (remainingTrackers.size() == trackers.size())
         throw APIError(APIErrorType::Conflict, "No trackers were removed");
  
     torrent->replaceTrackers(remainingTrackers);
  
     if (!torrent->isPaused())
         torrent->forceReannounce();
 }

References Conflict, BitTorrent::Session::findTorrent(), BitTorrent::Torrent::forceReannounce(), BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), BitTorrent::Torrent::isPaused(), NotFound, APIController::params(), BitTorrent::Torrent::replaceTrackers(), APIController::requireParams(), and BitTorrent::Torrent::trackers().

Here is the call graph for this function:

◆ renameAction

void TorrentsController::renameAction ( )

privateslot

Definition at line 1156 of file torrentscontroller.cpp.

 {
     requireParams({"hash", "name"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     QString name = params()["name"].trimmed();
  
     if (name.isEmpty())
         throw APIError(APIErrorType::Conflict, tr("Incorrect torrent name"));
  
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     name.replace(QRegularExpression("\r?\n|\r"), " ");
     torrent->setName(name);
 }

References Conflict, BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), NotFound, APIController::params(), APIController::requireParams(), and BitTorrent::Torrent::setName().

Here is the call graph for this function:

◆ renameFileAction

void TorrentsController::renameFileAction ( )

privateslot

Definition at line 1359 of file torrentscontroller.cpp.

 {
     requireParams({"hash", "oldPath", "newPath"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     const QString oldPath = params()["oldPath"];
     const QString newPath = params()["newPath"];
  
     try
     {
         torrent->renameFile(oldPath, newPath);
     }
     catch (const RuntimeError &error)
     {
         throw APIError(APIErrorType::Conflict, error.message());
     }
 }

References Conflict, BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), Exception::message(), NotFound, APIController::params(), BitTorrent::AbstractFileStorage::renameFile(), and APIController::requireParams().

Here is the call graph for this function:

◆ renameFolderAction

void TorrentsController::renameFolderAction ( )

privateslot

Definition at line 1381 of file torrentscontroller.cpp.

 {
     requireParams({"hash", "oldPath", "newPath"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     const QString oldPath = params()["oldPath"];
     const QString newPath = params()["newPath"];
  
     try
     {
         torrent->renameFolder(oldPath, newPath);
     }
     catch (const RuntimeError &error)
     {
         throw APIError(APIErrorType::Conflict, error.message());
     }
 }

References Conflict, BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), Exception::message(), NotFound, APIController::params(), BitTorrent::AbstractFileStorage::renameFolder(), and APIController::requireParams().

Here is the call graph for this function:

◆ resumeAction

void TorrentsController::resumeAction ( )

privateslot

Definition at line 861 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     const QStringList idStrings = params()["hashes"].split('|');
     applyToTorrents(idStrings, [](BitTorrent::Torrent *const torrent) { torrent->resume(); });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), APIController::requireParams(), and BitTorrent::Torrent::resume().

Here is the call graph for this function:

◆ setAutoManagementAction

void TorrentsController::setAutoManagementAction ( )

privateslot

Definition at line 1174 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "enable"});
  
     const QStringList hashes {params()["hashes"].split('|')};
     const bool isEnabled {parseBool(params()["enable"]).value_or(false)};
  
     applyToTorrents(hashes, [isEnabled](BitTorrent::Torrent *const torrent)
     {
         torrent->setAutoTMMEnabled(isEnabled);
     });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), Utils::String::parseBool(), APIController::requireParams(), and BitTorrent::Torrent::setAutoTMMEnabled().

Here is the call graph for this function:

◆ setCategoryAction

void TorrentsController::setCategoryAction ( )

privateslot

Definition at line 1203 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "category"});
  
     const QStringList hashes {params()["hashes"].split('|')};
     const QString category {params()["category"]};
  
     applyToTorrents(hashes, [category](BitTorrent::Torrent *const torrent)
     {
         if (!torrent->setCategory(category))
             throw APIError(APIErrorType::Conflict, tr("Incorrect category name"));
     });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), Conflict, APIController::params(), APIController::requireParams(), and BitTorrent::Torrent::setCategory().

Here is the call graph for this function:

◆ setDownloadLimitAction

void TorrentsController::setDownloadLimitAction ( )

privateslot

Definition at line 958 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "limit"});
  
     qlonglong limit = params()["limit"].toLongLong();
     if (limit == 0)
         limit = -1;
  
     const QStringList hashes {params()["hashes"].split('|')};
     applyToTorrents(hashes, [limit](BitTorrent::Torrent *const torrent) { torrent->setDownloadLimit(limit); });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), APIController::requireParams(), and BitTorrent::Torrent::setDownloadLimit().

Here is the call graph for this function:

◆ setDownloadPathAction

void TorrentsController::setDownloadPathAction ( )

privateslot

Definition at line 1131 of file torrentscontroller.cpp.

 {
     requireParams({"id", "path"});
  
     const QStringList ids {params()["id"].split('|')};
     const QString newPath {params()["path"]};
  
     if (!newPath.isEmpty())
     {
         // try to create the directory if it does not exist
         if (!QDir(newPath).mkpath("."))
             throw APIError(APIErrorType::Conflict, tr("Cannot create target directory"));
  
         // check permissions
         if (!QFileInfo(newPath).isWritable())
             throw APIError(APIErrorType::AccessDenied, tr("Cannot write to directory"));
     }
  
     applyToTorrents(ids, [&newPath](BitTorrent::Torrent *const torrent)
     {
         if (!torrent->isAutoTMMEnabled())
             torrent->setDownloadPath(newPath);
     });
 }

References AccessDenied, anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), Conflict, BitTorrent::Torrent::isAutoTMMEnabled(), APIController::params(), APIController::requireParams(), and BitTorrent::Torrent::setDownloadPath().

Here is the call graph for this function:

◆ setForceStartAction

void TorrentsController::setForceStartAction ( )

privateslot

Definition at line 1010 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "value"});
  
     const bool value {parseBool(params()["value"]).value_or(false)};
     const QStringList hashes {params()["hashes"].split('|')};
     applyToTorrents(hashes, [value](BitTorrent::Torrent *const torrent)
     {
         torrent->resume(value ? BitTorrent::TorrentOperatingMode::Forced : BitTorrent::TorrentOperatingMode::AutoManaged);
     });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), Utils::String::parseBool(), APIController::requireParams(), BitTorrent::Torrent::resume(), and anonymous_namespace{preferences.cpp}::value().

Here is the call graph for this function:

◆ setLocationAction

void TorrentsController::setLocationAction ( )

privateslot

Definition at line 1079 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "location"});
  
     const QStringList hashes {params()["hashes"].split('|')};
     const QString newLocation {params()["location"].trimmed()};
  
     if (newLocation.isEmpty())
         throw APIError(APIErrorType::BadParams, tr("Save path cannot be empty"));
  
     // try to create the location if it does not exist
     if (!QDir(newLocation).mkpath("."))
         throw APIError(APIErrorType::Conflict, tr("Cannot make save path"));
  
     // check permissions
     if (!QFileInfo(newLocation).isWritable())
         throw APIError(APIErrorType::AccessDenied, tr("Cannot write to directory"));
  
     applyToTorrents(hashes, [newLocation](BitTorrent::Torrent *const torrent)
     {
         LogMsg(tr("WebUI Set location: moving \"%1\", from \"%2\" to \"%3\"")
             .arg(torrent->name(), Utils::Fs::toNativePath(torrent->savePath()), Utils::Fs::toNativePath(newLocation)));
         torrent->setAutoTMMEnabled(false);
         torrent->setSavePath(Utils::Fs::expandPathAbs(newLocation));
     });
 }

References AccessDenied, anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), BadParams, Conflict, Utils::Fs::expandPathAbs(), LogMsg(), BitTorrent::Torrent::name(), APIController::params(), APIController::requireParams(), BitTorrent::Torrent::savePath(), BitTorrent::Torrent::setAutoTMMEnabled(), BitTorrent::Torrent::setSavePath(), and Utils::Fs::toNativePath().

Here is the call graph for this function:

◆ setSavePathAction

void TorrentsController::setSavePathAction ( )

privateslot

Definition at line 1106 of file torrentscontroller.cpp.

 {
     requireParams({"id", "path"});
  
     const QStringList ids {params()["id"].split('|')};
     const QString newPath {params()["path"]};
  
     if (newPath.isEmpty())
         throw APIError(APIErrorType::BadParams, tr("Save path cannot be empty"));
  
     // try to create the directory if it does not exist
     if (!QDir(newPath).mkpath("."))
         throw APIError(APIErrorType::Conflict, tr("Cannot create target directory"));
  
     // check permissions
     if (!QFileInfo(newPath).isWritable())
         throw APIError(APIErrorType::AccessDenied, tr("Cannot write to directory"));
  
     applyToTorrents(ids, [&newPath](BitTorrent::Torrent *const torrent)
     {
         if (!torrent->isAutoTMMEnabled())
             torrent->setSavePath(newPath);
     });
 }

References AccessDenied, anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), BadParams, Conflict, BitTorrent::Torrent::isAutoTMMEnabled(), APIController::params(), APIController::requireParams(), and BitTorrent::Torrent::setSavePath().

Here is the call graph for this function:

◆ setShareLimitsAction

void TorrentsController::setShareLimitsAction ( )

privateslot

Definition at line 970 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "ratioLimit", "seedingTimeLimit"});
  
     const qreal ratioLimit = params()["ratioLimit"].toDouble();
     const qlonglong seedingTimeLimit = params()["seedingTimeLimit"].toLongLong();
     const QStringList hashes = params()["hashes"].split('|');
  
     applyToTorrents(hashes, [ratioLimit, seedingTimeLimit](BitTorrent::Torrent *const torrent)
     {
         torrent->setRatioLimit(ratioLimit);
         torrent->setSeedingTimeLimit(seedingTimeLimit);
     });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), APIController::requireParams(), BitTorrent::Torrent::setRatioLimit(), and BitTorrent::Torrent::setSeedingTimeLimit().

Here is the call graph for this function:

◆ setSuperSeedingAction

void TorrentsController::setSuperSeedingAction ( )

privateslot

Definition at line 1001 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "value"});
  
     const bool value {parseBool(params()["value"]).value_or(false)};
     const QStringList hashes {params()["hashes"].split('|')};
     applyToTorrents(hashes, [value](BitTorrent::Torrent *const torrent) { torrent->setSuperSeeding(value); });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), Utils::String::parseBool(), APIController::requireParams(), BitTorrent::Torrent::setSuperSeeding(), and anonymous_namespace{preferences.cpp}::value().

Here is the call graph for this function:

◆ setUploadLimitAction

void TorrentsController::setUploadLimitAction ( )

privateslot

Definition at line 946 of file torrentscontroller.cpp.

 {
     requireParams({"hashes", "limit"});
  
     qlonglong limit = params()["limit"].toLongLong();
     if (limit == 0)
         limit = -1;
  
     const QStringList hashes {params()["hashes"].split('|')};
     applyToTorrents(hashes, [limit](BitTorrent::Torrent *const torrent) { torrent->setUploadLimit(limit); });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), APIController::requireParams(), and BitTorrent::Torrent::setUploadLimit().

Here is the call graph for this function:

◆ tagsAction

void TorrentsController::tagsAction ( )

privateslot

Definition at line 1351 of file torrentscontroller.cpp.

 {
     QJsonArray result;
     for (const QString &tag : asConst(BitTorrent::Session::instance()->tags()))
         result << tag;
     setResult(result);
 }

References asConst(), BitTorrent::Session::instance(), and APIController::setResult().

Here is the call graph for this function:

◆ toggleFirstLastPiecePrioAction

void TorrentsController::toggleFirstLastPiecePrioAction ( )

privateslot

Definition at line 993 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     const QStringList hashes {params()["hashes"].split('|')};
     applyToTorrents(hashes, [](BitTorrent::Torrent *const torrent) { torrent->toggleFirstLastPiecePriority(); });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), APIController::requireParams(), and BitTorrent::Torrent::toggleFirstLastPiecePriority().

Here is the call graph for this function:

◆ toggleSequentialDownloadAction

void TorrentsController::toggleSequentialDownloadAction ( )

privateslot

Definition at line 985 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     const QStringList hashes {params()["hashes"].split('|')};
     applyToTorrents(hashes, [](BitTorrent::Torrent *const torrent) { torrent->toggleSequentialDownload(); });
 }

References anonymous_namespace{torrentscontroller.cpp}::applyToTorrents(), APIController::params(), APIController::requireParams(), and BitTorrent::Torrent::toggleSequentialDownload().

Here is the call graph for this function:

◆ topPrioAction

void TorrentsController::topPrioAction ( )

privateslot

Definition at line 1057 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     if (!BitTorrent::Session::instance()->isQueueingSystemEnabled())
         throw APIError(APIErrorType::Conflict, tr("Torrent queueing must be enabled"));
  
     const QStringList hashes {params()["hashes"].split('|')};
     BitTorrent::Session::instance()->topTorrentsQueuePos(toTorrentIDs(hashes));
 }

References Conflict, BitTorrent::Session::instance(), APIController::params(), APIController::requireParams(), BitTorrent::Session::topTorrentsQueuePos(), and anonymous_namespace{torrentscontroller.cpp}::toTorrentIDs().

Here is the call graph for this function:

◆ trackersAction

void TorrentsController::trackersAction ( )

privateslot

Definition at line 452 of file torrentscontroller.cpp.

 {
     requireParams({"hash"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     const BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     QJsonArray trackerList = getStickyTrackers(torrent);
  
     for (const BitTorrent::TrackerEntry &tracker : asConst(torrent->trackers()))
     {
         trackerList << QJsonObject
         {
             {KEY_TRACKER_URL, tracker.url},
             {KEY_TRACKER_TIER, tracker.tier},
             {KEY_TRACKER_STATUS, static_cast<int>(tracker.status)},
             {KEY_TRACKER_MSG, tracker.message},
             {KEY_TRACKER_PEERS_COUNT, tracker.numPeers},
             {KEY_TRACKER_SEEDS_COUNT, tracker.numSeeds},
             {KEY_TRACKER_LEECHES_COUNT, tracker.numLeeches},
             {KEY_TRACKER_DOWNLOADED_COUNT, tracker.numDownloaded}
         };
     }
  
     setResult(trackerList);
 }

References asConst(), BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), anonymous_namespace{torrentscontroller.cpp}::getStickyTrackers(), BitTorrent::Session::instance(), KEY_TRACKER_DOWNLOADED_COUNT, KEY_TRACKER_LEECHES_COUNT, KEY_TRACKER_MSG, KEY_TRACKER_PEERS_COUNT, KEY_TRACKER_SEEDS_COUNT, KEY_TRACKER_STATUS, KEY_TRACKER_TIER, KEY_TRACKER_URL, NotFound, APIController::params(), APIController::requireParams(), APIController::setResult(), and BitTorrent::Torrent::trackers().

Here is the call graph for this function:

◆ uploadLimitAction

void TorrentsController::uploadLimitAction ( )

privateslot

Definition at line 910 of file torrentscontroller.cpp.

 {
     requireParams({"hashes"});
  
     const QStringList idList {params()["hashes"].split('|')};
     QJsonObject map;
     for (const QString &id : idList)
     {
         int limit = -1;
         const BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(BitTorrent::TorrentID::fromString(id));
         if (torrent)
             limit = torrent->uploadLimit();
         map[id] = limit;
     }
  
     setResult(map);
 }

References BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), APIController::params(), APIController::requireParams(), APIController::setResult(), and BitTorrent::Torrent::uploadLimit().

Here is the call graph for this function:

◆ webseedsAction

void TorrentsController::webseedsAction ( )

privateslot

Definition at line 485 of file torrentscontroller.cpp.

 {
     requireParams({"hash"});
  
     const auto id = BitTorrent::TorrentID::fromString(params()["hash"]);
     BitTorrent::Torrent *const torrent = BitTorrent::Session::instance()->findTorrent(id);
     if (!torrent)
         throw APIError(APIErrorType::NotFound);
  
     QJsonArray webSeedList;
     for (const QUrl &webseed : asConst(torrent->urlSeeds()))
     {
         webSeedList.append(QJsonObject
         {
             {KEY_WEBSEED_URL, webseed.toString()}
         });
     }
  
     setResult(webSeedList);
 }

References asConst(), BitTorrent::Session::findTorrent(), BitTorrent::TorrentID::fromString(), BitTorrent::Session::instance(), KEY_WEBSEED_URL, NotFound, APIController::params(), APIController::requireParams(), APIController::setResult(), and BitTorrent::Torrent::urlSeeds().

Here is the call graph for this function:

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

src/webui/api/torrentscontroller.h
src/webui/api/torrentscontroller.cpp

Public Member Functions

Private Slots

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ addAction

◆ addPeersAction

◆ addTagsAction

◆ addTrackersAction

◆ APIController()

◆ bottomPrioAction

◆ categoriesAction

◆ createCategoryAction

◆ createTagsAction

◆ decreasePrioAction

◆ deleteAction

◆ deleteTagsAction

◆ downloadLimitAction

◆ editCategoryAction

◆ editTrackerAction

◆ filePrioAction

◆ filesAction

◆ increasePrioAction

◆ infoAction

◆ pauseAction

◆ pieceHashesAction

◆ pieceStatesAction

◆ propertiesAction

◆ reannounceAction

◆ recheckAction

◆ removeCategoriesAction

◆ removeTagsAction

◆ removeTrackersAction

◆ renameAction

◆ renameFileAction

◆ renameFolderAction

◆ resumeAction

◆ setAutoManagementAction

◆ setCategoryAction

◆ setDownloadLimitAction

◆ setDownloadPathAction

◆ setForceStartAction

◆ setLocationAction

◆ setSavePathAction

◆ setShareLimitsAction

◆ setSuperSeedingAction

◆ setUploadLimitAction

◆ tagsAction

◆ toggleFirstLastPiecePrioAction

◆ toggleSequentialDownloadAction

◆ topPrioAction

◆ trackersAction

◆ uploadLimitAction

◆ webseedsAction