chris/harbour-sailfin
chris/harbour-sailfin
1
0
Fork 0
mirror of https://github.com/HenkKalkwater/harbour-sailfin.git synced 2025-09-05 10:12:46 +00:00
Code Issues Releases Wiki Activity

Refractor ApiClient and add support for body params

Browse source 
ApiClient was refractored to use PIMPL. This is mainly done to reduce
compile times whenever the implementation of ApiClient itself changes,
since a lot of files include it.

The loaders have gained support for body parameters, this was somehow
omitted before.
This commit is contained in:
Chris Josten 2021-09-03 03:47:25 +02:00
parent 1453cbbc63
commit 96ecd8e7d8
116 changed files with 4437 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

227
core/src/apiclient.cpp
View file

@ -20,51 +20,167 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
#include "JellyfinQt/apiclient.h"
#include "JellyfinQt/support/jsonconv.h"
#include "JellyfinQt/viewmodel/settings.h"
#include "JellyfinQt/websocket.h"
namespace Jellyfin {
class ApiClientPrivate {
public:
ApiClientPrivate(ApiClient *parent);
virtual ~ApiClientPrivate() {}
// Exposed properties
ViewModel::Settings *settings;
WebSocket *webSocket;
EventBus *eventbus;
CredentialsManager *credManager;
// Authentication-related variables
QString token;
QString baseUrl;
QString deviceName;
QString deviceId;
QString userId;
bool online = true;
QJsonObject deviceProfile;
QJsonObject playbackDeviceProfile;
QVariantList supportedCommands;
bool authenticated = false;
/**
* @brief Retrieves the device ID or generates a random one.
*/
QUuid retrieveDeviceId() const;
};
ApiClient::ApiClient(QObject *parent)
: QObject(parent),
m_webSocket(new WebSocket(this)),
m_eventbus(new EventBus(this)),
m_deviceName(QHostInfo::localHostName()) {
d_ptr(new ApiClientPrivate(this)) {
Q_D(ApiClient);
m_deviceId = Support::toString(retrieveDeviceId());
m_credManager = CredentialsManager::newInstance(this);
connect(m_credManager, &CredentialsManager::serversListed, this, &ApiClient::credManagerServersListed);
connect(m_credManager, &CredentialsManager::usersListed, this, &ApiClient::credManagerUsersListed);
connect(m_credManager, &CredentialsManager::tokenRetrieved, this, &ApiClient::credManagerTokenRetrieved);
d->deviceId = Support::toString(d->retrieveDeviceId());
d->deviceName = QHostInfo::localHostName();
d->credManager = CredentialsManager::newInstance(this);
connect(d->credManager, &CredentialsManager::serversListed, this, &ApiClient::credManagerServersListed);
connect(d->credManager, &CredentialsManager::usersListed, this, &ApiClient::credManagerUsersListed);
connect(d->credManager, &CredentialsManager::tokenRetrieved, this, &ApiClient::credManagerTokenRetrieved);
generateDeviceProfile();
}
ApiClient::~ApiClient() {
}
bool ApiClient::authenticated() const {
Q_D(const ApiClient);
return d->authenticated;
}
const QString &ApiClient::baseUrl() const {
Q_D(const ApiClient);
return d->baseUrl;
}
void ApiClient::setBaseUrl(const QString &url) {
Q_D(ApiClient);
d->baseUrl = url;
if (d->baseUrl.endsWith("/")) {
d->baseUrl.chop(1);
}
emit this->baseUrlChanged(d->baseUrl);
}
const QString &ApiClient::userId() const {
Q_D(const ApiClient);
return d->userId;
}
void ApiClient::setUserId(const QString &userId) {
Q_D(ApiClient);
d->userId = userId;
emit userIdChanged(userId);
}
const QString &ApiClient::deviceId() const {
Q_D(const ApiClient);
return d->deviceId;
}
EventBus *ApiClient::eventbus() const {
Q_D(const ApiClient);
return d->eventbus;
}
WebSocket *ApiClient::websocket() const {
Q_D(const ApiClient);
return d->webSocket;
}
QString ApiClient::version() const {
return QString(SAILFIN_VERSION);
}
bool ApiClient::online() const {
Q_D(const ApiClient);
return d->online;
}
const QString &ApiClient::token() const {
Q_D(const ApiClient);
return d->token;
}
ViewModel::Settings *ApiClient::settings() const {
Q_D(const ApiClient);
return d->settings;
}
QVariantList ApiClient::supportedCommands() const {
Q_D(const ApiClient);
return d->supportedCommands;
}
void ApiClient::setSupportedCommands(QVariantList newSupportedCommands) {
Q_D(ApiClient);
d->supportedCommands = newSupportedCommands;
emit supportedCommandsChanged();
}
const QJsonObject &ApiClient::deviceProfile() const {
Q_D(const ApiClient);
return d->deviceProfile;
}
const QJsonObject &ApiClient::playbackDeviceProfile() const {
Q_D(const ApiClient);
return d->playbackDeviceProfile;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// BASE HTTP METHODS //
////////////////////////////////////////////////////////////////////////////////////////////////////
void ApiClient::addBaseRequestHeaders(QNetworkRequest &request, const QString &path, const QUrlQuery &params) {
void ApiClient::addBaseRequestHeaders(QNetworkRequest &request, const QString &path, const QUrlQuery &params) const {
Q_D(const ApiClient);
addTokenHeader(request);
request.setRawHeader("Accept", "application/json;"); // profile=\"CamelCase\"");
request.setHeader(QNetworkRequest::UserAgentHeader, QString("Sailfin/%1").arg(version()));
QString url = this->m_baseUrl + path;
QString url = d->baseUrl + path;
if (!params.isEmpty()) url += "?" + params.toString(QUrl::EncodeReserved);
request.setUrl(url);
}
void ApiClient::addTokenHeader(QNetworkRequest &request) {
void ApiClient::addTokenHeader(QNetworkRequest &request) const {
Q_D(const ApiClient);
QString authentication = "MediaBrowser ";
authentication += "Client=\"Sailfin\"";
authentication += ", Device=\"" + m_deviceName + "\"";
authentication += ", DeviceId=\"" + m_deviceId + "\"";
authentication += ", Device=\"" + d->deviceName + "\"";
authentication += ", DeviceId=\"" + d->deviceId + "\"";
authentication += ", Version=\"" + version() + "\"";
if (m_authenticated) {
authentication += ", token=\"" + m_token + "\"";
if (d->authenticated) {
authentication += ", token=\"" + d->token + "\"";
}
request.setRawHeader("X-Emby-Authorization", authentication.toUtf8());
}
@ -88,15 +204,29 @@ QNetworkReply *ApiClient::post(const QString &path, const QJsonDocument &data, c
}
}
QNetworkReply *ApiClient::post(const QString &path, const QByteArray &data, const QUrlQuery &params) {
QNetworkRequest req;
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
addBaseRequestHeaders(req, path, params);
qDebug() << "POST " << req.url();
if (data.isEmpty())
return m_naManager.post(req, QByteArray());
else {
return m_naManager.post(req, data);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Nice to have methods //
////////////////////////////////////////////////////////////////////////////////////////////////////
void ApiClient::restoreSavedSession(){
m_credManager->listServers();
Q_D(ApiClient);
d->credManager->listServers();
}
void ApiClient::credManagerServersListed(QStringList servers) {
Q_D(ApiClient);
qDebug() << "Servers listed: " << servers;
if (servers.size() == 0) {
emit this->setupRequired();
@ -105,12 +235,13 @@ void ApiClient::credManagerServersListed(QStringList servers) {
//FIXME: support multiple servers
QString server = servers[0];
this->m_baseUrl = server;
d->baseUrl = server;
qDebug() << "Chosen server: " << server;
m_credManager->listUsers(server);
d->credManager->listUsers(server);
}
void ApiClient::credManagerUsersListed(const QString &server, QStringList users) {
Q_D(ApiClient);
if (users.size() == 0) {
emit this->setupRequired();
return;
@ -119,10 +250,11 @@ void ApiClient::credManagerUsersListed(const QString &server, QStringList users)
QString user = users[0];
qDebug() << "Chosen user: " << user;
m_credManager->get(server, user);
d->credManager->get(server, user);
}
void ApiClient::credManagerTokenRetrieved(const QString &server, const QString &user, const QString &token) {
this->m_token = token;
Q_D(ApiClient);
d->token = token;
qDebug() << "Token retreived, logged in as user " << user;
this->setUserId(user);
this->setAuthenticated(true);
@ -130,10 +262,11 @@ void ApiClient::credManagerTokenRetrieved(const QString &server, const QString &
}
void ApiClient::setupConnection() {
Q_D(ApiClient);
// First detect redirects:
// Note that this is done without calling JellyfinApiClient::get since that automatically includes the base_url,
// which is something we want to avoid here.
QNetworkRequest req = QNetworkRequest(m_baseUrl);
QNetworkRequest req = QNetworkRequest(d->baseUrl);
#if QT_VERSION >= QT_VERSION_CHECK(5, 9, 0)
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
#else
@ -185,27 +318,29 @@ void ApiClient::getBrandingConfiguration() {
}
void ApiClient::authenticate(QString username, QString password, bool storeCredentials) {
Q_D(ApiClient);
QJsonObject requestData;
requestData["Username"] = username;
requestData["Pw"] = password;
QNetworkReply *rep = post("/Users/authenticatebyname", QJsonDocument(requestData));
connect(rep, &QNetworkReply::finished, this, [rep, username, storeCredentials, this]() {
Q_D(ApiClient);
int status = rep->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
qDebug() << "Got reply with status code " << status;
if (status >= 200 && status < 300) {
QJsonObject authInfo = QJsonDocument::fromJson(rep->readAll()).object();
this->m_token = authInfo["AccessToken"].toString();
d->token = authInfo["AccessToken"].toString();
// Fool this class's addRequestheaders to add the token, without
// notifying QML that we're authenticated, to prevent other requests going first.
this->m_authenticated = true;
d->authenticated = true;
this->setUserId(authInfo["User"].toObject()["Id"].toString());
this->postCapabilities();
this->setAuthenticated(true);
if (storeCredentials) {
m_credManager->store(this->m_baseUrl, this->m_userId, this->m_token);
d->credManager->store(d->baseUrl, d->userId, d->token);
}
} else if(status >= 400 && status < 500) {
if (status == 401) {
@ -222,7 +357,8 @@ void ApiClient::authenticate(QString username, QString password, bool storeCrede
void ApiClient::deleteSession() {
QNetworkReply *rep = post("/Sessions/Logout");
connect(rep, &QNetworkReply::finished, this, [rep, this] {
m_credManager->remove(m_baseUrl, m_userId);
Q_D(ApiClient);
d->credManager->remove(d->baseUrl, d->userId);
this->setAuthenticated(false);
emit this->setupRequired();
rep->deleteLater();
@ -230,12 +366,13 @@ void ApiClient::deleteSession() {
}
void ApiClient::postCapabilities() {
Q_D(const ApiClient);
QJsonObject capabilities;
QList<DTO::GeneralCommandType> supportedCommands;
supportedCommands.reserve(m_supportedCommands.size());
for (int i = 0; i < m_supportedCommands.size(); i++) {
if (m_supportedCommands[i].canConvert<DTO::GeneralCommandType>()) {
supportedCommands.append(m_supportedCommands[i].value<DTO::GeneralCommandType>());
supportedCommands.reserve(d->supportedCommands.size());
for (int i = 0; i < d->supportedCommands.size(); i++) {
if (d->supportedCommands[i].canConvert<DTO::GeneralCommandType>()) {
supportedCommands.append(d->supportedCommands[i].value<DTO::GeneralCommandType>());
}
}
QList<int> foo = {1, 2, 3};
@ -248,20 +385,22 @@ void ApiClient::postCapabilities() {
capabilities["SupportsContentUploading"] = false;
capabilities["AppStoreUrl"] = "https://chris.netsoj.nl/projects/harbour-sailfin";
capabilities["IconUrl"] = "https://chris.netsoj.nl/static/img/logo.png";
capabilities["DeviceProfile"] = m_deviceProfile;
capabilities["DeviceProfile"] = d->deviceProfile;
QNetworkReply *rep = post("/Sessions/Capabilities/Full", QJsonDocument(capabilities));
setDefaultErrorHandler(rep);
}
QString ApiClient::downloadUrl(const QString &itemId) const {
return m_baseUrl + "/Items/" + itemId + "/Download?api_key=" + this->m_token;
Q_D(const ApiClient);
return d->baseUrl + "/Items/" + itemId + "/Download?api_key=" + d->token;
}
void ApiClient::generateDeviceProfile() {
Q_D(ApiClient);
QJsonObject root = Model::DeviceProfile::generateProfile();
m_playbackDeviceProfile = QJsonObject(root);
root["Name"] = m_deviceName;
root["Id"] = m_deviceId;
d->playbackDeviceProfile = QJsonObject(root);
root["Name"] = d->deviceName;
root["Id"] = d->deviceId;
root["FriendlyName"] = QSysInfo::prettyProductName();
QJsonArray playableMediaTypes;
playableMediaTypes.append("Audio");
@ -269,7 +408,7 @@ void ApiClient::generateDeviceProfile() {
playableMediaTypes.append("Photo");
root["PlayableMediaTypes"] = playableMediaTypes;
m_deviceProfile = root;
d->deviceProfile = root;
emit deviceProfileChanged();
}
@ -291,12 +430,13 @@ void ApiClient::onUserDataChanged(const QString &itemId, UserData *userData) {
}
void ApiClient::setAuthenticated(bool authenticated) {
this->m_authenticated = authenticated;
if (authenticated) m_webSocket->open();
Q_D(ApiClient);
d->authenticated = authenticated;
if (authenticated) d->webSocket->open();
emit authenticatedChanged(authenticated);
}
QUuid ApiClient::retrieveDeviceId() {
QUuid ApiClientPrivate::retrieveDeviceId() const {
// This should probably not block the main thread, but on the other side,
// the file is not too big.
QString path = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
@ -336,4 +476,15 @@ QUuid ApiClient::retrieveDeviceId() {
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// PRIVATE //
////////////////////////////////////////////////////////////////////////////////////////////////////
ApiClientPrivate::ApiClientPrivate(ApiClient *apiClient)
: settings(new ViewModel::Settings(apiClient)),
webSocket(new WebSocket(apiClient)),
eventbus(new EventBus(apiClient)) {
}
}

1
core/src/jellyfin.cpp
View file

@ -29,6 +29,7 @@ void registerTypes(const char *uri) {
qmlRegisterUncreatableType<EventBus>(uri, 1, 0, "EventBus", "Obtain one via your ApiClient");
qmlRegisterUncreatableType<WebSocket>(uri, 1, 0, "WebSocket", "Obtain one via your ApiClient");
qmlRegisterUncreatableType<ViewModel::MediaStream>(uri, 1, 0, "MediaStream", "Obtain one via an Item");
qmlRegisterUncreatableType<ViewModel::Settings>(uri, 1, 0, "Settings", "Obtain one via your ApiClient");
qmlRegisterUncreatableType<ViewModel::UserData>(uri, 1, 0, "UserData", "Obtain one via an Item");
// AbstractItemModels

10
core/src/loader/http/activitylog.cpp
View file

@ -66,6 +66,16 @@ QUrlQuery GetLogEntriesLoader::query(const GetLogEntriesParams &params) const {
return result;
}
QByteArray GetLogEntriesLoader::body(const GetLogEntriesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLogEntriesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/apikey.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetKeysLoader::query(const GetKeysParams &params) const {
return result;
}
QByteArray GetKeysLoader::body(const GetKeysParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetKeysLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/artists.cpp
View file

@ -144,6 +144,16 @@ QUrlQuery GetArtistsLoader::query(const GetArtistsParams &params) const {
return result;
}
QByteArray GetArtistsLoader::body(const GetArtistsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetArtistsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetArtistByNameLoader::GetArtistByNameLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetArtistByNameParams>(apiClient) {}
@ -166,6 +176,16 @@ QUrlQuery GetArtistByNameLoader::query(const GetArtistByNameParams &params) cons
return result;
}
QByteArray GetArtistByNameLoader::body(const GetArtistByNameParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetArtistByNameLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetAlbumArtistsLoader::GetAlbumArtistsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetAlbumArtistsParams>(apiClient) {}
@ -275,6 +295,16 @@ QUrlQuery GetAlbumArtistsLoader::query(const GetAlbumArtistsParams &params) cons
return result;
}
QByteArray GetAlbumArtistsLoader::body(const GetAlbumArtistsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetAlbumArtistsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/branding.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetBrandingOptionsLoader::query(const GetBrandingOptionsParams &params
return result;
}
QByteArray GetBrandingOptionsLoader::body(const GetBrandingOptionsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetBrandingOptionsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetBrandingCssLoader::GetBrandingCssLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetBrandingCssParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetBrandingCssLoader::query(const GetBrandingCssParams &params) const
return result;
}
QByteArray GetBrandingCssLoader::body(const GetBrandingCssParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetBrandingCssLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetBrandingCss_2Loader::GetBrandingCss_2Loader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetBrandingCss_2Params>(apiClient) {}
@ -92,6 +112,16 @@ QUrlQuery GetBrandingCss_2Loader::query(const GetBrandingCss_2Params &params) co
return result;
}
QByteArray GetBrandingCss_2Loader::body(const GetBrandingCss_2Params &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetBrandingCss_2Loader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

50
core/src/loader/http/channels.cpp
View file

@ -72,6 +72,16 @@ QUrlQuery GetChannelsLoader::query(const GetChannelsParams &params) const {
return result;
}
QByteArray GetChannelsLoader::body(const GetChannelsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetChannelsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetChannelFeaturesLoader::GetChannelFeaturesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<ChannelFeatures, GetChannelFeaturesParams>(apiClient) {}
@ -91,6 +101,16 @@ QUrlQuery GetChannelFeaturesLoader::query(const GetChannelFeaturesParams &params
return result;
}
QByteArray GetChannelFeaturesLoader::body(const GetChannelFeaturesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetChannelFeaturesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetChannelItemsLoader::GetChannelItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetChannelItemsParams>(apiClient) {}
@ -134,6 +154,16 @@ QUrlQuery GetChannelItemsLoader::query(const GetChannelItemsParams &params) cons
return result;
}
QByteArray GetChannelItemsLoader::body(const GetChannelItemsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetChannelItemsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetAllChannelFeaturesLoader::GetAllChannelFeaturesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ChannelFeatures>, GetAllChannelFeaturesParams>(apiClient) {}
@ -153,6 +183,16 @@ QUrlQuery GetAllChannelFeaturesLoader::query(const GetAllChannelFeaturesParams &
return result;
}
QByteArray GetAllChannelFeaturesLoader::body(const GetAllChannelFeaturesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetAllChannelFeaturesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetLatestChannelItemsLoader::GetLatestChannelItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetLatestChannelItemsParams>(apiClient) {}
@ -190,6 +230,16 @@ QUrlQuery GetLatestChannelItemsLoader::query(const GetLatestChannelItemsParams &
return result;
}
QByteArray GetLatestChannelItemsLoader::body(const GetLatestChannelItemsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLatestChannelItemsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/collection.cpp
View file

@ -66,6 +66,16 @@ QUrlQuery CreateCollectionLoader::query(const CreateCollectionParams &params) co
return result;
}
QByteArray CreateCollectionLoader::body(const CreateCollectionParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation CreateCollectionLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/configuration.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetConfigurationLoader::query(const GetConfigurationParams &params) co
return result;
}
QByteArray GetConfigurationLoader::body(const GetConfigurationParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetConfigurationLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetNamedConfigurationLoader::GetNamedConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetNamedConfigurationParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetNamedConfigurationLoader::query(const GetNamedConfigurationParams &
return result;
}
QByteArray GetNamedConfigurationLoader::body(const GetNamedConfigurationParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetNamedConfigurationLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetDefaultMetadataOptionsLoader::GetDefaultMetadataOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<MetadataOptions, GetDefaultMetadataOptionsParams>(apiClient) {}
@ -92,6 +112,16 @@ QUrlQuery GetDefaultMetadataOptionsLoader::query(const GetDefaultMetadataOptions
return result;
}
QByteArray GetDefaultMetadataOptionsLoader::body(const GetDefaultMetadataOptionsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDefaultMetadataOptionsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/dashboard.cpp
View file

@ -60,6 +60,16 @@ QUrlQuery GetConfigurationPagesLoader::query(const GetConfigurationPagesParams &
return result;
}
QByteArray GetConfigurationPagesLoader::body(const GetConfigurationPagesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetConfigurationPagesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/devices.cpp
View file

@ -60,6 +60,16 @@ QUrlQuery GetDevicesLoader::query(const GetDevicesParams &params) const {
return result;
}
QByteArray GetDevicesLoader::body(const GetDevicesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDevicesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetDeviceInfoLoader::GetDeviceInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<DeviceInfo, GetDeviceInfoParams>(apiClient) {}
@ -80,6 +90,16 @@ QUrlQuery GetDeviceInfoLoader::query(const GetDeviceInfoParams &params) const {
return result;
}
QByteArray GetDeviceInfoLoader::body(const GetDeviceInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDeviceInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetDeviceOptionsLoader::GetDeviceOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<DeviceOptions, GetDeviceOptionsParams>(apiClient) {}
@ -100,6 +120,16 @@ QUrlQuery GetDeviceOptionsLoader::query(const GetDeviceOptionsParams &params) co
return result;
}
QByteArray GetDeviceOptionsLoader::body(const GetDeviceOptionsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDeviceOptionsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/displaypreferences.cpp
View file

@ -56,6 +56,16 @@ QUrlQuery GetDisplayPreferencesLoader::query(const GetDisplayPreferencesParams &
return result;
}
QByteArray GetDisplayPreferencesLoader::body(const GetDisplayPreferencesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDisplayPreferencesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/dlna.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetProfileInfosLoader::query(const GetProfileInfosParams &params) cons
return result;
}
QByteArray GetProfileInfosLoader::body(const GetProfileInfosParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetProfileInfosLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetProfileLoader::GetProfileLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<DeviceProfile, GetProfileParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetProfileLoader::query(const GetProfileParams &params) const {
return result;
}
QByteArray GetProfileLoader::body(const GetProfileParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetProfileLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetDefaultProfileLoader::GetDefaultProfileLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<DeviceProfile, GetDefaultProfileParams>(apiClient) {}
@ -92,6 +112,16 @@ QUrlQuery GetDefaultProfileLoader::query(const GetDefaultProfileParams &params)
return result;
}
QByteArray GetDefaultProfileLoader::body(const GetDefaultProfileParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDefaultProfileLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

50
core/src/loader/http/environment.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetDefaultDirectoryBrowserLoader::query(const GetDefaultDirectoryBrows
return result;
}
QByteArray GetDefaultDirectoryBrowserLoader::body(const GetDefaultDirectoryBrowserParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDefaultDirectoryBrowserLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetDirectoryContentsLoader::GetDirectoryContentsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<FileSystemEntryInfo>, GetDirectoryContentsParams>(apiClient) {}
@ -80,6 +90,16 @@ QUrlQuery GetDirectoryContentsLoader::query(const GetDirectoryContentsParams &pa
return result;
}
QByteArray GetDirectoryContentsLoader::body(const GetDirectoryContentsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDirectoryContentsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetDrivesLoader::GetDrivesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<FileSystemEntryInfo>, GetDrivesParams>(apiClient) {}
@ -99,6 +119,16 @@ QUrlQuery GetDrivesLoader::query(const GetDrivesParams &params) const {
return result;
}
QByteArray GetDrivesLoader::body(const GetDrivesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDrivesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetNetworkSharesLoader::GetNetworkSharesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<FileSystemEntryInfo>, GetNetworkSharesParams>(apiClient) {}
@ -118,6 +148,16 @@ QUrlQuery GetNetworkSharesLoader::query(const GetNetworkSharesParams &params) co
return result;
}
QByteArray GetNetworkSharesLoader::body(const GetNetworkSharesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetNetworkSharesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetParentPathLoader::GetParentPathLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetParentPathParams>(apiClient) {}
@ -138,6 +178,16 @@ QUrlQuery GetParentPathLoader::query(const GetParentPathParams &params) const {
return result;
}
QByteArray GetParentPathLoader::body(const GetParentPathParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetParentPathLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/filter.cpp
View file

@ -66,6 +66,16 @@ QUrlQuery GetQueryFiltersLegacyLoader::query(const GetQueryFiltersLegacyParams &
return result;
}
QByteArray GetQueryFiltersLegacyLoader::body(const GetQueryFiltersLegacyParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetQueryFiltersLegacyLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetQueryFiltersLoader::GetQueryFiltersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QueryFilters, GetQueryFiltersParams>(apiClient) {}
@ -115,6 +125,16 @@ QUrlQuery GetQueryFiltersLoader::query(const GetQueryFiltersParams &params) cons
return result;
}
QByteArray GetQueryFiltersLoader::body(const GetQueryFiltersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetQueryFiltersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/genres.cpp
View file

@ -102,6 +102,16 @@ QUrlQuery GetGenresLoader::query(const GetGenresParams &params) const {
return result;
}
QByteArray GetGenresLoader::body(const GetGenresParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetGenresLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetGenreLoader::GetGenreLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetGenreParams>(apiClient) {}
@ -124,6 +134,16 @@ QUrlQuery GetGenreLoader::query(const GetGenreParams &params) const {
return result;
}
QByteArray GetGenreLoader::body(const GetGenreParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetGenreLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/image.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetItemImageInfosLoader::query(const GetItemImageInfosParams &params)
return result;
}
QByteArray GetItemImageInfosLoader::body(const GetItemImageInfosParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetItemImageInfosLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/imagebyname.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetGeneralImagesLoader::query(const GetGeneralImagesParams &params) co
return result;
}
QByteArray GetGeneralImagesLoader::body(const GetGeneralImagesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetGeneralImagesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetMediaInfoImagesLoader::GetMediaInfoImagesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ImageByNameInfo>, GetMediaInfoImagesParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetMediaInfoImagesLoader::query(const GetMediaInfoImagesParams &params
return result;
}
QByteArray GetMediaInfoImagesLoader::body(const GetMediaInfoImagesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetMediaInfoImagesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetRatingImagesLoader::GetRatingImagesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ImageByNameInfo>, GetRatingImagesParams>(apiClient) {}
@ -92,6 +112,16 @@ QUrlQuery GetRatingImagesLoader::query(const GetRatingImagesParams &params) cons
return result;
}
QByteArray GetRatingImagesLoader::body(const GetRatingImagesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRatingImagesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

70
core/src/loader/http/instantmix.cpp
View file

@ -75,6 +75,16 @@ QUrlQuery GetInstantMixFromAlbumLoader::query(const GetInstantMixFromAlbumParams
return result;
}
QByteArray GetInstantMixFromAlbumLoader::body(const GetInstantMixFromAlbumParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetInstantMixFromAlbumLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetInstantMixFromArtistsLoader::GetInstantMixFromArtistsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromArtistsParams>(apiClient) {}
@ -115,6 +125,16 @@ QUrlQuery GetInstantMixFromArtistsLoader::query(const GetInstantMixFromArtistsPa
return result;
}
QByteArray GetInstantMixFromArtistsLoader::body(const GetInstantMixFromArtistsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetInstantMixFromArtistsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetInstantMixFromItemLoader::GetInstantMixFromItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromItemParams>(apiClient) {}
@ -155,6 +175,16 @@ QUrlQuery GetInstantMixFromItemLoader::query(const GetInstantMixFromItemParams &
return result;
}
QByteArray GetInstantMixFromItemLoader::body(const GetInstantMixFromItemParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetInstantMixFromItemLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetInstantMixFromMusicGenresLoader::GetInstantMixFromMusicGenresLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromMusicGenresParams>(apiClient) {}
@ -195,6 +225,16 @@ QUrlQuery GetInstantMixFromMusicGenresLoader::query(const GetInstantMixFromMusic
return result;
}
QByteArray GetInstantMixFromMusicGenresLoader::body(const GetInstantMixFromMusicGenresParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetInstantMixFromMusicGenresLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetInstantMixFromMusicGenreLoader::GetInstantMixFromMusicGenreLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromMusicGenreParams>(apiClient) {}
@ -235,6 +275,16 @@ QUrlQuery GetInstantMixFromMusicGenreLoader::query(const GetInstantMixFromMusicG
return result;
}
QByteArray GetInstantMixFromMusicGenreLoader::body(const GetInstantMixFromMusicGenreParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetInstantMixFromMusicGenreLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetInstantMixFromPlaylistLoader::GetInstantMixFromPlaylistLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromPlaylistParams>(apiClient) {}
@ -275,6 +325,16 @@ QUrlQuery GetInstantMixFromPlaylistLoader::query(const GetInstantMixFromPlaylist
return result;
}
QByteArray GetInstantMixFromPlaylistLoader::body(const GetInstantMixFromPlaylistParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetInstantMixFromPlaylistLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetInstantMixFromSongLoader::GetInstantMixFromSongLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromSongParams>(apiClient) {}
@ -315,6 +375,16 @@ QUrlQuery GetInstantMixFromSongLoader::query(const GetInstantMixFromSongParams &
return result;
}
QByteArray GetInstantMixFromSongLoader::body(const GetInstantMixFromSongParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetInstantMixFromSongLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

100
core/src/loader/http/itemlookup.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetExternalIdInfosLoader::query(const GetExternalIdInfosParams &params
return result;
}
QByteArray GetExternalIdInfosLoader::body(const GetExternalIdInfosParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetExternalIdInfosLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetBookRemoteSearchResultsLoader::GetBookRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetBookRemoteSearchResultsParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetBookRemoteSearchResultsLoader::query(const GetBookRemoteSearchResul
return result;
}
QByteArray GetBookRemoteSearchResultsLoader::body(const GetBookRemoteSearchResultsParams &params) const {
return Support::toString<QSharedPointer<BookInfoRemoteSearchQuery>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetBookRemoteSearchResultsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetBoxSetRemoteSearchResultsLoader::GetBoxSetRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetBoxSetRemoteSearchResultsParams>(apiClient) {}
@ -92,6 +112,16 @@ QUrlQuery GetBoxSetRemoteSearchResultsLoader::query(const GetBoxSetRemoteSearchR
return result;
}
QByteArray GetBoxSetRemoteSearchResultsLoader::body(const GetBoxSetRemoteSearchResultsParams &params) const {
return Support::toString<QSharedPointer<BoxSetInfoRemoteSearchQuery>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetBoxSetRemoteSearchResultsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetMovieRemoteSearchResultsLoader::GetMovieRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetMovieRemoteSearchResultsParams>(apiClient) {}
@ -111,6 +141,16 @@ QUrlQuery GetMovieRemoteSearchResultsLoader::query(const GetMovieRemoteSearchRes
return result;
}
QByteArray GetMovieRemoteSearchResultsLoader::body(const GetMovieRemoteSearchResultsParams &params) const {
return Support::toString<QSharedPointer<MovieInfoRemoteSearchQuery>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetMovieRemoteSearchResultsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetMusicAlbumRemoteSearchResultsLoader::GetMusicAlbumRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetMusicAlbumRemoteSearchResultsParams>(apiClient) {}
@ -130,6 +170,16 @@ QUrlQuery GetMusicAlbumRemoteSearchResultsLoader::query(const GetMusicAlbumRemot
return result;
}
QByteArray GetMusicAlbumRemoteSearchResultsLoader::body(const GetMusicAlbumRemoteSearchResultsParams &params) const {
return Support::toString<QSharedPointer<AlbumInfoRemoteSearchQuery>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetMusicAlbumRemoteSearchResultsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetMusicArtistRemoteSearchResultsLoader::GetMusicArtistRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetMusicArtistRemoteSearchResultsParams>(apiClient) {}
@ -149,6 +199,16 @@ QUrlQuery GetMusicArtistRemoteSearchResultsLoader::query(const GetMusicArtistRem
return result;
}
QByteArray GetMusicArtistRemoteSearchResultsLoader::body(const GetMusicArtistRemoteSearchResultsParams &params) const {
return Support::toString<QSharedPointer<ArtistInfoRemoteSearchQuery>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetMusicArtistRemoteSearchResultsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetMusicVideoRemoteSearchResultsLoader::GetMusicVideoRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetMusicVideoRemoteSearchResultsParams>(apiClient) {}
@ -168,6 +228,16 @@ QUrlQuery GetMusicVideoRemoteSearchResultsLoader::query(const GetMusicVideoRemot
return result;
}
QByteArray GetMusicVideoRemoteSearchResultsLoader::body(const GetMusicVideoRemoteSearchResultsParams &params) const {
return Support::toString<QSharedPointer<MusicVideoInfoRemoteSearchQuery>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetMusicVideoRemoteSearchResultsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetPersonRemoteSearchResultsLoader::GetPersonRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetPersonRemoteSearchResultsParams>(apiClient) {}
@ -187,6 +257,16 @@ QUrlQuery GetPersonRemoteSearchResultsLoader::query(const GetPersonRemoteSearchR
return result;
}
QByteArray GetPersonRemoteSearchResultsLoader::body(const GetPersonRemoteSearchResultsParams &params) const {
return Support::toString<QSharedPointer<PersonLookupInfoRemoteSearchQuery>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetPersonRemoteSearchResultsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetSeriesRemoteSearchResultsLoader::GetSeriesRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetSeriesRemoteSearchResultsParams>(apiClient) {}
@ -206,6 +286,16 @@ QUrlQuery GetSeriesRemoteSearchResultsLoader::query(const GetSeriesRemoteSearchR
return result;
}
QByteArray GetSeriesRemoteSearchResultsLoader::body(const GetSeriesRemoteSearchResultsParams &params) const {
return Support::toString<QSharedPointer<SeriesInfoRemoteSearchQuery>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetSeriesRemoteSearchResultsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetTrailerRemoteSearchResultsLoader::GetTrailerRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetTrailerRemoteSearchResultsParams>(apiClient) {}
@ -225,6 +315,16 @@ QUrlQuery GetTrailerRemoteSearchResultsLoader::query(const GetTrailerRemoteSearc
return result;
}
QByteArray GetTrailerRemoteSearchResultsLoader::body(const GetTrailerRemoteSearchResultsParams &params) const {
return Support::toString<QSharedPointer<TrailerInfoRemoteSearchQuery>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetTrailerRemoteSearchResultsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/items.cpp
View file

@ -294,6 +294,16 @@ QUrlQuery GetItemsLoader::query(const GetItemsParams &params) const {
return result;
}
QByteArray GetItemsLoader::body(const GetItemsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetItemsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetItemsByUserIdLoader::GetItemsByUserIdLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetItemsByUserIdParams>(apiClient) {}
@ -550,6 +560,16 @@ QUrlQuery GetItemsByUserIdLoader::query(const GetItemsByUserIdParams &params) co
return result;
}
QByteArray GetItemsByUserIdLoader::body(const GetItemsByUserIdParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetItemsByUserIdLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetResumeItemsLoader::GetResumeItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetResumeItemsParams>(apiClient) {}
@ -608,6 +628,16 @@ QUrlQuery GetResumeItemsLoader::query(const GetResumeItemsParams &params) const
return result;
}
QByteArray GetResumeItemsLoader::body(const GetResumeItemsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetResumeItemsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/itemupdate.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetMetadataEditorInfoLoader::query(const GetMetadataEditorInfoParams &
return result;
}
QByteArray GetMetadataEditorInfoLoader::body(const GetMetadataEditorInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetMetadataEditorInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

150
core/src/loader/http/library.cpp
View file

@ -66,6 +66,16 @@ QUrlQuery GetSimilarAlbumsLoader::query(const GetSimilarAlbumsParams &params) co
return result;
}
QByteArray GetSimilarAlbumsLoader::body(const GetSimilarAlbumsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSimilarAlbumsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSimilarArtistsLoader::GetSimilarArtistsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetSimilarArtistsParams>(apiClient) {}
@ -97,6 +107,16 @@ QUrlQuery GetSimilarArtistsLoader::query(const GetSimilarArtistsParams &params)
return result;
}
QByteArray GetSimilarArtistsLoader::body(const GetSimilarArtistsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSimilarArtistsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetAncestorsLoader::GetAncestorsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<BaseItemDto>, GetAncestorsParams>(apiClient) {}
@ -119,6 +139,16 @@ QUrlQuery GetAncestorsLoader::query(const GetAncestorsParams &params) const {
return result;
}
QByteArray GetAncestorsLoader::body(const GetAncestorsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetAncestorsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetCriticReviewsLoader::GetCriticReviewsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetCriticReviewsParams>(apiClient) {}
@ -138,6 +168,16 @@ QUrlQuery GetCriticReviewsLoader::query(const GetCriticReviewsParams &params) co
return result;
}
QByteArray GetCriticReviewsLoader::body(const GetCriticReviewsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetCriticReviewsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSimilarItemsLoader::GetSimilarItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetSimilarItemsParams>(apiClient) {}
@ -169,6 +209,16 @@ QUrlQuery GetSimilarItemsLoader::query(const GetSimilarItemsParams &params) cons
return result;
}
QByteArray GetSimilarItemsLoader::body(const GetSimilarItemsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSimilarItemsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetThemeMediaLoader::GetThemeMediaLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<AllThemeMediaResult, GetThemeMediaParams>(apiClient) {}
@ -194,6 +244,16 @@ QUrlQuery GetThemeMediaLoader::query(const GetThemeMediaParams &params) const {
return result;
}
QByteArray GetThemeMediaLoader::body(const GetThemeMediaParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetThemeMediaLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetThemeSongsLoader::GetThemeSongsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<ThemeMediaResult, GetThemeSongsParams>(apiClient) {}
@ -219,6 +279,16 @@ QUrlQuery GetThemeSongsLoader::query(const GetThemeSongsParams &params) const {
return result;
}
QByteArray GetThemeSongsLoader::body(const GetThemeSongsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetThemeSongsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetThemeVideosLoader::GetThemeVideosLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<ThemeMediaResult, GetThemeVideosParams>(apiClient) {}
@ -244,6 +314,16 @@ QUrlQuery GetThemeVideosLoader::query(const GetThemeVideosParams &params) const
return result;
}
QByteArray GetThemeVideosLoader::body(const GetThemeVideosParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetThemeVideosLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetItemCountsLoader::GetItemCountsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<ItemCounts, GetItemCountsParams>(apiClient) {}
@ -269,6 +349,16 @@ QUrlQuery GetItemCountsLoader::query(const GetItemCountsParams &params) const {
return result;
}
QByteArray GetItemCountsLoader::body(const GetItemCountsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetItemCountsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetLibraryOptionsInfoLoader::GetLibraryOptionsInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<LibraryOptionsResultDto, GetLibraryOptionsInfoParams>(apiClient) {}
@ -294,6 +384,16 @@ QUrlQuery GetLibraryOptionsInfoLoader::query(const GetLibraryOptionsInfoParams &
return result;
}
QByteArray GetLibraryOptionsInfoLoader::body(const GetLibraryOptionsInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLibraryOptionsInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetMediaFoldersLoader::GetMediaFoldersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetMediaFoldersParams>(apiClient) {}
@ -316,6 +416,16 @@ QUrlQuery GetMediaFoldersLoader::query(const GetMediaFoldersParams &params) cons
return result;
}
QByteArray GetMediaFoldersLoader::body(const GetMediaFoldersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetMediaFoldersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetPhysicalPathsLoader::GetPhysicalPathsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QStringList, GetPhysicalPathsParams>(apiClient) {}
@ -335,6 +445,16 @@ QUrlQuery GetPhysicalPathsLoader::query(const GetPhysicalPathsParams &params) co
return result;
}
QByteArray GetPhysicalPathsLoader::body(const GetPhysicalPathsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPhysicalPathsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSimilarMoviesLoader::GetSimilarMoviesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetSimilarMoviesParams>(apiClient) {}
@ -366,6 +486,16 @@ QUrlQuery GetSimilarMoviesLoader::query(const GetSimilarMoviesParams &params) co
return result;
}
QByteArray GetSimilarMoviesLoader::body(const GetSimilarMoviesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSimilarMoviesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSimilarShowsLoader::GetSimilarShowsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetSimilarShowsParams>(apiClient) {}
@ -397,6 +527,16 @@ QUrlQuery GetSimilarShowsLoader::query(const GetSimilarShowsParams &params) cons
return result;
}
QByteArray GetSimilarShowsLoader::body(const GetSimilarShowsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSimilarShowsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSimilarTrailersLoader::GetSimilarTrailersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetSimilarTrailersParams>(apiClient) {}
@ -428,6 +568,16 @@ QUrlQuery GetSimilarTrailersLoader::query(const GetSimilarTrailersParams &params
return result;
}
QByteArray GetSimilarTrailersLoader::body(const GetSimilarTrailersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSimilarTrailersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/librarystructure.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetVirtualFoldersLoader::query(const GetVirtualFoldersParams &params)
return result;
}
QByteArray GetVirtualFoldersLoader::body(const GetVirtualFoldersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetVirtualFoldersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

280
core/src/loader/http/livetv.cpp
View file

@ -57,6 +57,16 @@ QUrlQuery GetChannelMappingOptionsLoader::query(const GetChannelMappingOptionsPa
return result;
}
QByteArray GetChannelMappingOptionsLoader::body(const GetChannelMappingOptionsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetChannelMappingOptionsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
SetChannelMappingLoader::SetChannelMappingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<TunerChannelMapping, SetChannelMappingParams>(apiClient) {}
@ -76,6 +86,16 @@ QUrlQuery SetChannelMappingLoader::query(const SetChannelMappingParams &params)
return result;
}
QByteArray SetChannelMappingLoader::body(const SetChannelMappingParams &params) const {
return Support::toString<QSharedPointer<SetChannelMappingDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SetChannelMappingLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetLiveTvChannelsLoader::GetLiveTvChannelsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetLiveTvChannelsParams>(apiClient) {}
@ -158,6 +178,16 @@ QUrlQuery GetLiveTvChannelsLoader::query(const GetLiveTvChannelsParams &params)
return result;
}
QByteArray GetLiveTvChannelsLoader::body(const GetLiveTvChannelsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLiveTvChannelsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetChannelLoader::GetChannelLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetChannelParams>(apiClient) {}
@ -180,6 +210,16 @@ QUrlQuery GetChannelLoader::query(const GetChannelParams &params) const {
return result;
}
QByteArray GetChannelLoader::body(const GetChannelParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetChannelLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetGuideInfoLoader::GetGuideInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<GuideInfo, GetGuideInfoParams>(apiClient) {}
@ -199,6 +239,16 @@ QUrlQuery GetGuideInfoLoader::query(const GetGuideInfoParams &params) const {
return result;
}
QByteArray GetGuideInfoLoader::body(const GetGuideInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetGuideInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetLiveTvInfoLoader::GetLiveTvInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<LiveTvInfo, GetLiveTvInfoParams>(apiClient) {}
@ -218,6 +268,16 @@ QUrlQuery GetLiveTvInfoLoader::query(const GetLiveTvInfoParams &params) const {
return result;
}
QByteArray GetLiveTvInfoLoader::body(const GetLiveTvInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLiveTvInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
AddListingProviderLoader::AddListingProviderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<ListingsProviderInfo, AddListingProviderParams>(apiClient) {}
@ -246,6 +306,16 @@ QUrlQuery AddListingProviderLoader::query(const AddListingProviderParams &params
return result;
}
QByteArray AddListingProviderLoader::body(const AddListingProviderParams &params) const {
return Support::toString<QSharedPointer<ListingsProviderInfo>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation AddListingProviderLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetDefaultListingProviderLoader::GetDefaultListingProviderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<ListingsProviderInfo, GetDefaultListingProviderParams>(apiClient) {}
@ -265,6 +335,16 @@ QUrlQuery GetDefaultListingProviderLoader::query(const GetDefaultListingProvider
return result;
}
QByteArray GetDefaultListingProviderLoader::body(const GetDefaultListingProviderParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDefaultListingProviderLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetLineupsLoader::GetLineupsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<NameIdPair>, GetLineupsParams>(apiClient) {}
@ -296,6 +376,16 @@ QUrlQuery GetLineupsLoader::query(const GetLineupsParams &params) const {
return result;
}
QByteArray GetLineupsLoader::body(const GetLineupsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLineupsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSchedulesDirectCountriesLoader::GetSchedulesDirectCountriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetSchedulesDirectCountriesParams>(apiClient) {}
@ -315,6 +405,16 @@ QUrlQuery GetSchedulesDirectCountriesLoader::query(const GetSchedulesDirectCount
return result;
}
QByteArray GetSchedulesDirectCountriesLoader::body(const GetSchedulesDirectCountriesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSchedulesDirectCountriesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetLiveTvProgramsLoader::GetLiveTvProgramsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetLiveTvProgramsParams>(apiClient) {}
@ -415,6 +515,16 @@ QUrlQuery GetLiveTvProgramsLoader::query(const GetLiveTvProgramsParams &params)
return result;
}
QByteArray GetLiveTvProgramsLoader::body(const GetLiveTvProgramsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLiveTvProgramsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetProgramsLoader::GetProgramsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetProgramsParams>(apiClient) {}
@ -434,6 +544,16 @@ QUrlQuery GetProgramsLoader::query(const GetProgramsParams &params) const {
return result;
}
QByteArray GetProgramsLoader::body(const GetProgramsParams &params) const {
return Support::toString<QSharedPointer<GetProgramsDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetProgramsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetProgramLoader::GetProgramLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetProgramParams>(apiClient) {}
@ -456,6 +576,16 @@ QUrlQuery GetProgramLoader::query(const GetProgramParams &params) const {
return result;
}
QByteArray GetProgramLoader::body(const GetProgramParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetProgramLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetRecommendedProgramsLoader::GetRecommendedProgramsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetRecommendedProgramsParams>(apiClient) {}
@ -523,6 +653,16 @@ QUrlQuery GetRecommendedProgramsLoader::query(const GetRecommendedProgramsParams
return result;
}
QByteArray GetRecommendedProgramsLoader::body(const GetRecommendedProgramsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRecommendedProgramsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetRecordingsLoader::GetRecordingsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetRecordingsParams>(apiClient) {}
@ -599,6 +739,16 @@ QUrlQuery GetRecordingsLoader::query(const GetRecordingsParams &params) const {
return result;
}
QByteArray GetRecordingsLoader::body(const GetRecordingsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRecordingsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetRecordingLoader::GetRecordingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetRecordingParams>(apiClient) {}
@ -621,6 +771,16 @@ QUrlQuery GetRecordingLoader::query(const GetRecordingParams &params) const {
return result;
}
QByteArray GetRecordingLoader::body(const GetRecordingParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRecordingLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetRecordingFoldersLoader::GetRecordingFoldersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetRecordingFoldersParams>(apiClient) {}
@ -643,6 +803,16 @@ QUrlQuery GetRecordingFoldersLoader::query(const GetRecordingFoldersParams &para
return result;
}
QByteArray GetRecordingFoldersLoader::body(const GetRecordingFoldersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRecordingFoldersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetRecordingGroupsLoader::GetRecordingGroupsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetRecordingGroupsParams>(apiClient) {}
@ -665,6 +835,16 @@ QUrlQuery GetRecordingGroupsLoader::query(const GetRecordingGroupsParams &params
return result;
}
QByteArray GetRecordingGroupsLoader::body(const GetRecordingGroupsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRecordingGroupsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetRecordingsSeriesLoader::GetRecordingsSeriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetRecordingsSeriesParams>(apiClient) {}
@ -726,6 +906,16 @@ QUrlQuery GetRecordingsSeriesLoader::query(const GetRecordingsSeriesParams &para
return result;
}
QByteArray GetRecordingsSeriesLoader::body(const GetRecordingsSeriesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRecordingsSeriesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSeriesTimersLoader::GetSeriesTimersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<SeriesTimerInfoDtoQueryResult, GetSeriesTimersParams>(apiClient) {}
@ -751,6 +941,16 @@ QUrlQuery GetSeriesTimersLoader::query(const GetSeriesTimersParams &params) cons
return result;
}
QByteArray GetSeriesTimersLoader::body(const GetSeriesTimersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSeriesTimersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSeriesTimerLoader::GetSeriesTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<SeriesTimerInfoDto, GetSeriesTimerParams>(apiClient) {}
@ -770,6 +970,16 @@ QUrlQuery GetSeriesTimerLoader::query(const GetSeriesTimerParams &params) const
return result;
}
QByteArray GetSeriesTimerLoader::body(const GetSeriesTimerParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSeriesTimerLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetTimersLoader::GetTimersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<TimerInfoDtoQueryResult, GetTimersParams>(apiClient) {}
@ -801,6 +1011,16 @@ QUrlQuery GetTimersLoader::query(const GetTimersParams &params) const {
return result;
}
QByteArray GetTimersLoader::body(const GetTimersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetTimersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetTimerLoader::GetTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<TimerInfoDto, GetTimerParams>(apiClient) {}
@ -820,6 +1040,16 @@ QUrlQuery GetTimerLoader::query(const GetTimerParams &params) const {
return result;
}
QByteArray GetTimerLoader::body(const GetTimerParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetTimerLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetDefaultTimerLoader::GetDefaultTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<SeriesTimerInfoDto, GetDefaultTimerParams>(apiClient) {}
@ -842,6 +1072,16 @@ QUrlQuery GetDefaultTimerLoader::query(const GetDefaultTimerParams &params) cons
return result;
}
QByteArray GetDefaultTimerLoader::body(const GetDefaultTimerParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetDefaultTimerLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
AddTunerHostLoader::AddTunerHostLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<TunerHostInfo, AddTunerHostParams>(apiClient) {}
@ -861,6 +1101,16 @@ QUrlQuery AddTunerHostLoader::query(const AddTunerHostParams &params) const {
return result;
}
QByteArray AddTunerHostLoader::body(const AddTunerHostParams &params) const {
return Support::toString<QSharedPointer<TunerHostInfo>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation AddTunerHostLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetTunerHostTypesLoader::GetTunerHostTypesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<NameIdPair>, GetTunerHostTypesParams>(apiClient) {}
@ -880,6 +1130,16 @@ QUrlQuery GetTunerHostTypesLoader::query(const GetTunerHostTypesParams &params)
return result;
}
QByteArray GetTunerHostTypesLoader::body(const GetTunerHostTypesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetTunerHostTypesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
DiscoverTunersLoader::DiscoverTunersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<TunerHostInfo>, DiscoverTunersParams>(apiClient) {}
@ -902,6 +1162,16 @@ QUrlQuery DiscoverTunersLoader::query(const DiscoverTunersParams &params) const
return result;
}
QByteArray DiscoverTunersLoader::body(const DiscoverTunersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DiscoverTunersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
DiscvoverTunersLoader::DiscvoverTunersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<TunerHostInfo>, DiscvoverTunersParams>(apiClient) {}
@ -924,6 +1194,16 @@ QUrlQuery DiscvoverTunersLoader::query(const DiscvoverTunersParams &params) cons
return result;
}
QByteArray DiscvoverTunersLoader::body(const DiscvoverTunersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DiscvoverTunersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

40
core/src/loader/http/localization.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetCountriesLoader::query(const GetCountriesParams &params) const {
return result;
}
QByteArray GetCountriesLoader::body(const GetCountriesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetCountriesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetCulturesLoader::GetCulturesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<CultureDto>, GetCulturesParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetCulturesLoader::query(const GetCulturesParams &params) const {
return result;
}
QByteArray GetCulturesLoader::body(const GetCulturesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetCulturesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetLocalizationOptionsLoader::GetLocalizationOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<LocalizationOption>, GetLocalizationOptionsParams>(apiClient) {}
@ -92,6 +112,16 @@ QUrlQuery GetLocalizationOptionsLoader::query(const GetLocalizationOptionsParams
return result;
}
QByteArray GetLocalizationOptionsLoader::body(const GetLocalizationOptionsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLocalizationOptionsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetParentalRatingsLoader::GetParentalRatingsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ParentalRating>, GetParentalRatingsParams>(apiClient) {}
@ -111,6 +141,16 @@ QUrlQuery GetParentalRatingsLoader::query(const GetParentalRatingsParams &params
return result;
}
QByteArray GetParentalRatingsLoader::body(const GetParentalRatingsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetParentalRatingsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/mediainfo.cpp
View file

@ -55,6 +55,16 @@ QUrlQuery GetPlaybackInfoLoader::query(const GetPlaybackInfoParams &params) cons
return result;
}
QByteArray GetPlaybackInfoLoader::body(const GetPlaybackInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPlaybackInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetPostedPlaybackInfoLoader::GetPostedPlaybackInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<PlaybackInfoResponse, GetPostedPlaybackInfoParams>(apiClient) {}
@ -116,6 +126,16 @@ QUrlQuery GetPostedPlaybackInfoLoader::query(const GetPostedPlaybackInfoParams &
return result;
}
QByteArray GetPostedPlaybackInfoLoader::body(const GetPostedPlaybackInfoParams &params) const {
return Support::toString<QSharedPointer<PlaybackInfoDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation GetPostedPlaybackInfoLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
OpenLiveStreamLoader::OpenLiveStreamLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<LiveStreamResponse, OpenLiveStreamParams>(apiClient) {}
@ -168,6 +188,16 @@ QUrlQuery OpenLiveStreamLoader::query(const OpenLiveStreamParams &params) const
return result;
}
QByteArray OpenLiveStreamLoader::body(const OpenLiveStreamParams &params) const {
return Support::toString<QSharedPointer<OpenLiveStreamDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation OpenLiveStreamLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/movies.cpp
View file

@ -69,6 +69,16 @@ QUrlQuery GetMovieRecommendationsLoader::query(const GetMovieRecommendationsPara
return result;
}
QByteArray GetMovieRecommendationsLoader::body(const GetMovieRecommendationsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetMovieRecommendationsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/musicgenres.cpp
View file

@ -102,6 +102,16 @@ QUrlQuery GetMusicGenresLoader::query(const GetMusicGenresParams &params) const
return result;
}
QByteArray GetMusicGenresLoader::body(const GetMusicGenresParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetMusicGenresLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetMusicGenreLoader::GetMusicGenreLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetMusicGenreParams>(apiClient) {}
@ -124,6 +134,16 @@ QUrlQuery GetMusicGenreLoader::query(const GetMusicGenreParams &params) const {
return result;
}
QByteArray GetMusicGenreLoader::body(const GetMusicGenreParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetMusicGenreLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

40
core/src/loader/http/notifications.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetNotificationsLoader::query(const GetNotificationsParams &params) co
return result;
}
QByteArray GetNotificationsLoader::body(const GetNotificationsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetNotificationsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetNotificationsSummaryLoader::GetNotificationsSummaryLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<NotificationsSummaryDto, GetNotificationsSummaryParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetNotificationsSummaryLoader::query(const GetNotificationsSummaryPara
return result;
}
QByteArray GetNotificationsSummaryLoader::body(const GetNotificationsSummaryParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetNotificationsSummaryLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetNotificationServicesLoader::GetNotificationServicesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<NameIdPair>, GetNotificationServicesParams>(apiClient) {}
@ -92,6 +112,16 @@ QUrlQuery GetNotificationServicesLoader::query(const GetNotificationServicesPara
return result;
}
QByteArray GetNotificationServicesLoader::body(const GetNotificationServicesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetNotificationServicesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetNotificationTypesLoader::GetNotificationTypesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<NotificationTypeInfo>, GetNotificationTypesParams>(apiClient) {}
@ -111,6 +141,16 @@ QUrlQuery GetNotificationTypesLoader::query(const GetNotificationTypesParams &pa
return result;
}
QByteArray GetNotificationTypesLoader::body(const GetNotificationTypesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetNotificationTypesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/package.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetPackagesLoader::query(const GetPackagesParams &params) const {
return result;
}
QByteArray GetPackagesLoader::body(const GetPackagesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPackagesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetPackageInfoLoader::GetPackageInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<PackageInfo, GetPackageInfoParams>(apiClient) {}
@ -76,6 +86,16 @@ QUrlQuery GetPackageInfoLoader::query(const GetPackageInfoParams &params) const
return result;
}
QByteArray GetPackageInfoLoader::body(const GetPackageInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPackageInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetRepositoriesLoader::GetRepositoriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RepositoryInfo>, GetRepositoriesParams>(apiClient) {}
@ -95,6 +115,16 @@ QUrlQuery GetRepositoriesLoader::query(const GetRepositoriesParams &params) cons
return result;
}
QByteArray GetRepositoriesLoader::body(const GetRepositoriesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRepositoriesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/persons.cpp
View file

@ -93,6 +93,16 @@ QUrlQuery GetPersonsLoader::query(const GetPersonsParams &params) const {
return result;
}
QByteArray GetPersonsLoader::body(const GetPersonsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPersonsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetPersonLoader::GetPersonLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetPersonParams>(apiClient) {}
@ -115,6 +125,16 @@ QUrlQuery GetPersonLoader::query(const GetPersonParams &params) const {
return result;
}
QByteArray GetPersonLoader::body(const GetPersonParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPersonLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/playlists.cpp
View file

@ -66,6 +66,16 @@ QUrlQuery CreatePlaylistLoader::query(const CreatePlaylistParams &params) const
return result;
}
QByteArray CreatePlaylistLoader::body(const CreatePlaylistParams &params) const {
return Support::toString<QSharedPointer<CreatePlaylistDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation CreatePlaylistLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetPlaylistItemsLoader::GetPlaylistItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetPlaylistItemsParams>(apiClient) {}
@ -107,6 +117,16 @@ QUrlQuery GetPlaylistItemsLoader::query(const GetPlaylistItemsParams &params) co
return result;
}
QByteArray GetPlaylistItemsLoader::body(const GetPlaylistItemsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPlaylistItemsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/playstate.cpp
View file

@ -57,6 +57,16 @@ QUrlQuery MarkPlayedItemLoader::query(const MarkPlayedItemParams &params) const
return result;
}
QByteArray MarkPlayedItemLoader::body(const MarkPlayedItemParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation MarkPlayedItemLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
MarkUnplayedItemLoader::MarkUnplayedItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<UserItemDataDto, MarkUnplayedItemParams>(apiClient) {}
@ -76,6 +86,16 @@ QUrlQuery MarkUnplayedItemLoader::query(const MarkUnplayedItemParams &params) co
return result;
}
QByteArray MarkUnplayedItemLoader::body(const MarkUnplayedItemParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation MarkUnplayedItemLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/plugins.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetPluginsLoader::query(const GetPluginsParams &params) const {
return result;
}
QByteArray GetPluginsLoader::body(const GetPluginsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPluginsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetPluginConfigurationLoader::GetPluginConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BasePluginConfiguration, GetPluginConfigurationParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetPluginConfigurationLoader::query(const GetPluginConfigurationParams
return result;
}
QByteArray GetPluginConfigurationLoader::body(const GetPluginConfigurationParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPluginConfigurationLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

50
core/src/loader/http/quickconnect.cpp
View file

@ -55,6 +55,16 @@ QUrlQuery AuthorizeLoader::query(const AuthorizeParams &params) const {
return result;
}
QByteArray AuthorizeLoader::body(const AuthorizeParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation AuthorizeLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
ConnectLoader::ConnectLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QuickConnectResult, ConnectParams>(apiClient) {}
@ -75,6 +85,16 @@ QUrlQuery ConnectLoader::query(const ConnectParams &params) const {
return result;
}
QByteArray ConnectLoader::body(const ConnectParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation ConnectLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
DeauthorizeLoader::DeauthorizeLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<qint32, DeauthorizeParams>(apiClient) {}
@ -94,6 +114,16 @@ QUrlQuery DeauthorizeLoader::query(const DeauthorizeParams &params) const {
return result;
}
QByteArray DeauthorizeLoader::body(const DeauthorizeParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeauthorizeLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
InitiateLoader::InitiateLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QuickConnectResult, InitiateParams>(apiClient) {}
@ -113,6 +143,16 @@ QUrlQuery InitiateLoader::query(const InitiateParams &params) const {
return result;
}
QByteArray InitiateLoader::body(const InitiateParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation InitiateLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetStatusLoader::GetStatusLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QuickConnectState, GetStatusParams>(apiClient) {}
@ -132,6 +172,16 @@ QUrlQuery GetStatusLoader::query(const GetStatusParams &params) const {
return result;
}
QByteArray GetStatusLoader::body(const GetStatusParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetStatusLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/remoteimage.cpp
View file

@ -69,6 +69,16 @@ QUrlQuery GetRemoteImagesLoader::query(const GetRemoteImagesParams &params) cons
return result;
}
QByteArray GetRemoteImagesLoader::body(const GetRemoteImagesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRemoteImagesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetRemoteImageProvidersLoader::GetRemoteImageProvidersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ImageProviderInfo>, GetRemoteImageProvidersParams>(apiClient) {}
@ -88,6 +98,16 @@ QUrlQuery GetRemoteImageProvidersLoader::query(const GetRemoteImageProvidersPara
return result;
}
QByteArray GetRemoteImageProvidersLoader::body(const GetRemoteImageProvidersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRemoteImageProvidersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/scheduledtasks.cpp
View file

@ -60,6 +60,16 @@ QUrlQuery GetTasksLoader::query(const GetTasksParams &params) const {
return result;
}
QByteArray GetTasksLoader::body(const GetTasksParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetTasksLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetTaskLoader::GetTaskLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<TaskInfo, GetTaskParams>(apiClient) {}
@ -79,6 +89,16 @@ QUrlQuery GetTaskLoader::query(const GetTaskParams &params) const {
return result;
}
QByteArray GetTaskLoader::body(const GetTaskParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetTaskLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/search.cpp
View file

@ -106,6 +106,16 @@ QUrlQuery GetLoader::query(const GetParams &params) const {
return result;
}
QByteArray GetLoader::body(const GetParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/session.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetPasswordResetProvidersLoader::query(const GetPasswordResetProviders
return result;
}
QByteArray GetPasswordResetProvidersLoader::body(const GetPasswordResetProvidersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPasswordResetProvidersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetAuthProvidersLoader::GetAuthProvidersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<NameIdPair>, GetAuthProvidersParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetAuthProvidersLoader::query(const GetAuthProvidersParams &params) co
return result;
}
QByteArray GetAuthProvidersLoader::body(const GetAuthProvidersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetAuthProvidersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSessionsLoader::GetSessionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<SessionInfo>, GetSessionsParams>(apiClient) {}
@ -101,6 +121,16 @@ QUrlQuery GetSessionsLoader::query(const GetSessionsParams &params) const {
return result;
}
QByteArray GetSessionsLoader::body(const GetSessionsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSessionsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

30
core/src/loader/http/startup.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetStartupConfigurationLoader::query(const GetStartupConfigurationPara
return result;
}
QByteArray GetStartupConfigurationLoader::body(const GetStartupConfigurationParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetStartupConfigurationLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetFirstUser_2Loader::GetFirstUser_2Loader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<StartupUserDto, GetFirstUser_2Params>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetFirstUser_2Loader::query(const GetFirstUser_2Params &params) const
return result;
}
QByteArray GetFirstUser_2Loader::body(const GetFirstUser_2Params &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetFirstUser_2Loader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetFirstUserLoader::GetFirstUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<StartupUserDto, GetFirstUserParams>(apiClient) {}
@ -92,6 +112,16 @@ QUrlQuery GetFirstUserLoader::query(const GetFirstUserParams &params) const {
return result;
}
QByteArray GetFirstUserLoader::body(const GetFirstUserParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetFirstUserLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/studios.cpp
View file

@ -105,6 +105,16 @@ QUrlQuery GetStudiosLoader::query(const GetStudiosParams &params) const {
return result;
}
QByteArray GetStudiosLoader::body(const GetStudiosParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetStudiosLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetStudioLoader::GetStudioLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetStudioParams>(apiClient) {}
@ -127,6 +137,16 @@ QUrlQuery GetStudioLoader::query(const GetStudioParams &params) const {
return result;
}
QByteArray GetStudioLoader::body(const GetStudioParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetStudioLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/subtitle.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetFallbackFontListLoader::query(const GetFallbackFontListParams &para
return result;
}
QByteArray GetFallbackFontListLoader::body(const GetFallbackFontListParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetFallbackFontListLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
SearchRemoteSubtitlesLoader::SearchRemoteSubtitlesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSubtitleInfo>, SearchRemoteSubtitlesParams>(apiClient) {}
@ -76,6 +86,16 @@ QUrlQuery SearchRemoteSubtitlesLoader::query(const SearchRemoteSubtitlesParams &
return result;
}
QByteArray SearchRemoteSubtitlesLoader::body(const SearchRemoteSubtitlesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SearchRemoteSubtitlesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/suggestions.cpp
View file

@ -69,6 +69,16 @@ QUrlQuery GetSuggestionsLoader::query(const GetSuggestionsParams &params) const
return result;
}
QByteArray GetSuggestionsLoader::body(const GetSuggestionsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSuggestionsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/syncplay.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery SyncPlayGetGroupsLoader::query(const SyncPlayGetGroupsParams &params)
return result;
}
QByteArray SyncPlayGetGroupsLoader::body(const SyncPlayGetGroupsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SyncPlayGetGroupsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

70
core/src/loader/http/system.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetEndpointInfoLoader::query(const GetEndpointInfoParams &params) cons
return result;
}
QByteArray GetEndpointInfoLoader::body(const GetEndpointInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetEndpointInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSystemInfoLoader::GetSystemInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<SystemInfo, GetSystemInfoParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery GetSystemInfoLoader::query(const GetSystemInfoParams &params) const {
return result;
}
QByteArray GetSystemInfoLoader::body(const GetSystemInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSystemInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetPublicSystemInfoLoader::GetPublicSystemInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<PublicSystemInfo, GetPublicSystemInfoParams>(apiClient) {}
@ -92,6 +112,16 @@ QUrlQuery GetPublicSystemInfoLoader::query(const GetPublicSystemInfoParams &para
return result;
}
QByteArray GetPublicSystemInfoLoader::body(const GetPublicSystemInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPublicSystemInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetServerLogsLoader::GetServerLogsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<LogFile>, GetServerLogsParams>(apiClient) {}
@ -111,6 +141,16 @@ QUrlQuery GetServerLogsLoader::query(const GetServerLogsParams &params) const {
return result;
}
QByteArray GetServerLogsLoader::body(const GetServerLogsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetServerLogsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetPingSystemLoader::GetPingSystemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetPingSystemParams>(apiClient) {}
@ -130,6 +170,16 @@ QUrlQuery GetPingSystemLoader::query(const GetPingSystemParams &params) const {
return result;
}
QByteArray GetPingSystemLoader::body(const GetPingSystemParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPingSystemLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
PostPingSystemLoader::PostPingSystemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, PostPingSystemParams>(apiClient) {}
@ -149,6 +199,16 @@ QUrlQuery PostPingSystemLoader::query(const PostPingSystemParams &params) const
return result;
}
QByteArray PostPingSystemLoader::body(const PostPingSystemParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PostPingSystemLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetWakeOnLanInfoLoader::GetWakeOnLanInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<WakeOnLanInfo>, GetWakeOnLanInfoParams>(apiClient) {}
@ -168,6 +228,16 @@ QUrlQuery GetWakeOnLanInfoLoader::query(const GetWakeOnLanInfoParams &params) co
return result;
}
QByteArray GetWakeOnLanInfoLoader::body(const GetWakeOnLanInfoParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetWakeOnLanInfoLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/timesync.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetUtcTimeLoader::query(const GetUtcTimeParams &params) const {
return result;
}
QByteArray GetUtcTimeLoader::body(const GetUtcTimeParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetUtcTimeLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/trailers.cpp
View file

@ -291,6 +291,16 @@ QUrlQuery GetTrailersLoader::query(const GetTrailersParams &params) const {
return result;
}
QByteArray GetTrailersLoader::body(const GetTrailersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetTrailersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

40
core/src/loader/http/tvshows.cpp
View file

@ -96,6 +96,16 @@ QUrlQuery GetEpisodesLoader::query(const GetEpisodesParams &params) const {
return result;
}
QByteArray GetEpisodesLoader::body(const GetEpisodesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetEpisodesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetSeasonsLoader::GetSeasonsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetSeasonsParams>(apiClient) {}
@ -142,6 +152,16 @@ QUrlQuery GetSeasonsLoader::query(const GetSeasonsParams &params) const {
return result;
}
QByteArray GetSeasonsLoader::body(const GetSeasonsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSeasonsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetNextUpLoader::GetNextUpLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetNextUpParams>(apiClient) {}
@ -197,6 +217,16 @@ QUrlQuery GetNextUpLoader::query(const GetNextUpParams &params) const {
return result;
}
QByteArray GetNextUpLoader::body(const GetNextUpParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetNextUpLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetUpcomingEpisodesLoader::GetUpcomingEpisodesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetUpcomingEpisodesParams>(apiClient) {}
@ -243,6 +273,16 @@ QUrlQuery GetUpcomingEpisodesLoader::query(const GetUpcomingEpisodesParams &para
return result;
}
QByteArray GetUpcomingEpisodesLoader::body(const GetUpcomingEpisodesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetUpcomingEpisodesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

100
core/src/loader/http/user.cpp
View file

@ -60,6 +60,16 @@ QUrlQuery GetUsersLoader::query(const GetUsersParams &params) const {
return result;
}
QByteArray GetUsersLoader::body(const GetUsersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetUsersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetUserByIdLoader::GetUserByIdLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<UserDto, GetUserByIdParams>(apiClient) {}
@ -79,6 +89,16 @@ QUrlQuery GetUserByIdLoader::query(const GetUserByIdParams &params) const {
return result;
}
QByteArray GetUserByIdLoader::body(const GetUserByIdParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetUserByIdLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
AuthenticateUserLoader::AuthenticateUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<AuthenticationResult, AuthenticateUserParams>(apiClient) {}
@ -102,6 +122,16 @@ QUrlQuery AuthenticateUserLoader::query(const AuthenticateUserParams &params) co
return result;
}
QByteArray AuthenticateUserLoader::body(const AuthenticateUserParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation AuthenticateUserLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
AuthenticateUserByNameLoader::AuthenticateUserByNameLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<AuthenticationResult, AuthenticateUserByNameParams>(apiClient) {}
@ -121,6 +151,16 @@ QUrlQuery AuthenticateUserByNameLoader::query(const AuthenticateUserByNameParams
return result;
}
QByteArray AuthenticateUserByNameLoader::body(const AuthenticateUserByNameParams &params) const {
return Support::toString<QSharedPointer<AuthenticateUserByName>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation AuthenticateUserByNameLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
AuthenticateWithQuickConnectLoader::AuthenticateWithQuickConnectLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<AuthenticationResult, AuthenticateWithQuickConnectParams>(apiClient) {}
@ -140,6 +180,16 @@ QUrlQuery AuthenticateWithQuickConnectLoader::query(const AuthenticateWithQuickC
return result;
}
QByteArray AuthenticateWithQuickConnectLoader::body(const AuthenticateWithQuickConnectParams &params) const {
return Support::toString<QSharedPointer<QuickConnectDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation AuthenticateWithQuickConnectLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
ForgotPasswordLoader::ForgotPasswordLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<ForgotPasswordResult, ForgotPasswordParams>(apiClient) {}
@ -159,6 +209,16 @@ QUrlQuery ForgotPasswordLoader::query(const ForgotPasswordParams &params) const
return result;
}
QByteArray ForgotPasswordLoader::body(const ForgotPasswordParams &params) const {
return Support::toString<QSharedPointer<ForgotPasswordDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation ForgotPasswordLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
ForgotPasswordPinLoader::ForgotPasswordPinLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<PinRedeemResult, ForgotPasswordPinParams>(apiClient) {}
@ -178,6 +238,16 @@ QUrlQuery ForgotPasswordPinLoader::query(const ForgotPasswordPinParams &params)
return result;
}
QByteArray ForgotPasswordPinLoader::body(const ForgotPasswordPinParams &params) const {
return Support::toString<QString>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation ForgotPasswordPinLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetCurrentUserLoader::GetCurrentUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<UserDto, GetCurrentUserParams>(apiClient) {}
@ -197,6 +267,16 @@ QUrlQuery GetCurrentUserLoader::query(const GetCurrentUserParams &params) const
return result;
}
QByteArray GetCurrentUserLoader::body(const GetCurrentUserParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetCurrentUserLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
CreateUserByNameLoader::CreateUserByNameLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<UserDto, CreateUserByNameParams>(apiClient) {}
@ -216,6 +296,16 @@ QUrlQuery CreateUserByNameLoader::query(const CreateUserByNameParams &params) co
return result;
}
QByteArray CreateUserByNameLoader::body(const CreateUserByNameParams &params) const {
return Support::toString<QSharedPointer<CreateUserByName>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation CreateUserByNameLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetPublicUsersLoader::GetPublicUsersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<UserDto>, GetPublicUsersParams>(apiClient) {}
@ -235,6 +325,16 @@ QUrlQuery GetPublicUsersLoader::query(const GetPublicUsersParams &params) const
return result;
}
QByteArray GetPublicUsersLoader::body(const GetPublicUsersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPublicUsersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

100
core/src/loader/http/userlibrary.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery MarkFavoriteItemLoader::query(const MarkFavoriteItemParams &params) co
return result;
}
QByteArray MarkFavoriteItemLoader::body(const MarkFavoriteItemParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation MarkFavoriteItemLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
UnmarkFavoriteItemLoader::UnmarkFavoriteItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<UserItemDataDto, UnmarkFavoriteItemParams>(apiClient) {}
@ -73,6 +83,16 @@ QUrlQuery UnmarkFavoriteItemLoader::query(const UnmarkFavoriteItemParams &params
return result;
}
QByteArray UnmarkFavoriteItemLoader::body(const UnmarkFavoriteItemParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation UnmarkFavoriteItemLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
GetItemLoader::GetItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetItemParams>(apiClient) {}
@ -92,6 +112,16 @@ QUrlQuery GetItemLoader::query(const GetItemParams &params) const {
return result;
}
QByteArray GetItemLoader::body(const GetItemParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetItemLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetIntrosLoader::GetIntrosLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetIntrosParams>(apiClient) {}
@ -111,6 +141,16 @@ QUrlQuery GetIntrosLoader::query(const GetIntrosParams &params) const {
return result;
}
QByteArray GetIntrosLoader::body(const GetIntrosParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetIntrosLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetLocalTrailersLoader::GetLocalTrailersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<BaseItemDto>, GetLocalTrailersParams>(apiClient) {}
@ -130,6 +170,16 @@ QUrlQuery GetLocalTrailersLoader::query(const GetLocalTrailersParams &params) co
return result;
}
QByteArray GetLocalTrailersLoader::body(const GetLocalTrailersParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLocalTrailersLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
DeleteUserItemRatingLoader::DeleteUserItemRatingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<UserItemDataDto, DeleteUserItemRatingParams>(apiClient) {}
@ -149,6 +199,16 @@ QUrlQuery DeleteUserItemRatingLoader::query(const DeleteUserItemRatingParams &pa
return result;
}
QByteArray DeleteUserItemRatingLoader::body(const DeleteUserItemRatingParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteUserItemRatingLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
UpdateUserItemRatingLoader::UpdateUserItemRatingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<UserItemDataDto, UpdateUserItemRatingParams>(apiClient) {}
@ -171,6 +231,16 @@ QUrlQuery UpdateUserItemRatingLoader::query(const UpdateUserItemRatingParams &pa
return result;
}
QByteArray UpdateUserItemRatingLoader::body(const UpdateUserItemRatingParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation UpdateUserItemRatingLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetSpecialFeaturesLoader::GetSpecialFeaturesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<BaseItemDto>, GetSpecialFeaturesParams>(apiClient) {}
@ -190,6 +260,16 @@ QUrlQuery GetSpecialFeaturesLoader::query(const GetSpecialFeaturesParams &params
return result;
}
QByteArray GetSpecialFeaturesLoader::body(const GetSpecialFeaturesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetSpecialFeaturesLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetLatestMediaLoader::GetLatestMediaLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<BaseItemDto>, GetLatestMediaParams>(apiClient) {}
@ -239,6 +319,16 @@ QUrlQuery GetLatestMediaLoader::query(const GetLatestMediaParams &params) const
return result;
}
QByteArray GetLatestMediaLoader::body(const GetLatestMediaParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetLatestMediaLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetRootFolderLoader::GetRootFolderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetRootFolderParams>(apiClient) {}
@ -258,6 +348,16 @@ QUrlQuery GetRootFolderLoader::query(const GetRootFolderParams &params) const {
return result;
}
QByteArray GetRootFolderLoader::body(const GetRootFolderParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetRootFolderLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/userviews.cpp
View file

@ -54,6 +54,16 @@ QUrlQuery GetGroupingOptionsLoader::query(const GetGroupingOptionsParams &params
return result;
}
QByteArray GetGroupingOptionsLoader::body(const GetGroupingOptionsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetGroupingOptionsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetUserViewsLoader::GetUserViewsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetUserViewsParams>(apiClient) {}
@ -82,6 +92,16 @@ QUrlQuery GetUserViewsLoader::query(const GetUserViewsParams &params) const {
return result;
}
QByteArray GetUserViewsLoader::body(const GetUserViewsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetUserViewsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

10
core/src/loader/http/videos.cpp
View file

@ -57,6 +57,16 @@ QUrlQuery GetAdditionalPartLoader::query(const GetAdditionalPartParams &params)
return result;
}
QByteArray GetAdditionalPartLoader::body(const GetAdditionalPartParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetAdditionalPartLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

20
core/src/loader/http/years.cpp
View file

@ -99,6 +99,16 @@ QUrlQuery GetYearsLoader::query(const GetYearsParams &params) const {
return result;
}
QByteArray GetYearsLoader::body(const GetYearsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetYearsLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
GetYearLoader::GetYearLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDto, GetYearParams>(apiClient) {}
@ -121,6 +131,16 @@ QUrlQuery GetYearLoader::query(const GetYearParams &params) const {
return result;
}
QByteArray GetYearLoader::body(const GetYearParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetYearLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
} // NS HTTP
} // NS Loader

648
core/src/loader/requesttypes.cpp
View file

File diff suppressed because it is too large Load diff

2
core/src/websocket.cpp
View file

@ -41,7 +41,7 @@ WebSocket::WebSocket(ApiClient *client)
void WebSocket::open() {
QUrlQuery query;
query.addQueryItem("api_key", m_apiClient->token());
query.addQueryItem("deviceId", m_apiClient->m_deviceId);
query.addQueryItem("deviceId", m_apiClient->deviceId());
QUrl connectionUrl(m_apiClient->baseUrl());
connectionUrl.setScheme(connectionUrl.scheme() == "http" ? "ws" : "wss");
connectionUrl.setPath("/socket");