chris/harbour-sailfin
chris/harbour-sailfin
1
0
Fork 0
mirror of https://github.com/HenkKalkwater/harbour-sailfin.git synced 2025-09-06 02:32:44 +00:00
Code Issues Releases Wiki Activity

openapigen: support for 204 No Content endpoints

Browse source
This commit is contained in:
Chris Josten 2023-01-02 20:24:40 +01:00
parent b257fe60aa
commit 77cb5d5957
66 changed files with 6169 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -64,6 +64,65 @@ QNetworkAccessManager::Operation GetKeysLoader::operation() const {
}
CreateKeyLoader::CreateKeyLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, CreateKeyParams>(apiClient) {}
QString CreateKeyLoader::path(const CreateKeyParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Auth/Keys");
}
QUrlQuery CreateKeyLoader::query(const CreateKeyParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("app", Support::toString<QString>(params.app()));
// Optional parameters
return result;
}
QByteArray CreateKeyLoader::body(const CreateKeyParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation CreateKeyLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
RevokeKeyLoader::RevokeKeyLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, RevokeKeyParams>(apiClient) {}
QString RevokeKeyLoader::path(const RevokeKeyParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Auth/Keys/") + Support::toString< QString>(params.key()) ;
}
QUrlQuery RevokeKeyLoader::query(const RevokeKeyParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray RevokeKeyLoader::body(const RevokeKeyParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation RevokeKeyLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
} // NS HTTP
} // NS Loader

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

@ -65,7 +65,7 @@ QNetworkAccessManager::Operation GetBrandingOptionsLoader::operation() const {
}
GetBrandingCssLoader::GetBrandingCssLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetBrandingCssParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<void, GetBrandingCssParams>(apiClient) {}
QString GetBrandingCssLoader::path(const GetBrandingCssParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -94,7 +94,7 @@ QNetworkAccessManager::Operation GetBrandingCssLoader::operation() const {
}
GetBrandingCss_2Loader::GetBrandingCss_2Loader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetBrandingCss_2Params>(apiClient) {}
: Jellyfin::Support::HttpLoader<void, GetBrandingCss_2Params>(apiClient) {}
QString GetBrandingCss_2Loader::path(const GetBrandingCss_2Params &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -76,6 +76,66 @@ QNetworkAccessManager::Operation CreateCollectionLoader::operation() const {
}
AddToCollectionLoader::AddToCollectionLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, AddToCollectionParams>(apiClient) {}
QString AddToCollectionLoader::path(const AddToCollectionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Collections/") + Support::toString< QString>(params.collectionId()) + QStringLiteral("/Items");
}
QUrlQuery AddToCollectionLoader::query(const AddToCollectionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
// Optional parameters
return result;
}
QByteArray AddToCollectionLoader::body(const AddToCollectionParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation AddToCollectionLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
RemoveFromCollectionLoader::RemoveFromCollectionLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, RemoveFromCollectionParams>(apiClient) {}
QString RemoveFromCollectionLoader::path(const RemoveFromCollectionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Collections/") + Support::toString< QString>(params.collectionId()) + QStringLiteral("/Items");
}
QUrlQuery RemoveFromCollectionLoader::query(const RemoveFromCollectionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
// Optional parameters
return result;
}
QByteArray RemoveFromCollectionLoader::body(const RemoveFromCollectionParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation RemoveFromCollectionLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
} // NS HTTP
} // NS Loader

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

@ -64,6 +64,35 @@ QNetworkAccessManager::Operation GetConfigurationLoader::operation() const {
}
UpdateConfigurationLoader::UpdateConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateConfigurationParams>(apiClient) {}
QString UpdateConfigurationLoader::path(const UpdateConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/Configuration");
}
QUrlQuery UpdateConfigurationLoader::query(const UpdateConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateConfigurationLoader::body(const UpdateConfigurationParams &params) const {
return Support::toString<QSharedPointer<ServerConfiguration>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateConfigurationLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetNamedConfigurationLoader::GetNamedConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetNamedConfigurationParams>(apiClient) {}
@ -93,6 +122,35 @@ QNetworkAccessManager::Operation GetNamedConfigurationLoader::operation() const
}
UpdateNamedConfigurationLoader::UpdateNamedConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateNamedConfigurationParams>(apiClient) {}
QString UpdateNamedConfigurationLoader::path(const UpdateNamedConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/Configuration/") + Support::toString< QString>(params.key()) ;
}
QUrlQuery UpdateNamedConfigurationLoader::query(const UpdateNamedConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateNamedConfigurationLoader::body(const UpdateNamedConfigurationParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation UpdateNamedConfigurationLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetDefaultMetadataOptionsLoader::GetDefaultMetadataOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<MetadataOptions, GetDefaultMetadataOptionsParams>(apiClient) {}
@ -122,6 +180,35 @@ QNetworkAccessManager::Operation GetDefaultMetadataOptionsLoader::operation() co
}
UpdateMediaEncoderPathLoader::UpdateMediaEncoderPathLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateMediaEncoderPathParams>(apiClient) {}
QString UpdateMediaEncoderPathLoader::path(const UpdateMediaEncoderPathParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/MediaEncoder/Path");
}
QUrlQuery UpdateMediaEncoderPathLoader::query(const UpdateMediaEncoderPathParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateMediaEncoderPathLoader::body(const UpdateMediaEncoderPathParams &params) const {
return Support::toString<QSharedPointer<MediaEncoderPathDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateMediaEncoderPathLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -70,6 +70,36 @@ QNetworkAccessManager::Operation GetDevicesLoader::operation() const {
}
DeleteDeviceLoader::DeleteDeviceLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteDeviceParams>(apiClient) {}
QString DeleteDeviceLoader::path(const DeleteDeviceParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Devices");
}
QUrlQuery DeleteDeviceLoader::query(const DeleteDeviceParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
// Optional parameters
return result;
}
QByteArray DeleteDeviceLoader::body(const DeleteDeviceParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteDeviceLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
GetDeviceInfoLoader::GetDeviceInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<DeviceInfo, GetDeviceInfoParams>(apiClient) {}
@ -130,6 +160,36 @@ QNetworkAccessManager::Operation GetDeviceOptionsLoader::operation() const {
}
UpdateDeviceOptionsLoader::UpdateDeviceOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateDeviceOptionsParams>(apiClient) {}
QString UpdateDeviceOptionsLoader::path(const UpdateDeviceOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Devices/Options");
}
QUrlQuery UpdateDeviceOptionsLoader::query(const UpdateDeviceOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
// Optional parameters
return result;
}
QByteArray UpdateDeviceOptionsLoader::body(const UpdateDeviceOptionsParams &params) const {
return Support::toString<QSharedPointer<DeviceOptions>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateDeviceOptionsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -66,6 +66,37 @@ QNetworkAccessManager::Operation GetDisplayPreferencesLoader::operation() const
}
UpdateDisplayPreferencesLoader::UpdateDisplayPreferencesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateDisplayPreferencesParams>(apiClient) {}
QString UpdateDisplayPreferencesLoader::path(const UpdateDisplayPreferencesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/DisplayPreferences/") + Support::toString< QString>(params.displayPreferencesId()) ;
}
QUrlQuery UpdateDisplayPreferencesLoader::query(const UpdateDisplayPreferencesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
result.addQueryItem("client", Support::toString<QString>(params.client()));
// Optional parameters
return result;
}
QByteArray UpdateDisplayPreferencesLoader::body(const UpdateDisplayPreferencesParams &params) const {
return Support::toString<QSharedPointer<DisplayPreferencesDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateDisplayPreferencesLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -64,6 +64,35 @@ QNetworkAccessManager::Operation GetProfileInfosLoader::operation() const {
}
CreateProfileLoader::CreateProfileLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, CreateProfileParams>(apiClient) {}
QString CreateProfileLoader::path(const CreateProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Dlna/Profiles");
}
QUrlQuery CreateProfileLoader::query(const CreateProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray CreateProfileLoader::body(const CreateProfileParams &params) const {
return Support::toString<QSharedPointer<DeviceProfile>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation CreateProfileLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetProfileLoader::GetProfileLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<DeviceProfile, GetProfileParams>(apiClient) {}
@ -93,6 +122,64 @@ QNetworkAccessManager::Operation GetProfileLoader::operation() const {
}
DeleteProfileLoader::DeleteProfileLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteProfileParams>(apiClient) {}
QString DeleteProfileLoader::path(const DeleteProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Dlna/Profiles/") + Support::toString< QString>(params.profileId()) ;
}
QUrlQuery DeleteProfileLoader::query(const DeleteProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray DeleteProfileLoader::body(const DeleteProfileParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteProfileLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
UpdateProfileLoader::UpdateProfileLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateProfileParams>(apiClient) {}
QString UpdateProfileLoader::path(const UpdateProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Dlna/Profiles/") + Support::toString< QString>(params.profileId()) ;
}
QUrlQuery UpdateProfileLoader::query(const UpdateProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateProfileLoader::body(const UpdateProfileParams &params) const {
return Support::toString<QSharedPointer<DeviceProfile>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateProfileLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetDefaultProfileLoader::GetDefaultProfileLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<DeviceProfile, GetDefaultProfileParams>(apiClient) {}

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

@ -188,6 +188,35 @@ QNetworkAccessManager::Operation GetParentPathLoader::operation() const {
}
ValidatePathLoader::ValidatePathLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, ValidatePathParams>(apiClient) {}
QString ValidatePathLoader::path(const ValidatePathParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Environment/ValidatePath");
}
QUrlQuery ValidatePathLoader::query(const ValidatePathParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray ValidatePathLoader::body(const ValidatePathParams &params) const {
return Support::toString<QSharedPointer<ValidatePathDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation ValidatePathLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

35
core/src/loader/http/hlssegment.cpp
View file

@ -35,6 +35,41 @@ namespace HTTP {
using namespace Jellyfin::DTO;
StopEncodingProcessLoader::StopEncodingProcessLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, StopEncodingProcessParams>(apiClient) {}
QString StopEncodingProcessLoader::path(const StopEncodingProcessParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Videos/ActiveEncodings");
}
QUrlQuery StopEncodingProcessLoader::query(const StopEncodingProcessParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.deviceIdNull()) {
result.addQueryItem("deviceId", Support::toString<QString>(params.deviceId()));
}
if (!params.playSessionIdNull()) {
result.addQueryItem("playSessionId", Support::toString<QString>(params.playSessionId()));
}
return result;
}
QByteArray StopEncodingProcessLoader::body(const StopEncodingProcessParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation StopEncodingProcessLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
} // NS HTTP
} // NS Loader

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

@ -64,6 +64,279 @@ QNetworkAccessManager::Operation GetItemImageInfosLoader::operation() const {
}
DeleteItemImageLoader::DeleteItemImageLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteItemImageParams>(apiClient) {}
QString DeleteItemImageLoader::path(const DeleteItemImageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) ;
}
QUrlQuery DeleteItemImageLoader::query(const DeleteItemImageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.imageIndexNull()) {
result.addQueryItem("imageIndex", Support::toString<std::optional<qint32>>(params.imageIndex()));
}
return result;
}
QByteArray DeleteItemImageLoader::body(const DeleteItemImageParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteItemImageLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
SetItemImageLoader::SetItemImageLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SetItemImageParams>(apiClient) {}
QString SetItemImageLoader::path(const SetItemImageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) ;
}
QUrlQuery SetItemImageLoader::query(const SetItemImageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SetItemImageLoader::body(const SetItemImageParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SetItemImageLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
DeleteItemImageByIndexLoader::DeleteItemImageByIndexLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteItemImageByIndexParams>(apiClient) {}
QString DeleteItemImageByIndexLoader::path(const DeleteItemImageByIndexParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) + QStringLiteral("/") + Support::toString< qint32>(params.imageIndex()) ;
}
QUrlQuery DeleteItemImageByIndexLoader::query(const DeleteItemImageByIndexParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray DeleteItemImageByIndexLoader::body(const DeleteItemImageByIndexParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteItemImageByIndexLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
SetItemImageByIndexLoader::SetItemImageByIndexLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SetItemImageByIndexParams>(apiClient) {}
QString SetItemImageByIndexLoader::path(const SetItemImageByIndexParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) + QStringLiteral("/") + Support::toString< qint32>(params.imageIndex()) ;
}
QUrlQuery SetItemImageByIndexLoader::query(const SetItemImageByIndexParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SetItemImageByIndexLoader::body(const SetItemImageByIndexParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SetItemImageByIndexLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
UpdateItemImageIndexLoader::UpdateItemImageIndexLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateItemImageIndexParams>(apiClient) {}
QString UpdateItemImageIndexLoader::path(const UpdateItemImageIndexParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) + QStringLiteral("/") + Support::toString< qint32>(params.imageIndex()) + QStringLiteral("/Index");
}
QUrlQuery UpdateItemImageIndexLoader::query(const UpdateItemImageIndexParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.newIndexNull()) {
result.addQueryItem("newIndex", Support::toString<std::optional<qint32>>(params.newIndex()));
}
return result;
}
QByteArray UpdateItemImageIndexLoader::body(const UpdateItemImageIndexParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation UpdateItemImageIndexLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
PostUserImageLoader::PostUserImageLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PostUserImageParams>(apiClient) {}
QString PostUserImageLoader::path(const PostUserImageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) ;
}
QUrlQuery PostUserImageLoader::query(const PostUserImageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.indexNull()) {
result.addQueryItem("index", Support::toString<std::optional<qint32>>(params.index()));
}
return result;
}
QByteArray PostUserImageLoader::body(const PostUserImageParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PostUserImageLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
DeleteUserImageLoader::DeleteUserImageLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteUserImageParams>(apiClient) {}
QString DeleteUserImageLoader::path(const DeleteUserImageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) ;
}
QUrlQuery DeleteUserImageLoader::query(const DeleteUserImageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.indexNull()) {
result.addQueryItem("index", Support::toString<std::optional<qint32>>(params.index()));
}
return result;
}
QByteArray DeleteUserImageLoader::body(const DeleteUserImageParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteUserImageLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
PostUserImageByIndexLoader::PostUserImageByIndexLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PostUserImageByIndexParams>(apiClient) {}
QString PostUserImageByIndexLoader::path(const PostUserImageByIndexParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) + QStringLiteral("/") + Support::toString< qint32>(params.index()) ;
}
QUrlQuery PostUserImageByIndexLoader::query(const PostUserImageByIndexParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray PostUserImageByIndexLoader::body(const PostUserImageByIndexParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PostUserImageByIndexLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
DeleteUserImageByIndexLoader::DeleteUserImageByIndexLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteUserImageByIndexParams>(apiClient) {}
QString DeleteUserImageByIndexLoader::path(const DeleteUserImageByIndexParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Images/") + Support::toString< ImageType>(params.imageType()) + QStringLiteral("/") + Support::toString< qint32>(params.index()) ;
}
QUrlQuery DeleteUserImageByIndexLoader::query(const DeleteUserImageByIndexParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray DeleteUserImageByIndexLoader::body(const DeleteUserImageByIndexParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteUserImageByIndexLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
} // NS HTTP
} // NS Loader

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

@ -64,6 +64,38 @@ QNetworkAccessManager::Operation GetExternalIdInfosLoader::operation() const {
}
ApplySearchCriteriaLoader::ApplySearchCriteriaLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, ApplySearchCriteriaParams>(apiClient) {}
QString ApplySearchCriteriaLoader::path(const ApplySearchCriteriaParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/RemoteSearch/Apply/") + Support::toString< QString>(params.itemId()) ;
}
QUrlQuery ApplySearchCriteriaLoader::query(const ApplySearchCriteriaParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.replaceAllImagesNull()) {
result.addQueryItem("replaceAllImages", Support::toString<std::optional<bool>>(params.replaceAllImages()));
}
return result;
}
QByteArray ApplySearchCriteriaLoader::body(const ApplySearchCriteriaParams &params) const {
return Support::toString<QSharedPointer<RemoteSearchResult>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation ApplySearchCriteriaLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetBookRemoteSearchResultsLoader::GetBookRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetBookRemoteSearchResultsParams>(apiClient) {}

41
core/src/loader/http/itemrefresh.cpp
View file

@ -35,6 +35,47 @@ namespace HTTP {
using namespace Jellyfin::DTO;
PostLoader::PostLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PostParams>(apiClient) {}
QString PostLoader::path(const PostParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Refresh");
}
QUrlQuery PostLoader::query(const PostParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.metadataRefreshModeNull()) {
result.addQueryItem("metadataRefreshMode", Support::toString<MetadataRefreshMode>(params.metadataRefreshMode()));
}
if (!params.imageRefreshModeNull()) {
result.addQueryItem("imageRefreshMode", Support::toString<MetadataRefreshMode>(params.imageRefreshMode()));
}
if (!params.replaceAllMetadataNull()) {
result.addQueryItem("replaceAllMetadata", Support::toString<std::optional<bool>>(params.replaceAllMetadata()));
}
if (!params.replaceAllImagesNull()) {
result.addQueryItem("replaceAllImages", Support::toString<std::optional<bool>>(params.replaceAllImages()));
}
return result;
}
QByteArray PostLoader::body(const PostParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PostLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -35,6 +35,67 @@ namespace HTTP {
using namespace Jellyfin::DTO;
UpdateItemLoader::UpdateItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateItemParams>(apiClient) {}
QString UpdateItemLoader::path(const UpdateItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) ;
}
QUrlQuery UpdateItemLoader::query(const UpdateItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateItemLoader::body(const UpdateItemParams &params) const {
return Support::toString<QSharedPointer<BaseItemDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateItemLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
UpdateItemContentTypeLoader::UpdateItemContentTypeLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateItemContentTypeParams>(apiClient) {}
QString UpdateItemContentTypeLoader::path(const UpdateItemContentTypeParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/ContentType");
}
QUrlQuery UpdateItemContentTypeLoader::query(const UpdateItemContentTypeParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.contentTypeNull()) {
result.addQueryItem("contentType", Support::toString<QString>(params.contentType()));
}
return result;
}
QByteArray UpdateItemContentTypeLoader::body(const UpdateItemContentTypeParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation UpdateItemContentTypeLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetMetadataEditorInfoLoader::GetMetadataEditorInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<MetadataEditorInfo, GetMetadataEditorInfoParams>(apiClient) {}

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

@ -35,6 +35,67 @@ namespace HTTP {
using namespace Jellyfin::DTO;
DeleteItemsLoader::DeleteItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteItemsParams>(apiClient) {}
QString DeleteItemsLoader::path(const DeleteItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items");
}
QUrlQuery DeleteItemsLoader::query(const DeleteItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.idsNull()) {
result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
}
return result;
}
QByteArray DeleteItemsLoader::body(const DeleteItemsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteItemsLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
DeleteItemLoader::DeleteItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteItemParams>(apiClient) {}
QString DeleteItemLoader::path(const DeleteItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) ;
}
QUrlQuery DeleteItemLoader::query(const DeleteItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray DeleteItemLoader::body(const DeleteItemParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteItemLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
GetSimilarAlbumsLoader::GetSimilarAlbumsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetSimilarAlbumsParams>(apiClient) {}
@ -394,6 +455,35 @@ QNetworkAccessManager::Operation GetLibraryOptionsInfoLoader::operation() const
}
PostUpdatedMediaLoader::PostUpdatedMediaLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PostUpdatedMediaParams>(apiClient) {}
QString PostUpdatedMediaLoader::path(const PostUpdatedMediaParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/Media/Updated");
}
QUrlQuery PostUpdatedMediaLoader::query(const PostUpdatedMediaParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray PostUpdatedMediaLoader::body(const PostUpdatedMediaParams &params) const {
return Support::toString<QList<MediaUpdateInfoDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation PostUpdatedMediaLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetMediaFoldersLoader::GetMediaFoldersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetMediaFoldersParams>(apiClient) {}
@ -426,6 +516,76 @@ QNetworkAccessManager::Operation GetMediaFoldersLoader::operation() const {
}
PostAddedMoviesLoader::PostAddedMoviesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PostAddedMoviesParams>(apiClient) {}
QString PostAddedMoviesLoader::path(const PostAddedMoviesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/Movies/Added");
}
QUrlQuery PostAddedMoviesLoader::query(const PostAddedMoviesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.tmdbIdNull()) {
result.addQueryItem("tmdbId", Support::toString<QString>(params.tmdbId()));
}
if (!params.imdbIdNull()) {
result.addQueryItem("imdbId", Support::toString<QString>(params.imdbId()));
}
return result;
}
QByteArray PostAddedMoviesLoader::body(const PostAddedMoviesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PostAddedMoviesLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
PostUpdatedMoviesLoader::PostUpdatedMoviesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PostUpdatedMoviesParams>(apiClient) {}
QString PostUpdatedMoviesLoader::path(const PostUpdatedMoviesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/Movies/Updated");
}
QUrlQuery PostUpdatedMoviesLoader::query(const PostUpdatedMoviesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.tmdbIdNull()) {
result.addQueryItem("tmdbId", Support::toString<QString>(params.tmdbId()));
}
if (!params.imdbIdNull()) {
result.addQueryItem("imdbId", Support::toString<QString>(params.imdbId()));
}
return result;
}
QByteArray PostUpdatedMoviesLoader::body(const PostUpdatedMoviesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PostUpdatedMoviesLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetPhysicalPathsLoader::GetPhysicalPathsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QStringList, GetPhysicalPathsParams>(apiClient) {}
@ -455,6 +615,99 @@ QNetworkAccessManager::Operation GetPhysicalPathsLoader::operation() const {
}
RefreshLibraryLoader::RefreshLibraryLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, RefreshLibraryParams>(apiClient) {}
QString RefreshLibraryLoader::path(const RefreshLibraryParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/Refresh");
}
QUrlQuery RefreshLibraryLoader::query(const RefreshLibraryParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray RefreshLibraryLoader::body(const RefreshLibraryParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation RefreshLibraryLoader::operation() const {
// HTTP method Get
return QNetworkAccessManager::GetOperation;
}
PostAddedSeriesLoader::PostAddedSeriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PostAddedSeriesParams>(apiClient) {}
QString PostAddedSeriesLoader::path(const PostAddedSeriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/Series/Added");
}
QUrlQuery PostAddedSeriesLoader::query(const PostAddedSeriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.tvdbIdNull()) {
result.addQueryItem("tvdbId", Support::toString<QString>(params.tvdbId()));
}
return result;
}
QByteArray PostAddedSeriesLoader::body(const PostAddedSeriesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PostAddedSeriesLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
PostUpdatedSeriesLoader::PostUpdatedSeriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PostUpdatedSeriesParams>(apiClient) {}
QString PostUpdatedSeriesLoader::path(const PostUpdatedSeriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/Series/Updated");
}
QUrlQuery PostUpdatedSeriesLoader::query(const PostUpdatedSeriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.tvdbIdNull()) {
result.addQueryItem("tvdbId", Support::toString<QString>(params.tvdbId()));
}
return result;
}
QByteArray PostUpdatedSeriesLoader::body(const PostUpdatedSeriesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PostUpdatedSeriesLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetSimilarMoviesLoader::GetSimilarMoviesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetSimilarMoviesParams>(apiClient) {}

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

@ -64,6 +64,251 @@ QNetworkAccessManager::Operation GetVirtualFoldersLoader::operation() const {
}
AddVirtualFolderLoader::AddVirtualFolderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, AddVirtualFolderParams>(apiClient) {}
QString AddVirtualFolderLoader::path(const AddVirtualFolderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/VirtualFolders");
}
QUrlQuery AddVirtualFolderLoader::query(const AddVirtualFolderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.nameNull()) {
result.addQueryItem("name", Support::toString<QString>(params.name()));
}
if (!params.collectionTypeNull()) {
result.addQueryItem("collectionType", Support::toString<QString>(params.collectionType()));
}
if (!params.pathsNull()) {
result.addQueryItem("paths", Support::toString<QStringList>(params.paths()));
}
if (!params.refreshLibraryNull()) {
result.addQueryItem("refreshLibrary", Support::toString<std::optional<bool>>(params.refreshLibrary()));
}
return result;
}
QByteArray AddVirtualFolderLoader::body(const AddVirtualFolderParams &params) const {
return Support::toString<QSharedPointer<AddVirtualFolderDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation AddVirtualFolderLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
RemoveVirtualFolderLoader::RemoveVirtualFolderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, RemoveVirtualFolderParams>(apiClient) {}
QString RemoveVirtualFolderLoader::path(const RemoveVirtualFolderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/VirtualFolders");
}
QUrlQuery RemoveVirtualFolderLoader::query(const RemoveVirtualFolderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.nameNull()) {
result.addQueryItem("name", Support::toString<QString>(params.name()));
}
if (!params.refreshLibraryNull()) {
result.addQueryItem("refreshLibrary", Support::toString<std::optional<bool>>(params.refreshLibrary()));
}
return result;
}
QByteArray RemoveVirtualFolderLoader::body(const RemoveVirtualFolderParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation RemoveVirtualFolderLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
UpdateLibraryOptionsLoader::UpdateLibraryOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateLibraryOptionsParams>(apiClient) {}
QString UpdateLibraryOptionsLoader::path(const UpdateLibraryOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/VirtualFolders/LibraryOptions");
}
QUrlQuery UpdateLibraryOptionsLoader::query(const UpdateLibraryOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateLibraryOptionsLoader::body(const UpdateLibraryOptionsParams &params) const {
return Support::toString<QSharedPointer<UpdateLibraryOptionsDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateLibraryOptionsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
RenameVirtualFolderLoader::RenameVirtualFolderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, RenameVirtualFolderParams>(apiClient) {}
QString RenameVirtualFolderLoader::path(const RenameVirtualFolderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/VirtualFolders/Name");
}
QUrlQuery RenameVirtualFolderLoader::query(const RenameVirtualFolderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.nameNull()) {
result.addQueryItem("name", Support::toString<QString>(params.name()));
}
if (!params.newNameNull()) {
result.addQueryItem("newName", Support::toString<QString>(params.newName()));
}
if (!params.refreshLibraryNull()) {
result.addQueryItem("refreshLibrary", Support::toString<std::optional<bool>>(params.refreshLibrary()));
}
return result;
}
QByteArray RenameVirtualFolderLoader::body(const RenameVirtualFolderParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation RenameVirtualFolderLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
AddMediaPathLoader::AddMediaPathLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, AddMediaPathParams>(apiClient) {}
QString AddMediaPathLoader::path(const AddMediaPathParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/VirtualFolders/Paths");
}
QUrlQuery AddMediaPathLoader::query(const AddMediaPathParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.refreshLibraryNull()) {
result.addQueryItem("refreshLibrary", Support::toString<std::optional<bool>>(params.refreshLibrary()));
}
return result;
}
QByteArray AddMediaPathLoader::body(const AddMediaPathParams &params) const {
return Support::toString<QSharedPointer<MediaPathDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation AddMediaPathLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
RemoveMediaPathLoader::RemoveMediaPathLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, RemoveMediaPathParams>(apiClient) {}
QString RemoveMediaPathLoader::path(const RemoveMediaPathParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/VirtualFolders/Paths");
}
QUrlQuery RemoveMediaPathLoader::query(const RemoveMediaPathParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.nameNull()) {
result.addQueryItem("name", Support::toString<QString>(params.name()));
}
if (!params.pathNull()) {
result.addQueryItem("path", Support::toString<QString>(params.path()));
}
if (!params.refreshLibraryNull()) {
result.addQueryItem("refreshLibrary", Support::toString<std::optional<bool>>(params.refreshLibrary()));
}
return result;
}
QByteArray RemoveMediaPathLoader::body(const RemoveMediaPathParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation RemoveMediaPathLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
UpdateMediaPathLoader::UpdateMediaPathLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateMediaPathParams>(apiClient) {}
QString UpdateMediaPathLoader::path(const UpdateMediaPathParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/VirtualFolders/Paths/Update");
}
QUrlQuery UpdateMediaPathLoader::query(const UpdateMediaPathParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.nameNull()) {
result.addQueryItem("name", Support::toString<QString>(params.name()));
}
return result;
}
QByteArray UpdateMediaPathLoader::body(const UpdateMediaPathParams &params) const {
return Support::toString<QSharedPointer<MediaPathInfo>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateMediaPathLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -316,6 +316,38 @@ QNetworkAccessManager::Operation AddListingProviderLoader::operation() const {
}
DeleteListingProviderLoader::DeleteListingProviderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteListingProviderParams>(apiClient) {}
QString DeleteListingProviderLoader::path(const DeleteListingProviderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/ListingProviders");
}
QUrlQuery DeleteListingProviderLoader::query(const DeleteListingProviderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.jellyfinIdNull()) {
result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
}
return result;
}
QByteArray DeleteListingProviderLoader::body(const DeleteListingProviderParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteListingProviderLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
GetDefaultListingProviderLoader::GetDefaultListingProviderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<ListingsProviderInfo, GetDefaultListingProviderParams>(apiClient) {}
@ -781,6 +813,35 @@ QNetworkAccessManager::Operation GetRecordingLoader::operation() const {
}
DeleteRecordingLoader::DeleteRecordingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteRecordingParams>(apiClient) {}
QString DeleteRecordingLoader::path(const DeleteRecordingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Recordings/") + Support::toString< QString>(params.recordingId()) ;
}
QUrlQuery DeleteRecordingLoader::query(const DeleteRecordingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray DeleteRecordingLoader::body(const DeleteRecordingParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteRecordingLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
GetRecordingFoldersLoader::GetRecordingFoldersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetRecordingFoldersParams>(apiClient) {}
@ -951,6 +1012,35 @@ QNetworkAccessManager::Operation GetSeriesTimersLoader::operation() const {
}
CreateSeriesTimerLoader::CreateSeriesTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, CreateSeriesTimerParams>(apiClient) {}
QString CreateSeriesTimerLoader::path(const CreateSeriesTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/SeriesTimers");
}
QUrlQuery CreateSeriesTimerLoader::query(const CreateSeriesTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray CreateSeriesTimerLoader::body(const CreateSeriesTimerParams &params) const {
return Support::toString<QSharedPointer<SeriesTimerInfoDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation CreateSeriesTimerLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetSeriesTimerLoader::GetSeriesTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<SeriesTimerInfoDto, GetSeriesTimerParams>(apiClient) {}
@ -980,6 +1070,64 @@ QNetworkAccessManager::Operation GetSeriesTimerLoader::operation() const {
}
CancelSeriesTimerLoader::CancelSeriesTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, CancelSeriesTimerParams>(apiClient) {}
QString CancelSeriesTimerLoader::path(const CancelSeriesTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/SeriesTimers/") + Support::toString< QString>(params.timerId()) ;
}
QUrlQuery CancelSeriesTimerLoader::query(const CancelSeriesTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray CancelSeriesTimerLoader::body(const CancelSeriesTimerParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation CancelSeriesTimerLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
UpdateSeriesTimerLoader::UpdateSeriesTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateSeriesTimerParams>(apiClient) {}
QString UpdateSeriesTimerLoader::path(const UpdateSeriesTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/SeriesTimers/") + Support::toString< QString>(params.timerId()) ;
}
QUrlQuery UpdateSeriesTimerLoader::query(const UpdateSeriesTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateSeriesTimerLoader::body(const UpdateSeriesTimerParams &params) const {
return Support::toString<QSharedPointer<SeriesTimerInfoDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateSeriesTimerLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetTimersLoader::GetTimersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<TimerInfoDtoQueryResult, GetTimersParams>(apiClient) {}
@ -1021,6 +1169,35 @@ QNetworkAccessManager::Operation GetTimersLoader::operation() const {
}
CreateTimerLoader::CreateTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, CreateTimerParams>(apiClient) {}
QString CreateTimerLoader::path(const CreateTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Timers");
}
QUrlQuery CreateTimerLoader::query(const CreateTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray CreateTimerLoader::body(const CreateTimerParams &params) const {
return Support::toString<QSharedPointer<TimerInfoDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation CreateTimerLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetTimerLoader::GetTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<TimerInfoDto, GetTimerParams>(apiClient) {}
@ -1050,6 +1227,64 @@ QNetworkAccessManager::Operation GetTimerLoader::operation() const {
}
CancelTimerLoader::CancelTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, CancelTimerParams>(apiClient) {}
QString CancelTimerLoader::path(const CancelTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Timers/") + Support::toString< QString>(params.timerId()) ;
}
QUrlQuery CancelTimerLoader::query(const CancelTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray CancelTimerLoader::body(const CancelTimerParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation CancelTimerLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
UpdateTimerLoader::UpdateTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateTimerParams>(apiClient) {}
QString UpdateTimerLoader::path(const UpdateTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Timers/") + Support::toString< QString>(params.timerId()) ;
}
QUrlQuery UpdateTimerLoader::query(const UpdateTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateTimerLoader::body(const UpdateTimerParams &params) const {
return Support::toString<QSharedPointer<TimerInfoDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateTimerLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetDefaultTimerLoader::GetDefaultTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<SeriesTimerInfoDto, GetDefaultTimerParams>(apiClient) {}
@ -1111,6 +1346,38 @@ QNetworkAccessManager::Operation AddTunerHostLoader::operation() const {
}
DeleteTunerHostLoader::DeleteTunerHostLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteTunerHostParams>(apiClient) {}
QString DeleteTunerHostLoader::path(const DeleteTunerHostParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/TunerHosts");
}
QUrlQuery DeleteTunerHostLoader::query(const DeleteTunerHostParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.jellyfinIdNull()) {
result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
}
return result;
}
QByteArray DeleteTunerHostLoader::body(const DeleteTunerHostParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteTunerHostLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
GetTunerHostTypesLoader::GetTunerHostTypesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<NameIdPair>, GetTunerHostTypesParams>(apiClient) {}
@ -1140,6 +1407,35 @@ QNetworkAccessManager::Operation GetTunerHostTypesLoader::operation() const {
}
ResetTunerLoader::ResetTunerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, ResetTunerParams>(apiClient) {}
QString ResetTunerLoader::path(const ResetTunerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Tuners/") + Support::toString< QString>(params.tunerId()) + QStringLiteral("/Reset");
}
QUrlQuery ResetTunerLoader::query(const ResetTunerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray ResetTunerLoader::body(const ResetTunerParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation ResetTunerLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
DiscoverTunersLoader::DiscoverTunersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<TunerHostInfo>, DiscoverTunersParams>(apiClient) {}

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

@ -136,6 +136,36 @@ QNetworkAccessManager::Operation GetPostedPlaybackInfoLoader::operation() const
}
CloseLiveStreamLoader::CloseLiveStreamLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, CloseLiveStreamParams>(apiClient) {}
QString CloseLiveStreamLoader::path(const CloseLiveStreamParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveStreams/Close");
}
QUrlQuery CloseLiveStreamLoader::query(const CloseLiveStreamParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("liveStreamId", Support::toString<QString>(params.liveStreamId()));
// Optional parameters
return result;
}
QByteArray CloseLiveStreamLoader::body(const CloseLiveStreamParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation CloseLiveStreamLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
OpenLiveStreamLoader::OpenLiveStreamLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<LiveStreamResponse, OpenLiveStreamParams>(apiClient) {}

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

@ -64,6 +64,35 @@ QNetworkAccessManager::Operation GetNotificationsLoader::operation() const {
}
SetReadLoader::SetReadLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SetReadParams>(apiClient) {}
QString SetReadLoader::path(const SetReadParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Notifications/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Read");
}
QUrlQuery SetReadLoader::query(const SetReadParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SetReadLoader::body(const SetReadParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SetReadLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetNotificationsSummaryLoader::GetNotificationsSummaryLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<NotificationsSummaryDto, GetNotificationsSummaryParams>(apiClient) {}
@ -93,6 +122,76 @@ QNetworkAccessManager::Operation GetNotificationsSummaryLoader::operation() cons
}
SetUnreadLoader::SetUnreadLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SetUnreadParams>(apiClient) {}
QString SetUnreadLoader::path(const SetUnreadParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Notifications/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Unread");
}
QUrlQuery SetUnreadLoader::query(const SetUnreadParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SetUnreadLoader::body(const SetUnreadParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SetUnreadLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
CreateAdminNotificationLoader::CreateAdminNotificationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, CreateAdminNotificationParams>(apiClient) {}
QString CreateAdminNotificationLoader::path(const CreateAdminNotificationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Notifications/Admin");
}
QUrlQuery CreateAdminNotificationLoader::query(const CreateAdminNotificationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.urlNull()) {
result.addQueryItem("url", Support::toString<QString>(params.url()));
}
if (!params.levelNull()) {
result.addQueryItem("level", Support::toString<NotificationLevel>(params.level()));
}
if (!params.nameNull()) {
result.addQueryItem("name", Support::toString<QString>(params.name()));
}
if (!params.descriptionNull()) {
result.addQueryItem("description", Support::toString<QString>(params.description()));
}
return result;
}
QByteArray CreateAdminNotificationLoader::body(const CreateAdminNotificationParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation CreateAdminNotificationLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetNotificationServicesLoader::GetNotificationServicesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<NameIdPair>, GetNotificationServicesParams>(apiClient) {}

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

@ -96,6 +96,73 @@ QNetworkAccessManager::Operation GetPackageInfoLoader::operation() const {
}
InstallPackageLoader::InstallPackageLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, InstallPackageParams>(apiClient) {}
QString InstallPackageLoader::path(const InstallPackageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Packages/Installed/") + Support::toString< QString>(params.name()) ;
}
QUrlQuery InstallPackageLoader::query(const InstallPackageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.assemblyGuidNull()) {
result.addQueryItem("assemblyGuid", Support::toString<QString>(params.assemblyGuid()));
}
if (!params.versionNull()) {
result.addQueryItem("version", Support::toString<QString>(params.version()));
}
if (!params.repositoryUrlNull()) {
result.addQueryItem("repositoryUrl", Support::toString<QString>(params.repositoryUrl()));
}
return result;
}
QByteArray InstallPackageLoader::body(const InstallPackageParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation InstallPackageLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
CancelPackageInstallationLoader::CancelPackageInstallationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, CancelPackageInstallationParams>(apiClient) {}
QString CancelPackageInstallationLoader::path(const CancelPackageInstallationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Packages/Installing/") + Support::toString< QString>(params.packageId()) ;
}
QUrlQuery CancelPackageInstallationLoader::query(const CancelPackageInstallationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray CancelPackageInstallationLoader::body(const CancelPackageInstallationParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation CancelPackageInstallationLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
GetRepositoriesLoader::GetRepositoriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RepositoryInfo>, GetRepositoriesParams>(apiClient) {}
@ -125,6 +192,35 @@ QNetworkAccessManager::Operation GetRepositoriesLoader::operation() const {
}
SetRepositoriesLoader::SetRepositoriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SetRepositoriesParams>(apiClient) {}
QString SetRepositoriesLoader::path(const SetRepositoriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Repositories");
}
QUrlQuery SetRepositoriesLoader::query(const SetRepositoriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SetRepositoriesLoader::body(const SetRepositoriesParams &params) const {
return Support::toString<QList<RepositoryInfo>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SetRepositoriesLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -76,6 +76,73 @@ QNetworkAccessManager::Operation CreatePlaylistLoader::operation() const {
}
AddToPlaylistLoader::AddToPlaylistLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, AddToPlaylistParams>(apiClient) {}
QString AddToPlaylistLoader::path(const AddToPlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Playlists/") + Support::toString< QString>(params.playlistId()) + QStringLiteral("/Items");
}
QUrlQuery AddToPlaylistLoader::query(const AddToPlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.idsNull()) {
result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
return result;
}
QByteArray AddToPlaylistLoader::body(const AddToPlaylistParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation AddToPlaylistLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
RemoveFromPlaylistLoader::RemoveFromPlaylistLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, RemoveFromPlaylistParams>(apiClient) {}
QString RemoveFromPlaylistLoader::path(const RemoveFromPlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Playlists/") + Support::toString< QString>(params.playlistId()) + QStringLiteral("/Items");
}
QUrlQuery RemoveFromPlaylistLoader::query(const RemoveFromPlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.entryIdsNull()) {
result.addQueryItem("entryIds", Support::toString<QStringList>(params.entryIds()));
}
return result;
}
QByteArray RemoveFromPlaylistLoader::body(const RemoveFromPlaylistParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation RemoveFromPlaylistLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
GetPlaylistItemsLoader::GetPlaylistItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetPlaylistItemsParams>(apiClient) {}
@ -127,6 +194,35 @@ QNetworkAccessManager::Operation GetPlaylistItemsLoader::operation() const {
}
MoveItemLoader::MoveItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, MoveItemParams>(apiClient) {}
QString MoveItemLoader::path(const MoveItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Playlists/") + Support::toString< QString>(params.playlistId()) + QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Move/") + Support::toString< qint32>(params.newIndex()) ;
}
QUrlQuery MoveItemLoader::query(const MoveItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray MoveItemLoader::body(const MoveItemParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation MoveItemLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -35,6 +35,125 @@ namespace HTTP {
using namespace Jellyfin::DTO;
ReportPlaybackStartLoader::ReportPlaybackStartLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, ReportPlaybackStartParams>(apiClient) {}
QString ReportPlaybackStartLoader::path(const ReportPlaybackStartParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/Playing");
}
QUrlQuery ReportPlaybackStartLoader::query(const ReportPlaybackStartParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray ReportPlaybackStartLoader::body(const ReportPlaybackStartParams &params) const {
return Support::toString<QSharedPointer<PlaybackStartInfo>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation ReportPlaybackStartLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
PingPlaybackSessionLoader::PingPlaybackSessionLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PingPlaybackSessionParams>(apiClient) {}
QString PingPlaybackSessionLoader::path(const PingPlaybackSessionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/Playing/Ping");
}
QUrlQuery PingPlaybackSessionLoader::query(const PingPlaybackSessionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.playSessionIdNull()) {
result.addQueryItem("playSessionId", Support::toString<QString>(params.playSessionId()));
}
return result;
}
QByteArray PingPlaybackSessionLoader::body(const PingPlaybackSessionParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PingPlaybackSessionLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
ReportPlaybackProgressLoader::ReportPlaybackProgressLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, ReportPlaybackProgressParams>(apiClient) {}
QString ReportPlaybackProgressLoader::path(const ReportPlaybackProgressParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/Playing/Progress");
}
QUrlQuery ReportPlaybackProgressLoader::query(const ReportPlaybackProgressParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray ReportPlaybackProgressLoader::body(const ReportPlaybackProgressParams &params) const {
return Support::toString<QSharedPointer<PlaybackProgressInfo>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation ReportPlaybackProgressLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
ReportPlaybackStoppedLoader::ReportPlaybackStoppedLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, ReportPlaybackStoppedParams>(apiClient) {}
QString ReportPlaybackStoppedLoader::path(const ReportPlaybackStoppedParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/Playing/Stopped");
}
QUrlQuery ReportPlaybackStoppedLoader::query(const ReportPlaybackStoppedParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray ReportPlaybackStoppedLoader::body(const ReportPlaybackStoppedParams &params) const {
return Support::toString<QSharedPointer<PlaybackStopInfo>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation ReportPlaybackStoppedLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
MarkPlayedItemLoader::MarkPlayedItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<UserItemDataDto, MarkPlayedItemParams>(apiClient) {}
@ -96,6 +215,162 @@ QNetworkAccessManager::Operation MarkUnplayedItemLoader::operation() const {
}
OnPlaybackStartLoader::OnPlaybackStartLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, OnPlaybackStartParams>(apiClient) {}
QString OnPlaybackStartLoader::path(const OnPlaybackStartParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/PlayingItems/") + Support::toString< QString>(params.itemId()) ;
}
QUrlQuery OnPlaybackStartLoader::query(const OnPlaybackStartParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.mediaSourceIdNull()) {
result.addQueryItem("mediaSourceId", Support::toString<QString>(params.mediaSourceId()));
}
if (!params.audioStreamIndexNull()) {
result.addQueryItem("audioStreamIndex", Support::toString<std::optional<qint32>>(params.audioStreamIndex()));
}
if (!params.subtitleStreamIndexNull()) {
result.addQueryItem("subtitleStreamIndex", Support::toString<std::optional<qint32>>(params.subtitleStreamIndex()));
}
if (!params.playMethodNull()) {
result.addQueryItem("playMethod", Support::toString<PlayMethod>(params.playMethod()));
}
if (!params.liveStreamIdNull()) {
result.addQueryItem("liveStreamId", Support::toString<QString>(params.liveStreamId()));
}
if (!params.playSessionIdNull()) {
result.addQueryItem("playSessionId", Support::toString<QString>(params.playSessionId()));
}
if (!params.canSeekNull()) {
result.addQueryItem("canSeek", Support::toString<std::optional<bool>>(params.canSeek()));
}
return result;
}
QByteArray OnPlaybackStartLoader::body(const OnPlaybackStartParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation OnPlaybackStartLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
OnPlaybackStoppedLoader::OnPlaybackStoppedLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, OnPlaybackStoppedParams>(apiClient) {}
QString OnPlaybackStoppedLoader::path(const OnPlaybackStoppedParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/PlayingItems/") + Support::toString< QString>(params.itemId()) ;
}
QUrlQuery OnPlaybackStoppedLoader::query(const OnPlaybackStoppedParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.mediaSourceIdNull()) {
result.addQueryItem("mediaSourceId", Support::toString<QString>(params.mediaSourceId()));
}
if (!params.nextMediaTypeNull()) {
result.addQueryItem("nextMediaType", Support::toString<QString>(params.nextMediaType()));
}
if (!params.positionTicksNull()) {
result.addQueryItem("positionTicks", Support::toString<std::optional<qint64>>(params.positionTicks()));
}
if (!params.liveStreamIdNull()) {
result.addQueryItem("liveStreamId", Support::toString<QString>(params.liveStreamId()));
}
if (!params.playSessionIdNull()) {
result.addQueryItem("playSessionId", Support::toString<QString>(params.playSessionId()));
}
return result;
}
QByteArray OnPlaybackStoppedLoader::body(const OnPlaybackStoppedParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation OnPlaybackStoppedLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
OnPlaybackProgressLoader::OnPlaybackProgressLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, OnPlaybackProgressParams>(apiClient) {}
QString OnPlaybackProgressLoader::path(const OnPlaybackProgressParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/PlayingItems/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Progress");
}
QUrlQuery OnPlaybackProgressLoader::query(const OnPlaybackProgressParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.mediaSourceIdNull()) {
result.addQueryItem("mediaSourceId", Support::toString<QString>(params.mediaSourceId()));
}
if (!params.positionTicksNull()) {
result.addQueryItem("positionTicks", Support::toString<std::optional<qint64>>(params.positionTicks()));
}
if (!params.audioStreamIndexNull()) {
result.addQueryItem("audioStreamIndex", Support::toString<std::optional<qint32>>(params.audioStreamIndex()));
}
if (!params.subtitleStreamIndexNull()) {
result.addQueryItem("subtitleStreamIndex", Support::toString<std::optional<qint32>>(params.subtitleStreamIndex()));
}
if (!params.volumeLevelNull()) {
result.addQueryItem("volumeLevel", Support::toString<std::optional<qint32>>(params.volumeLevel()));
}
if (!params.playMethodNull()) {
result.addQueryItem("playMethod", Support::toString<PlayMethod>(params.playMethod()));
}
if (!params.liveStreamIdNull()) {
result.addQueryItem("liveStreamId", Support::toString<QString>(params.liveStreamId()));
}
if (!params.playSessionIdNull()) {
result.addQueryItem("playSessionId", Support::toString<QString>(params.playSessionId()));
}
if (!params.repeatModeNull()) {
result.addQueryItem("repeatMode", Support::toString<RepeatMode>(params.repeatMode()));
}
if (!params.isPausedNull()) {
result.addQueryItem("isPaused", Support::toString<std::optional<bool>>(params.isPaused()));
}
if (!params.isMutedNull()) {
result.addQueryItem("isMuted", Support::toString<std::optional<bool>>(params.isMuted()));
}
return result;
}
QByteArray OnPlaybackProgressLoader::body(const OnPlaybackProgressParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation OnPlaybackProgressLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -64,6 +64,122 @@ QNetworkAccessManager::Operation GetPluginsLoader::operation() const {
}
UninstallPluginLoader::UninstallPluginLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UninstallPluginParams>(apiClient) {}
QString UninstallPluginLoader::path(const UninstallPluginParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) ;
}
QUrlQuery UninstallPluginLoader::query(const UninstallPluginParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UninstallPluginLoader::body(const UninstallPluginParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation UninstallPluginLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
UninstallPluginByVersionLoader::UninstallPluginByVersionLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UninstallPluginByVersionParams>(apiClient) {}
QString UninstallPluginByVersionLoader::path(const UninstallPluginByVersionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) + QStringLiteral("/") + Support::toString< QSharedPointer<Version>>(params.version()) ;
}
QUrlQuery UninstallPluginByVersionLoader::query(const UninstallPluginByVersionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UninstallPluginByVersionLoader::body(const UninstallPluginByVersionParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation UninstallPluginByVersionLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
DisablePluginLoader::DisablePluginLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DisablePluginParams>(apiClient) {}
QString DisablePluginLoader::path(const DisablePluginParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) + QStringLiteral("/") + Support::toString< QSharedPointer<Version>>(params.version()) + QStringLiteral("/Disable");
}
QUrlQuery DisablePluginLoader::query(const DisablePluginParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray DisablePluginLoader::body(const DisablePluginParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DisablePluginLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
EnablePluginLoader::EnablePluginLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, EnablePluginParams>(apiClient) {}
QString EnablePluginLoader::path(const EnablePluginParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) + QStringLiteral("/") + Support::toString< QSharedPointer<Version>>(params.version()) + QStringLiteral("/Enable");
}
QUrlQuery EnablePluginLoader::query(const EnablePluginParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray EnablePluginLoader::body(const EnablePluginParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation EnablePluginLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetPluginConfigurationLoader::GetPluginConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<BasePluginConfiguration, GetPluginConfigurationParams>(apiClient) {}
@ -93,6 +209,93 @@ QNetworkAccessManager::Operation GetPluginConfigurationLoader::operation() const
}
UpdatePluginConfigurationLoader::UpdatePluginConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdatePluginConfigurationParams>(apiClient) {}
QString UpdatePluginConfigurationLoader::path(const UpdatePluginConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) + QStringLiteral("/Configuration");
}
QUrlQuery UpdatePluginConfigurationLoader::query(const UpdatePluginConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdatePluginConfigurationLoader::body(const UpdatePluginConfigurationParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation UpdatePluginConfigurationLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetPluginManifestLoader::GetPluginManifestLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, GetPluginManifestParams>(apiClient) {}
QString GetPluginManifestLoader::path(const GetPluginManifestParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Plugins/") + Support::toString< QString>(params.pluginId()) + QStringLiteral("/Manifest");
}
QUrlQuery GetPluginManifestLoader::query(const GetPluginManifestParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray GetPluginManifestLoader::body(const GetPluginManifestParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation GetPluginManifestLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
UpdatePluginSecurityInfoLoader::UpdatePluginSecurityInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdatePluginSecurityInfoParams>(apiClient) {}
QString UpdatePluginSecurityInfoLoader::path(const UpdatePluginSecurityInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Plugins/SecurityInfo");
}
QUrlQuery UpdatePluginSecurityInfoLoader::query(const UpdatePluginSecurityInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdatePluginSecurityInfoLoader::body(const UpdatePluginSecurityInfoParams &params) const {
return Support::toString<QSharedPointer<PluginSecurityInfo>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdatePluginSecurityInfoLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -35,6 +35,35 @@ namespace HTTP {
using namespace Jellyfin::DTO;
ActivateLoader::ActivateLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, ActivateParams>(apiClient) {}
QString ActivateLoader::path(const ActivateParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/QuickConnect/Activate");
}
QUrlQuery ActivateLoader::query(const ActivateParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray ActivateLoader::body(const ActivateParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation ActivateLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
AuthorizeLoader::AuthorizeLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<bool, AuthorizeParams>(apiClient) {}
@ -65,6 +94,38 @@ QNetworkAccessManager::Operation AuthorizeLoader::operation() const {
}
AvailableLoader::AvailableLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, AvailableParams>(apiClient) {}
QString AvailableLoader::path(const AvailableParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/QuickConnect/Available");
}
QUrlQuery AvailableLoader::query(const AvailableParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.statusNull()) {
result.addQueryItem("status", Support::toString<QuickConnectState>(params.status()));
}
return result;
}
QByteArray AvailableLoader::body(const AvailableParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation AvailableLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
ConnectLoader::ConnectLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QuickConnectResult, ConnectParams>(apiClient) {}

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

@ -79,6 +79,39 @@ QNetworkAccessManager::Operation GetRemoteImagesLoader::operation() const {
}
DownloadRemoteImageLoader::DownloadRemoteImageLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DownloadRemoteImageParams>(apiClient) {}
QString DownloadRemoteImageLoader::path(const DownloadRemoteImageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/RemoteImages/Download");
}
QUrlQuery DownloadRemoteImageLoader::query(const DownloadRemoteImageParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("type", Support::toString<ImageType>(params.type()));
// Optional parameters
if (!params.imageUrlNull()) {
result.addQueryItem("imageUrl", Support::toString<QString>(params.imageUrl()));
}
return result;
}
QByteArray DownloadRemoteImageLoader::body(const DownloadRemoteImageParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DownloadRemoteImageLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetRemoteImageProvidersLoader::GetRemoteImageProvidersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ImageProviderInfo>, GetRemoteImageProvidersParams>(apiClient) {}

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

@ -99,6 +99,93 @@ QNetworkAccessManager::Operation GetTaskLoader::operation() const {
}
UpdateTaskLoader::UpdateTaskLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateTaskParams>(apiClient) {}
QString UpdateTaskLoader::path(const UpdateTaskParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/ScheduledTasks/") + Support::toString< QString>(params.taskId()) + QStringLiteral("/Triggers");
}
QUrlQuery UpdateTaskLoader::query(const UpdateTaskParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateTaskLoader::body(const UpdateTaskParams &params) const {
return Support::toString<QList<TaskTriggerInfo>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateTaskLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
StartTaskLoader::StartTaskLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, StartTaskParams>(apiClient) {}
QString StartTaskLoader::path(const StartTaskParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/ScheduledTasks/Running/") + Support::toString< QString>(params.taskId()) ;
}
QUrlQuery StartTaskLoader::query(const StartTaskParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray StartTaskLoader::body(const StartTaskParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation StartTaskLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
StopTaskLoader::StopTaskLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, StopTaskParams>(apiClient) {}
QString StopTaskLoader::path(const StopTaskParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/ScheduledTasks/Running/") + Support::toString< QString>(params.taskId()) ;
}
QUrlQuery StopTaskLoader::query(const StopTaskParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray StopTaskLoader::body(const StopTaskParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation StopTaskLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
} // NS HTTP
} // NS Loader

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

@ -131,6 +131,429 @@ QNetworkAccessManager::Operation GetSessionsLoader::operation() const {
}
SendFullGeneralCommandLoader::SendFullGeneralCommandLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SendFullGeneralCommandParams>(apiClient) {}
QString SendFullGeneralCommandLoader::path(const SendFullGeneralCommandParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/") + Support::toString< QString>(params.sessionId()) + QStringLiteral("/Command");
}
QUrlQuery SendFullGeneralCommandLoader::query(const SendFullGeneralCommandParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SendFullGeneralCommandLoader::body(const SendFullGeneralCommandParams &params) const {
return Support::toString<QSharedPointer<GeneralCommand>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SendFullGeneralCommandLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SendGeneralCommandLoader::SendGeneralCommandLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SendGeneralCommandParams>(apiClient) {}
QString SendGeneralCommandLoader::path(const SendGeneralCommandParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/") + Support::toString< QString>(params.sessionId()) + QStringLiteral("/Command/") + Support::toString< GeneralCommandType>(params.command()) ;
}
QUrlQuery SendGeneralCommandLoader::query(const SendGeneralCommandParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SendGeneralCommandLoader::body(const SendGeneralCommandParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SendGeneralCommandLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SendMessageCommandLoader::SendMessageCommandLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SendMessageCommandParams>(apiClient) {}
QString SendMessageCommandLoader::path(const SendMessageCommandParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/") + Support::toString< QString>(params.sessionId()) + QStringLiteral("/Message");
}
QUrlQuery SendMessageCommandLoader::query(const SendMessageCommandParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("text", Support::toString<QString>(params.text()));
// Optional parameters
if (!params.headerNull()) {
result.addQueryItem("header", Support::toString<QString>(params.header()));
}
if (!params.timeoutMsNull()) {
result.addQueryItem("timeoutMs", Support::toString<std::optional<qint64>>(params.timeoutMs()));
}
return result;
}
QByteArray SendMessageCommandLoader::body(const SendMessageCommandParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SendMessageCommandLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
PlayLoader::PlayLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PlayParams>(apiClient) {}
QString PlayLoader::path(const PlayParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/") + Support::toString< QString>(params.sessionId()) + QStringLiteral("/Playing");
}
QUrlQuery PlayLoader::query(const PlayParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("playCommand", Support::toString<PlayCommand>(params.playCommand()));
result.addQueryItem("itemIds", Support::toString<QStringList>(params.itemIds()));
// Optional parameters
if (!params.startPositionTicksNull()) {
result.addQueryItem("startPositionTicks", Support::toString<std::optional<qint64>>(params.startPositionTicks()));
}
return result;
}
QByteArray PlayLoader::body(const PlayParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PlayLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SendPlaystateCommandLoader::SendPlaystateCommandLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SendPlaystateCommandParams>(apiClient) {}
QString SendPlaystateCommandLoader::path(const SendPlaystateCommandParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/") + Support::toString< QString>(params.sessionId()) + QStringLiteral("/Playing/") + Support::toString< PlaystateCommand>(params.command()) ;
}
QUrlQuery SendPlaystateCommandLoader::query(const SendPlaystateCommandParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.seekPositionTicksNull()) {
result.addQueryItem("seekPositionTicks", Support::toString<std::optional<qint64>>(params.seekPositionTicks()));
}
if (!params.controllingUserIdNull()) {
result.addQueryItem("controllingUserId", Support::toString<QString>(params.controllingUserId()));
}
return result;
}
QByteArray SendPlaystateCommandLoader::body(const SendPlaystateCommandParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SendPlaystateCommandLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SendSystemCommandLoader::SendSystemCommandLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SendSystemCommandParams>(apiClient) {}
QString SendSystemCommandLoader::path(const SendSystemCommandParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/") + Support::toString< QString>(params.sessionId()) + QStringLiteral("/System/") + Support::toString< GeneralCommandType>(params.command()) ;
}
QUrlQuery SendSystemCommandLoader::query(const SendSystemCommandParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SendSystemCommandLoader::body(const SendSystemCommandParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SendSystemCommandLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
AddUserToSessionLoader::AddUserToSessionLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, AddUserToSessionParams>(apiClient) {}
QString AddUserToSessionLoader::path(const AddUserToSessionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/") + Support::toString< QString>(params.sessionId()) + QStringLiteral("/User/") + Support::toString< QString>(params.userId()) ;
}
QUrlQuery AddUserToSessionLoader::query(const AddUserToSessionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray AddUserToSessionLoader::body(const AddUserToSessionParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation AddUserToSessionLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
RemoveUserFromSessionLoader::RemoveUserFromSessionLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, RemoveUserFromSessionParams>(apiClient) {}
QString RemoveUserFromSessionLoader::path(const RemoveUserFromSessionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/") + Support::toString< QString>(params.sessionId()) + QStringLiteral("/User/") + Support::toString< QString>(params.userId()) ;
}
QUrlQuery RemoveUserFromSessionLoader::query(const RemoveUserFromSessionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray RemoveUserFromSessionLoader::body(const RemoveUserFromSessionParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation RemoveUserFromSessionLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
DisplayContentLoader::DisplayContentLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DisplayContentParams>(apiClient) {}
QString DisplayContentLoader::path(const DisplayContentParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/") + Support::toString< QString>(params.sessionId()) + QStringLiteral("/Viewing");
}
QUrlQuery DisplayContentLoader::query(const DisplayContentParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("itemType", Support::toString<QString>(params.itemType()));
result.addQueryItem("itemId", Support::toString<QString>(params.itemId()));
result.addQueryItem("itemName", Support::toString<QString>(params.itemName()));
// Optional parameters
return result;
}
QByteArray DisplayContentLoader::body(const DisplayContentParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DisplayContentLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
PostCapabilitiesLoader::PostCapabilitiesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PostCapabilitiesParams>(apiClient) {}
QString PostCapabilitiesLoader::path(const PostCapabilitiesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/Capabilities");
}
QUrlQuery PostCapabilitiesLoader::query(const PostCapabilitiesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.jellyfinIdNull()) {
result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
}
if (!params.playableMediaTypesNull()) {
result.addQueryItem("playableMediaTypes", Support::toString<QStringList>(params.playableMediaTypes()));
}
if (!params.supportedCommandsNull()) {
result.addQueryItem("supportedCommands", Support::toString<QList<GeneralCommandType>>(params.supportedCommands()));
}
if (!params.supportsMediaControlNull()) {
result.addQueryItem("supportsMediaControl", Support::toString<std::optional<bool>>(params.supportsMediaControl()));
}
if (!params.supportsSyncNull()) {
result.addQueryItem("supportsSync", Support::toString<std::optional<bool>>(params.supportsSync()));
}
if (!params.supportsPersistentIdentifierNull()) {
result.addQueryItem("supportsPersistentIdentifier", Support::toString<std::optional<bool>>(params.supportsPersistentIdentifier()));
}
return result;
}
QByteArray PostCapabilitiesLoader::body(const PostCapabilitiesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation PostCapabilitiesLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
PostFullCapabilitiesLoader::PostFullCapabilitiesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, PostFullCapabilitiesParams>(apiClient) {}
QString PostFullCapabilitiesLoader::path(const PostFullCapabilitiesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/Capabilities/Full");
}
QUrlQuery PostFullCapabilitiesLoader::query(const PostFullCapabilitiesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.jellyfinIdNull()) {
result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
}
return result;
}
QByteArray PostFullCapabilitiesLoader::body(const PostFullCapabilitiesParams &params) const {
return Support::toString<QSharedPointer<ClientCapabilitiesDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation PostFullCapabilitiesLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
ReportSessionEndedLoader::ReportSessionEndedLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, ReportSessionEndedParams>(apiClient) {}
QString ReportSessionEndedLoader::path(const ReportSessionEndedParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/Logout");
}
QUrlQuery ReportSessionEndedLoader::query(const ReportSessionEndedParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray ReportSessionEndedLoader::body(const ReportSessionEndedParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation ReportSessionEndedLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
ReportViewingLoader::ReportViewingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, ReportViewingParams>(apiClient) {}
QString ReportViewingLoader::path(const ReportViewingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Sessions/Viewing");
}
QUrlQuery ReportViewingLoader::query(const ReportViewingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("itemId", Support::toString<QString>(params.itemId()));
// Optional parameters
if (!params.sessionIdNull()) {
result.addQueryItem("sessionId", Support::toString<QString>(params.sessionId()));
}
return result;
}
QByteArray ReportViewingLoader::body(const ReportViewingParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation ReportViewingLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -35,6 +35,35 @@ namespace HTTP {
using namespace Jellyfin::DTO;
CompleteWizardLoader::CompleteWizardLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, CompleteWizardParams>(apiClient) {}
QString CompleteWizardLoader::path(const CompleteWizardParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Startup/Complete");
}
QUrlQuery CompleteWizardLoader::query(const CompleteWizardParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray CompleteWizardLoader::body(const CompleteWizardParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation CompleteWizardLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetStartupConfigurationLoader::GetStartupConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<StartupConfigurationDto, GetStartupConfigurationParams>(apiClient) {}
@ -64,6 +93,35 @@ QNetworkAccessManager::Operation GetStartupConfigurationLoader::operation() cons
}
UpdateInitialConfigurationLoader::UpdateInitialConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateInitialConfigurationParams>(apiClient) {}
QString UpdateInitialConfigurationLoader::path(const UpdateInitialConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Startup/Configuration");
}
QUrlQuery UpdateInitialConfigurationLoader::query(const UpdateInitialConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateInitialConfigurationLoader::body(const UpdateInitialConfigurationParams &params) const {
return Support::toString<QSharedPointer<StartupConfigurationDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateInitialConfigurationLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetFirstUser_2Loader::GetFirstUser_2Loader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<StartupUserDto, GetFirstUser_2Params>(apiClient) {}
@ -93,6 +151,35 @@ QNetworkAccessManager::Operation GetFirstUser_2Loader::operation() const {
}
SetRemoteAccessLoader::SetRemoteAccessLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SetRemoteAccessParams>(apiClient) {}
QString SetRemoteAccessLoader::path(const SetRemoteAccessParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Startup/RemoteAccess");
}
QUrlQuery SetRemoteAccessLoader::query(const SetRemoteAccessParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SetRemoteAccessLoader::body(const SetRemoteAccessParams &params) const {
return Support::toString<QSharedPointer<StartupRemoteAccessDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SetRemoteAccessLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetFirstUserLoader::GetFirstUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<StartupUserDto, GetFirstUserParams>(apiClient) {}
@ -122,6 +209,35 @@ QNetworkAccessManager::Operation GetFirstUserLoader::operation() const {
}
UpdateStartupUserLoader::UpdateStartupUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateStartupUserParams>(apiClient) {}
QString UpdateStartupUserLoader::path(const UpdateStartupUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Startup/User");
}
QUrlQuery UpdateStartupUserLoader::query(const UpdateStartupUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateStartupUserLoader::body(const UpdateStartupUserParams &params) const {
return Support::toString<QSharedPointer<StartupUserDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateStartupUserLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -96,6 +96,93 @@ QNetworkAccessManager::Operation SearchRemoteSubtitlesLoader::operation() const
}
DownloadRemoteSubtitlesLoader::DownloadRemoteSubtitlesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DownloadRemoteSubtitlesParams>(apiClient) {}
QString DownloadRemoteSubtitlesLoader::path(const DownloadRemoteSubtitlesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/RemoteSearch/Subtitles/") + Support::toString< QString>(params.subtitleId()) ;
}
QUrlQuery DownloadRemoteSubtitlesLoader::query(const DownloadRemoteSubtitlesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray DownloadRemoteSubtitlesLoader::body(const DownloadRemoteSubtitlesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DownloadRemoteSubtitlesLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
UploadSubtitleLoader::UploadSubtitleLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UploadSubtitleParams>(apiClient) {}
QString UploadSubtitleLoader::path(const UploadSubtitleParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Videos/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Subtitles");
}
QUrlQuery UploadSubtitleLoader::query(const UploadSubtitleParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UploadSubtitleLoader::body(const UploadSubtitleParams &params) const {
return Support::toString<QSharedPointer<UploadSubtitleDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UploadSubtitleLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
DeleteSubtitleLoader::DeleteSubtitleLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteSubtitleParams>(apiClient) {}
QString DeleteSubtitleLoader::path(const DeleteSubtitleParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Videos/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Subtitles/") + Support::toString< qint32>(params.index()) ;
}
QUrlQuery DeleteSubtitleLoader::query(const DeleteSubtitleParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray DeleteSubtitleLoader::body(const DeleteSubtitleParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteSubtitleLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
} // NS HTTP
} // NS Loader

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

@ -35,6 +35,93 @@ namespace HTTP {
using namespace Jellyfin::DTO;
SyncPlayBufferingLoader::SyncPlayBufferingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayBufferingParams>(apiClient) {}
QString SyncPlayBufferingLoader::path(const SyncPlayBufferingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/Buffering");
}
QUrlQuery SyncPlayBufferingLoader::query(const SyncPlayBufferingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayBufferingLoader::body(const SyncPlayBufferingParams &params) const {
return Support::toString<QSharedPointer<BufferRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlayBufferingLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayJoinGroupLoader::SyncPlayJoinGroupLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayJoinGroupParams>(apiClient) {}
QString SyncPlayJoinGroupLoader::path(const SyncPlayJoinGroupParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/Join");
}
QUrlQuery SyncPlayJoinGroupLoader::query(const SyncPlayJoinGroupParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayJoinGroupLoader::body(const SyncPlayJoinGroupParams &params) const {
return Support::toString<QSharedPointer<JoinGroupRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlayJoinGroupLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayLeaveGroupLoader::SyncPlayLeaveGroupLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayLeaveGroupParams>(apiClient) {}
QString SyncPlayLeaveGroupLoader::path(const SyncPlayLeaveGroupParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/Leave");
}
QUrlQuery SyncPlayLeaveGroupLoader::query(const SyncPlayLeaveGroupParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayLeaveGroupLoader::body(const SyncPlayLeaveGroupParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SyncPlayLeaveGroupLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayGetGroupsLoader::SyncPlayGetGroupsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<GroupInfoDto>, SyncPlayGetGroupsParams>(apiClient) {}
@ -64,6 +151,499 @@ QNetworkAccessManager::Operation SyncPlayGetGroupsLoader::operation() const {
}
SyncPlayMovePlaylistItemLoader::SyncPlayMovePlaylistItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayMovePlaylistItemParams>(apiClient) {}
QString SyncPlayMovePlaylistItemLoader::path(const SyncPlayMovePlaylistItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/MovePlaylistItem");
}
QUrlQuery SyncPlayMovePlaylistItemLoader::query(const SyncPlayMovePlaylistItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayMovePlaylistItemLoader::body(const SyncPlayMovePlaylistItemParams &params) const {
return Support::toString<QSharedPointer<MovePlaylistItemRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlayMovePlaylistItemLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayCreateGroupLoader::SyncPlayCreateGroupLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayCreateGroupParams>(apiClient) {}
QString SyncPlayCreateGroupLoader::path(const SyncPlayCreateGroupParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/New");
}
QUrlQuery SyncPlayCreateGroupLoader::query(const SyncPlayCreateGroupParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayCreateGroupLoader::body(const SyncPlayCreateGroupParams &params) const {
return Support::toString<QSharedPointer<NewGroupRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlayCreateGroupLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayNextItemLoader::SyncPlayNextItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayNextItemParams>(apiClient) {}
QString SyncPlayNextItemLoader::path(const SyncPlayNextItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/NextItem");
}
QUrlQuery SyncPlayNextItemLoader::query(const SyncPlayNextItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayNextItemLoader::body(const SyncPlayNextItemParams &params) const {
return Support::toString<QSharedPointer<NextItemRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlayNextItemLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayPauseLoader::SyncPlayPauseLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayPauseParams>(apiClient) {}
QString SyncPlayPauseLoader::path(const SyncPlayPauseParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/Pause");
}
QUrlQuery SyncPlayPauseLoader::query(const SyncPlayPauseParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayPauseLoader::body(const SyncPlayPauseParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SyncPlayPauseLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayPingLoader::SyncPlayPingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayPingParams>(apiClient) {}
QString SyncPlayPingLoader::path(const SyncPlayPingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/Ping");
}
QUrlQuery SyncPlayPingLoader::query(const SyncPlayPingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayPingLoader::body(const SyncPlayPingParams &params) const {
return Support::toString<QSharedPointer<PingRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlayPingLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayPreviousItemLoader::SyncPlayPreviousItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayPreviousItemParams>(apiClient) {}
QString SyncPlayPreviousItemLoader::path(const SyncPlayPreviousItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/PreviousItem");
}
QUrlQuery SyncPlayPreviousItemLoader::query(const SyncPlayPreviousItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayPreviousItemLoader::body(const SyncPlayPreviousItemParams &params) const {
return Support::toString<QSharedPointer<PreviousItemRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlayPreviousItemLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayQueueLoader::SyncPlayQueueLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayQueueParams>(apiClient) {}
QString SyncPlayQueueLoader::path(const SyncPlayQueueParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/Queue");
}
QUrlQuery SyncPlayQueueLoader::query(const SyncPlayQueueParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayQueueLoader::body(const SyncPlayQueueParams &params) const {
return Support::toString<QSharedPointer<QueueRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlayQueueLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayReadyLoader::SyncPlayReadyLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayReadyParams>(apiClient) {}
QString SyncPlayReadyLoader::path(const SyncPlayReadyParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/Ready");
}
QUrlQuery SyncPlayReadyLoader::query(const SyncPlayReadyParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayReadyLoader::body(const SyncPlayReadyParams &params) const {
return Support::toString<QSharedPointer<ReadyRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlayReadyLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayRemoveFromPlaylistLoader::SyncPlayRemoveFromPlaylistLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayRemoveFromPlaylistParams>(apiClient) {}
QString SyncPlayRemoveFromPlaylistLoader::path(const SyncPlayRemoveFromPlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/RemoveFromPlaylist");
}
QUrlQuery SyncPlayRemoveFromPlaylistLoader::query(const SyncPlayRemoveFromPlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayRemoveFromPlaylistLoader::body(const SyncPlayRemoveFromPlaylistParams &params) const {
return Support::toString<QSharedPointer<RemoveFromPlaylistRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlayRemoveFromPlaylistLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlaySeekLoader::SyncPlaySeekLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlaySeekParams>(apiClient) {}
QString SyncPlaySeekLoader::path(const SyncPlaySeekParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/Seek");
}
QUrlQuery SyncPlaySeekLoader::query(const SyncPlaySeekParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlaySeekLoader::body(const SyncPlaySeekParams &params) const {
return Support::toString<QSharedPointer<SeekRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlaySeekLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlaySetIgnoreWaitLoader::SyncPlaySetIgnoreWaitLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlaySetIgnoreWaitParams>(apiClient) {}
QString SyncPlaySetIgnoreWaitLoader::path(const SyncPlaySetIgnoreWaitParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/SetIgnoreWait");
}
QUrlQuery SyncPlaySetIgnoreWaitLoader::query(const SyncPlaySetIgnoreWaitParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlaySetIgnoreWaitLoader::body(const SyncPlaySetIgnoreWaitParams &params) const {
return Support::toString<QSharedPointer<IgnoreWaitRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlaySetIgnoreWaitLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlaySetNewQueueLoader::SyncPlaySetNewQueueLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlaySetNewQueueParams>(apiClient) {}
QString SyncPlaySetNewQueueLoader::path(const SyncPlaySetNewQueueParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/SetNewQueue");
}
QUrlQuery SyncPlaySetNewQueueLoader::query(const SyncPlaySetNewQueueParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlaySetNewQueueLoader::body(const SyncPlaySetNewQueueParams &params) const {
return Support::toString<QSharedPointer<PlayRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlaySetNewQueueLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlaySetPlaylistItemLoader::SyncPlaySetPlaylistItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlaySetPlaylistItemParams>(apiClient) {}
QString SyncPlaySetPlaylistItemLoader::path(const SyncPlaySetPlaylistItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/SetPlaylistItem");
}
QUrlQuery SyncPlaySetPlaylistItemLoader::query(const SyncPlaySetPlaylistItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlaySetPlaylistItemLoader::body(const SyncPlaySetPlaylistItemParams &params) const {
return Support::toString<QSharedPointer<SetPlaylistItemRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlaySetPlaylistItemLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlaySetRepeatModeLoader::SyncPlaySetRepeatModeLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlaySetRepeatModeParams>(apiClient) {}
QString SyncPlaySetRepeatModeLoader::path(const SyncPlaySetRepeatModeParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/SetRepeatMode");
}
QUrlQuery SyncPlaySetRepeatModeLoader::query(const SyncPlaySetRepeatModeParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlaySetRepeatModeLoader::body(const SyncPlaySetRepeatModeParams &params) const {
return Support::toString<QSharedPointer<SetRepeatModeRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlaySetRepeatModeLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlaySetShuffleModeLoader::SyncPlaySetShuffleModeLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlaySetShuffleModeParams>(apiClient) {}
QString SyncPlaySetShuffleModeLoader::path(const SyncPlaySetShuffleModeParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/SetShuffleMode");
}
QUrlQuery SyncPlaySetShuffleModeLoader::query(const SyncPlaySetShuffleModeParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlaySetShuffleModeLoader::body(const SyncPlaySetShuffleModeParams &params) const {
return Support::toString<QSharedPointer<SetShuffleModeRequestDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation SyncPlaySetShuffleModeLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayStopLoader::SyncPlayStopLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayStopParams>(apiClient) {}
QString SyncPlayStopLoader::path(const SyncPlayStopParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/Stop");
}
QUrlQuery SyncPlayStopLoader::query(const SyncPlayStopParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayStopLoader::body(const SyncPlayStopParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SyncPlayStopLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
SyncPlayUnpauseLoader::SyncPlayUnpauseLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, SyncPlayUnpauseParams>(apiClient) {}
QString SyncPlayUnpauseLoader::path(const SyncPlayUnpauseParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/SyncPlay/Unpause");
}
QUrlQuery SyncPlayUnpauseLoader::query(const SyncPlayUnpauseParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray SyncPlayUnpauseLoader::body(const SyncPlayUnpauseParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation SyncPlayUnpauseLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader

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

@ -209,6 +209,64 @@ QNetworkAccessManager::Operation PostPingSystemLoader::operation() const {
}
RestartApplicationLoader::RestartApplicationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, RestartApplicationParams>(apiClient) {}
QString RestartApplicationLoader::path(const RestartApplicationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/Restart");
}
QUrlQuery RestartApplicationLoader::query(const RestartApplicationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray RestartApplicationLoader::body(const RestartApplicationParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation RestartApplicationLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
ShutdownApplicationLoader::ShutdownApplicationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, ShutdownApplicationParams>(apiClient) {}
QString ShutdownApplicationLoader::path(const ShutdownApplicationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/Shutdown");
}
QUrlQuery ShutdownApplicationLoader::query(const ShutdownApplicationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray ShutdownApplicationLoader::body(const ShutdownApplicationParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation ShutdownApplicationLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
GetWakeOnLanInfoLoader::GetWakeOnLanInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<WakeOnLanInfo>, GetWakeOnLanInfoParams>(apiClient) {}

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

@ -99,6 +99,64 @@ QNetworkAccessManager::Operation GetUserByIdLoader::operation() const {
}
DeleteUserLoader::DeleteUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteUserParams>(apiClient) {}
QString DeleteUserLoader::path(const DeleteUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) ;
}
QUrlQuery DeleteUserLoader::query(const DeleteUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray DeleteUserLoader::body(const DeleteUserParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteUserLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
UpdateUserLoader::UpdateUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateUserParams>(apiClient) {}
QString UpdateUserLoader::path(const UpdateUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) ;
}
QUrlQuery UpdateUserLoader::query(const UpdateUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateUserLoader::body(const UpdateUserParams &params) const {
return Support::toString<QSharedPointer<UserDto>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateUserLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
AuthenticateUserLoader::AuthenticateUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<AuthenticationResult, AuthenticateUserParams>(apiClient) {}
@ -132,6 +190,122 @@ QNetworkAccessManager::Operation AuthenticateUserLoader::operation() const {
}
UpdateUserConfigurationLoader::UpdateUserConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateUserConfigurationParams>(apiClient) {}
QString UpdateUserConfigurationLoader::path(const UpdateUserConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Configuration");
}
QUrlQuery UpdateUserConfigurationLoader::query(const UpdateUserConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateUserConfigurationLoader::body(const UpdateUserConfigurationParams &params) const {
return Support::toString<QSharedPointer<UserConfiguration>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateUserConfigurationLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
UpdateUserEasyPasswordLoader::UpdateUserEasyPasswordLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateUserEasyPasswordParams>(apiClient) {}
QString UpdateUserEasyPasswordLoader::path(const UpdateUserEasyPasswordParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/EasyPassword");
}
QUrlQuery UpdateUserEasyPasswordLoader::query(const UpdateUserEasyPasswordParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateUserEasyPasswordLoader::body(const UpdateUserEasyPasswordParams &params) const {
return Support::toString<QSharedPointer<UpdateUserEasyPassword>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateUserEasyPasswordLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
UpdateUserPasswordLoader::UpdateUserPasswordLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateUserPasswordParams>(apiClient) {}
QString UpdateUserPasswordLoader::path(const UpdateUserPasswordParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Password");
}
QUrlQuery UpdateUserPasswordLoader::query(const UpdateUserPasswordParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateUserPasswordLoader::body(const UpdateUserPasswordParams &params) const {
return Support::toString<QSharedPointer<UpdateUserPassword>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateUserPasswordLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
UpdateUserPolicyLoader::UpdateUserPolicyLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, UpdateUserPolicyParams>(apiClient) {}
QString UpdateUserPolicyLoader::path(const UpdateUserPolicyParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Policy");
}
QUrlQuery UpdateUserPolicyLoader::query(const UpdateUserPolicyParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray UpdateUserPolicyLoader::body(const UpdateUserPolicyParams &params) const {
return Support::toString<QSharedPointer<UserPolicy>>(params.body()).toUtf8();
}
QNetworkAccessManager::Operation UpdateUserPolicyLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
AuthenticateUserByNameLoader::AuthenticateUserByNameLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<AuthenticationResult, AuthenticateUserByNameParams>(apiClient) {}

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

@ -67,6 +67,65 @@ QNetworkAccessManager::Operation GetAdditionalPartLoader::operation() const {
}
DeleteAlternateSourcesLoader::DeleteAlternateSourcesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, DeleteAlternateSourcesParams>(apiClient) {}
QString DeleteAlternateSourcesLoader::path(const DeleteAlternateSourcesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Videos/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/AlternateSources");
}
QUrlQuery DeleteAlternateSourcesLoader::query(const DeleteAlternateSourcesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
QByteArray DeleteAlternateSourcesLoader::body(const DeleteAlternateSourcesParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation DeleteAlternateSourcesLoader::operation() const {
// HTTP method Delete
return QNetworkAccessManager::DeleteOperation;
}
MergeVersionsLoader::MergeVersionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<void, MergeVersionsParams>(apiClient) {}
QString MergeVersionsLoader::path(const MergeVersionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Videos/MergeVersions");
}
QUrlQuery MergeVersionsLoader::query(const MergeVersionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
// Optional parameters
return result;
}
QByteArray MergeVersionsLoader::body(const MergeVersionsParams &params) const {
return QByteArray();
}
QNetworkAccessManager::Operation MergeVersionsLoader::operation() const {
// HTTP method Post
return QNetworkAccessManager::PostOperation;
}
} // NS HTTP
} // NS Loader