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

WIP: Reimplementation of ListModels.

Browse source
This commit is contained in:
Chris Josten 2021-03-26 21:27:35 +01:00
parent 76a49868b9
commit e421adf733
356 changed files with 1830 additions and 1833 deletions
Download patch file Download diff file Expand all files Collapse all files

6
core/src/loader/http/addlistingprovider.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
AddListingProvider::AddListingProvider(ApiClient *apiClient)
AddListingProviderLoader::AddListingProviderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ListingsProviderInfo, AddListingProviderParams>(apiClient) {}
QString AddListingProvider::path(const AddListingProviderParams &params) const {
QString AddListingProviderLoader::path(const AddListingProviderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/ListingProviders");
}
QUrlQuery AddListingProvider::query(const AddListingProviderParams &params) const {
QUrlQuery AddListingProviderLoader::query(const AddListingProviderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/addtunerhost.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
AddTunerHost::AddTunerHost(ApiClient *apiClient)
AddTunerHostLoader::AddTunerHostLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::TunerHostInfo, AddTunerHostParams>(apiClient) {}
QString AddTunerHost::path(const AddTunerHostParams &params) const {
QString AddTunerHostLoader::path(const AddTunerHostParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/TunerHosts");
}
QUrlQuery AddTunerHost::query(const AddTunerHostParams &params) const {
QUrlQuery AddTunerHostLoader::query(const AddTunerHostParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/authenticateuser.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
AuthenticateUser::AuthenticateUser(ApiClient *apiClient)
AuthenticateUserLoader::AuthenticateUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::AuthenticationResult, AuthenticateUserParams>(apiClient) {}
QString AuthenticateUser::path(const AuthenticateUserParams &params) const {
QString AuthenticateUserLoader::path(const AuthenticateUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString(params.userId()) + QStringLiteral("/Authenticate");
}
QUrlQuery AuthenticateUser::query(const AuthenticateUserParams &params) const {
QUrlQuery AuthenticateUserLoader::query(const AuthenticateUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/authenticateuserbyname.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
AuthenticateUserByName::AuthenticateUserByName(ApiClient *apiClient)
AuthenticateUserByNameLoader::AuthenticateUserByNameLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::AuthenticationResult, AuthenticateUserByNameParams>(apiClient) {}
QString AuthenticateUserByName::path(const AuthenticateUserByNameParams &params) const {
QString AuthenticateUserByNameLoader::path(const AuthenticateUserByNameParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/AuthenticateByName");
}
QUrlQuery AuthenticateUserByName::query(const AuthenticateUserByNameParams &params) const {
QUrlQuery AuthenticateUserByNameLoader::query(const AuthenticateUserByNameParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/authenticatewithquickconnect.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
AuthenticateWithQuickConnect::AuthenticateWithQuickConnect(ApiClient *apiClient)
AuthenticateWithQuickConnectLoader::AuthenticateWithQuickConnectLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::AuthenticationResult, AuthenticateWithQuickConnectParams>(apiClient) {}
QString AuthenticateWithQuickConnect::path(const AuthenticateWithQuickConnectParams &params) const {
QString AuthenticateWithQuickConnectLoader::path(const AuthenticateWithQuickConnectParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/AuthenticateWithQuickConnect");
}
QUrlQuery AuthenticateWithQuickConnect::query(const AuthenticateWithQuickConnectParams &params) const {
QUrlQuery AuthenticateWithQuickConnectLoader::query(const AuthenticateWithQuickConnectParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/connect.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
Connect::Connect(ApiClient *apiClient)
ConnectLoader::ConnectLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::QuickConnectResult, ConnectParams>(apiClient) {}
QString Connect::path(const ConnectParams &params) const {
QString ConnectLoader::path(const ConnectParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/QuickConnect/Connect");
}
QUrlQuery Connect::query(const ConnectParams &params) const {
QUrlQuery ConnectLoader::query(const ConnectParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/createcollection.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
CreateCollection::CreateCollection(ApiClient *apiClient)
CreateCollectionLoader::CreateCollectionLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::CollectionCreationResult, CreateCollectionParams>(apiClient) {}
QString CreateCollection::path(const CreateCollectionParams &params) const {
QString CreateCollectionLoader::path(const CreateCollectionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Collections");
}
QUrlQuery CreateCollection::query(const CreateCollectionParams &params) const {
QUrlQuery CreateCollectionLoader::query(const CreateCollectionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/createplaylist.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
CreatePlaylist::CreatePlaylist(ApiClient *apiClient)
CreatePlaylistLoader::CreatePlaylistLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::PlaylistCreationResult, CreatePlaylistParams>(apiClient) {}
QString CreatePlaylist::path(const CreatePlaylistParams &params) const {
QString CreatePlaylistLoader::path(const CreatePlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Playlists");
}
QUrlQuery CreatePlaylist::query(const CreatePlaylistParams &params) const {
QUrlQuery CreatePlaylistLoader::query(const CreatePlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/createuserbyname.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
CreateUserByName::CreateUserByName(ApiClient *apiClient)
CreateUserByNameLoader::CreateUserByNameLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::UserDto, CreateUserByNameParams>(apiClient) {}
QString CreateUserByName::path(const CreateUserByNameParams &params) const {
QString CreateUserByNameLoader::path(const CreateUserByNameParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/New");
}
QUrlQuery CreateUserByName::query(const CreateUserByNameParams &params) const {
QUrlQuery CreateUserByNameLoader::query(const CreateUserByNameParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/deleteuseritemrating.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
DeleteUserItemRating::DeleteUserItemRating(ApiClient *apiClient)
DeleteUserItemRatingLoader::DeleteUserItemRatingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::UserItemDataDto, DeleteUserItemRatingParams>(apiClient) {}
QString DeleteUserItemRating::path(const DeleteUserItemRatingParams &params) const {
QString DeleteUserItemRatingLoader::path(const DeleteUserItemRatingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString(params.userId()) + QStringLiteral("/Items/") + Support::toString(params.itemId()) + QStringLiteral("/Rating");
}
QUrlQuery DeleteUserItemRating::query(const DeleteUserItemRatingParams &params) const {
QUrlQuery DeleteUserItemRatingLoader::query(const DeleteUserItemRatingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/forgotpassword.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
ForgotPassword::ForgotPassword(ApiClient *apiClient)
ForgotPasswordLoader::ForgotPasswordLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ForgotPasswordResult, ForgotPasswordParams>(apiClient) {}
QString ForgotPassword::path(const ForgotPasswordParams &params) const {
QString ForgotPasswordLoader::path(const ForgotPasswordParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/ForgotPassword");
}
QUrlQuery ForgotPassword::query(const ForgotPasswordParams &params) const {
QUrlQuery ForgotPasswordLoader::query(const ForgotPasswordParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/forgotpasswordpin.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
ForgotPasswordPin::ForgotPasswordPin(ApiClient *apiClient)
ForgotPasswordPinLoader::ForgotPasswordPinLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::PinRedeemResult, ForgotPasswordPinParams>(apiClient) {}
QString ForgotPasswordPin::path(const ForgotPasswordPinParams &params) const {
QString ForgotPasswordPinLoader::path(const ForgotPasswordPinParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/ForgotPassword/Pin");
}
QUrlQuery ForgotPasswordPin::query(const ForgotPasswordPinParams &params) const {
QUrlQuery ForgotPasswordPinLoader::query(const ForgotPasswordPinParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/get.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
Get::Get(ApiClient *apiClient)
GetLoader::GetLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::SearchHintResult, GetParams>(apiClient) {}
QString Get::path(const GetParams &params) const {
QString GetLoader::path(const GetParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Search/Hints");
}
QUrlQuery Get::query(const GetParams &params) const {
QUrlQuery GetLoader::query(const GetParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getadditionalpart.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetAdditionalPart::GetAdditionalPart(ApiClient *apiClient)
GetAdditionalPartLoader::GetAdditionalPartLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetAdditionalPartParams>(apiClient) {}
QString GetAdditionalPart::path(const GetAdditionalPartParams &params) const {
QString GetAdditionalPartLoader::path(const GetAdditionalPartParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Videos/") + Support::toString(params.itemId()) + QStringLiteral("/AdditionalParts");
}
QUrlQuery GetAdditionalPart::query(const GetAdditionalPartParams &params) const {
QUrlQuery GetAdditionalPartLoader::query(const GetAdditionalPartParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getalbumartists.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetAlbumArtists::GetAlbumArtists(ApiClient *apiClient)
GetAlbumArtistsLoader::GetAlbumArtistsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetAlbumArtistsParams>(apiClient) {}
QString GetAlbumArtists::path(const GetAlbumArtistsParams &params) const {
QString GetAlbumArtistsLoader::path(const GetAlbumArtistsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Artists/AlbumArtists");
}
QUrlQuery GetAlbumArtists::query(const GetAlbumArtistsParams &params) const {
QUrlQuery GetAlbumArtistsLoader::query(const GetAlbumArtistsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getartistbyname.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetArtistByName::GetArtistByName(ApiClient *apiClient)
GetArtistByNameLoader::GetArtistByNameLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetArtistByNameParams>(apiClient) {}
QString GetArtistByName::path(const GetArtistByNameParams &params) const {
QString GetArtistByNameLoader::path(const GetArtistByNameParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Artists/") + Support::toString(params.name()) ;
}
QUrlQuery GetArtistByName::query(const GetArtistByNameParams &params) const {
QUrlQuery GetArtistByNameLoader::query(const GetArtistByNameParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getartists.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetArtists::GetArtists(ApiClient *apiClient)
GetArtistsLoader::GetArtistsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetArtistsParams>(apiClient) {}
QString GetArtists::path(const GetArtistsParams &params) const {
QString GetArtistsLoader::path(const GetArtistsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Artists");
}
QUrlQuery GetArtists::query(const GetArtistsParams &params) const {
QUrlQuery GetArtistsLoader::query(const GetArtistsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getbrandingoptions.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetBrandingOptions::GetBrandingOptions(ApiClient *apiClient)
GetBrandingOptionsLoader::GetBrandingOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BrandingOptions, GetBrandingOptionsParams>(apiClient) {}
QString GetBrandingOptions::path(const GetBrandingOptionsParams &params) const {
QString GetBrandingOptionsLoader::path(const GetBrandingOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Branding/Configuration");
}
QUrlQuery GetBrandingOptions::query(const GetBrandingOptionsParams &params) const {
QUrlQuery GetBrandingOptionsLoader::query(const GetBrandingOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getchannel.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetChannel::GetChannel(ApiClient *apiClient)
GetChannelLoader::GetChannelLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetChannelParams>(apiClient) {}
QString GetChannel::path(const GetChannelParams &params) const {
QString GetChannelLoader::path(const GetChannelParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Channels/") + Support::toString(params.channelId()) ;
}
QUrlQuery GetChannel::query(const GetChannelParams &params) const {
QUrlQuery GetChannelLoader::query(const GetChannelParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getchannelfeatures.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetChannelFeatures::GetChannelFeatures(ApiClient *apiClient)
GetChannelFeaturesLoader::GetChannelFeaturesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ChannelFeatures, GetChannelFeaturesParams>(apiClient) {}
QString GetChannelFeatures::path(const GetChannelFeaturesParams &params) const {
QString GetChannelFeaturesLoader::path(const GetChannelFeaturesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Channels/") + Support::toString(params.channelId()) + QStringLiteral("/Features");
}
QUrlQuery GetChannelFeatures::query(const GetChannelFeaturesParams &params) const {
QUrlQuery GetChannelFeaturesLoader::query(const GetChannelFeaturesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getchannelitems.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetChannelItems::GetChannelItems(ApiClient *apiClient)
GetChannelItemsLoader::GetChannelItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetChannelItemsParams>(apiClient) {}
QString GetChannelItems::path(const GetChannelItemsParams &params) const {
QString GetChannelItemsLoader::path(const GetChannelItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Channels/") + Support::toString(params.channelId()) + QStringLiteral("/Items");
}
QUrlQuery GetChannelItems::query(const GetChannelItemsParams &params) const {
QUrlQuery GetChannelItemsLoader::query(const GetChannelItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getchannelmappingoptions.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetChannelMappingOptions::GetChannelMappingOptions(ApiClient *apiClient)
GetChannelMappingOptionsLoader::GetChannelMappingOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ChannelMappingOptionsDto, GetChannelMappingOptionsParams>(apiClient) {}
QString GetChannelMappingOptions::path(const GetChannelMappingOptionsParams &params) const {
QString GetChannelMappingOptionsLoader::path(const GetChannelMappingOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/ChannelMappingOptions");
}
QUrlQuery GetChannelMappingOptions::query(const GetChannelMappingOptionsParams &params) const {
QUrlQuery GetChannelMappingOptionsLoader::query(const GetChannelMappingOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getchannels.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetChannels::GetChannels(ApiClient *apiClient)
GetChannelsLoader::GetChannelsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetChannelsParams>(apiClient) {}
QString GetChannels::path(const GetChannelsParams &params) const {
QString GetChannelsLoader::path(const GetChannelsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Channels");
}
QUrlQuery GetChannels::query(const GetChannelsParams &params) const {
QUrlQuery GetChannelsLoader::query(const GetChannelsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getconfiguration.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetConfiguration::GetConfiguration(ApiClient *apiClient)
GetConfigurationLoader::GetConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ServerConfiguration, GetConfigurationParams>(apiClient) {}
QString GetConfiguration::path(const GetConfigurationParams &params) const {
QString GetConfigurationLoader::path(const GetConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/Configuration");
}
QUrlQuery GetConfiguration::query(const GetConfigurationParams &params) const {
QUrlQuery GetConfigurationLoader::query(const GetConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getcriticreviews.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetCriticReviews::GetCriticReviews(ApiClient *apiClient)
GetCriticReviewsLoader::GetCriticReviewsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetCriticReviewsParams>(apiClient) {}
QString GetCriticReviews::path(const GetCriticReviewsParams &params) const {
QString GetCriticReviewsLoader::path(const GetCriticReviewsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString(params.itemId()) + QStringLiteral("/CriticReviews");
}
QUrlQuery GetCriticReviews::query(const GetCriticReviewsParams &params) const {
QUrlQuery GetCriticReviewsLoader::query(const GetCriticReviewsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getcurrentuser.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetCurrentUser::GetCurrentUser(ApiClient *apiClient)
GetCurrentUserLoader::GetCurrentUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::UserDto, GetCurrentUserParams>(apiClient) {}
QString GetCurrentUser::path(const GetCurrentUserParams &params) const {
QString GetCurrentUserLoader::path(const GetCurrentUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/Me");
}
QUrlQuery GetCurrentUser::query(const GetCurrentUserParams &params) const {
QUrlQuery GetCurrentUserLoader::query(const GetCurrentUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getdefaultdirectorybrowser.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetDefaultDirectoryBrowser::GetDefaultDirectoryBrowser(ApiClient *apiClient)
GetDefaultDirectoryBrowserLoader::GetDefaultDirectoryBrowserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DefaultDirectoryBrowserInfoDto, GetDefaultDirectoryBrowserParams>(apiClient) {}
QString GetDefaultDirectoryBrowser::path(const GetDefaultDirectoryBrowserParams &params) const {
QString GetDefaultDirectoryBrowserLoader::path(const GetDefaultDirectoryBrowserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Environment/DefaultDirectoryBrowser");
}
QUrlQuery GetDefaultDirectoryBrowser::query(const GetDefaultDirectoryBrowserParams &params) const {
QUrlQuery GetDefaultDirectoryBrowserLoader::query(const GetDefaultDirectoryBrowserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getdefaultlistingprovider.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetDefaultListingProvider::GetDefaultListingProvider(ApiClient *apiClient)
GetDefaultListingProviderLoader::GetDefaultListingProviderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ListingsProviderInfo, GetDefaultListingProviderParams>(apiClient) {}
QString GetDefaultListingProvider::path(const GetDefaultListingProviderParams &params) const {
QString GetDefaultListingProviderLoader::path(const GetDefaultListingProviderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/ListingProviders/Default");
}
QUrlQuery GetDefaultListingProvider::query(const GetDefaultListingProviderParams &params) const {
QUrlQuery GetDefaultListingProviderLoader::query(const GetDefaultListingProviderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getdefaultmetadataoptions.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetDefaultMetadataOptions::GetDefaultMetadataOptions(ApiClient *apiClient)
GetDefaultMetadataOptionsLoader::GetDefaultMetadataOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::MetadataOptions, GetDefaultMetadataOptionsParams>(apiClient) {}
QString GetDefaultMetadataOptions::path(const GetDefaultMetadataOptionsParams &params) const {
QString GetDefaultMetadataOptionsLoader::path(const GetDefaultMetadataOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/Configuration/MetadataOptions/Default");
}
QUrlQuery GetDefaultMetadataOptions::query(const GetDefaultMetadataOptionsParams &params) const {
QUrlQuery GetDefaultMetadataOptionsLoader::query(const GetDefaultMetadataOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getdefaultprofile.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetDefaultProfile::GetDefaultProfile(ApiClient *apiClient)
GetDefaultProfileLoader::GetDefaultProfileLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DeviceProfile, GetDefaultProfileParams>(apiClient) {}
QString GetDefaultProfile::path(const GetDefaultProfileParams &params) const {
QString GetDefaultProfileLoader::path(const GetDefaultProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Dlna/Profiles/Default");
}
QUrlQuery GetDefaultProfile::query(const GetDefaultProfileParams &params) const {
QUrlQuery GetDefaultProfileLoader::query(const GetDefaultProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getdefaulttimer.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetDefaultTimer::GetDefaultTimer(ApiClient *apiClient)
GetDefaultTimerLoader::GetDefaultTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::SeriesTimerInfoDto, GetDefaultTimerParams>(apiClient) {}
QString GetDefaultTimer::path(const GetDefaultTimerParams &params) const {
QString GetDefaultTimerLoader::path(const GetDefaultTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Timers/Defaults");
}
QUrlQuery GetDefaultTimer::query(const GetDefaultTimerParams &params) const {
QUrlQuery GetDefaultTimerLoader::query(const GetDefaultTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getdeviceinfo.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetDeviceInfo::GetDeviceInfo(ApiClient *apiClient)
GetDeviceInfoLoader::GetDeviceInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DeviceInfo, GetDeviceInfoParams>(apiClient) {}
QString GetDeviceInfo::path(const GetDeviceInfoParams &params) const {
QString GetDeviceInfoLoader::path(const GetDeviceInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Devices/Info");
}
QUrlQuery GetDeviceInfo::query(const GetDeviceInfoParams &params) const {
QUrlQuery GetDeviceInfoLoader::query(const GetDeviceInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getdeviceoptions.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetDeviceOptions::GetDeviceOptions(ApiClient *apiClient)
GetDeviceOptionsLoader::GetDeviceOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DeviceOptions, GetDeviceOptionsParams>(apiClient) {}
QString GetDeviceOptions::path(const GetDeviceOptionsParams &params) const {
QString GetDeviceOptionsLoader::path(const GetDeviceOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Devices/Options");
}
QUrlQuery GetDeviceOptions::query(const GetDeviceOptionsParams &params) const {
QUrlQuery GetDeviceOptionsLoader::query(const GetDeviceOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getdevices.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetDevices::GetDevices(ApiClient *apiClient)
GetDevicesLoader::GetDevicesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DeviceInfoQueryResult, GetDevicesParams>(apiClient) {}
QString GetDevices::path(const GetDevicesParams &params) const {
QString GetDevicesLoader::path(const GetDevicesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Devices");
}
QUrlQuery GetDevices::query(const GetDevicesParams &params) const {
QUrlQuery GetDevicesLoader::query(const GetDevicesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getdisplaypreferences.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetDisplayPreferences::GetDisplayPreferences(ApiClient *apiClient)
GetDisplayPreferencesLoader::GetDisplayPreferencesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DisplayPreferencesDto, GetDisplayPreferencesParams>(apiClient) {}
QString GetDisplayPreferences::path(const GetDisplayPreferencesParams &params) const {
QString GetDisplayPreferencesLoader::path(const GetDisplayPreferencesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/DisplayPreferences/") + Support::toString(params.displayPreferencesId()) ;
}
QUrlQuery GetDisplayPreferences::query(const GetDisplayPreferencesParams &params) const {
QUrlQuery GetDisplayPreferencesLoader::query(const GetDisplayPreferencesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getendpointinfo.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetEndpointInfo::GetEndpointInfo(ApiClient *apiClient)
GetEndpointInfoLoader::GetEndpointInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::EndPointInfo, GetEndpointInfoParams>(apiClient) {}
QString GetEndpointInfo::path(const GetEndpointInfoParams &params) const {
QString GetEndpointInfoLoader::path(const GetEndpointInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/Endpoint");
}
QUrlQuery GetEndpointInfo::query(const GetEndpointInfoParams &params) const {
QUrlQuery GetEndpointInfoLoader::query(const GetEndpointInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getepisodes.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetEpisodes::GetEpisodes(ApiClient *apiClient)
GetEpisodesLoader::GetEpisodesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetEpisodesParams>(apiClient) {}
QString GetEpisodes::path(const GetEpisodesParams &params) const {
QString GetEpisodesLoader::path(const GetEpisodesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Shows/") + Support::toString(params.seriesId()) + QStringLiteral("/Episodes");
}
QUrlQuery GetEpisodes::query(const GetEpisodesParams &params) const {
QUrlQuery GetEpisodesLoader::query(const GetEpisodesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getfirstuser.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetFirstUser::GetFirstUser(ApiClient *apiClient)
GetFirstUserLoader::GetFirstUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::StartupUserDto, GetFirstUserParams>(apiClient) {}
QString GetFirstUser::path(const GetFirstUserParams &params) const {
QString GetFirstUserLoader::path(const GetFirstUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Startup/User");
}
QUrlQuery GetFirstUser::query(const GetFirstUserParams &params) const {
QUrlQuery GetFirstUserLoader::query(const GetFirstUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getfirstuser_2.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetFirstUser_2::GetFirstUser_2(ApiClient *apiClient)
GetFirstUser_2Loader::GetFirstUser_2Loader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::StartupUserDto, GetFirstUser_2Params>(apiClient) {}
QString GetFirstUser_2::path(const GetFirstUser_2Params &params) const {
QString GetFirstUser_2Loader::path(const GetFirstUser_2Params &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Startup/FirstUser");
}
QUrlQuery GetFirstUser_2::query(const GetFirstUser_2Params &params) const {
QUrlQuery GetFirstUser_2Loader::query(const GetFirstUser_2Params &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getgenre.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetGenre::GetGenre(ApiClient *apiClient)
GetGenreLoader::GetGenreLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetGenreParams>(apiClient) {}
QString GetGenre::path(const GetGenreParams &params) const {
QString GetGenreLoader::path(const GetGenreParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Genres/") + Support::toString(params.genreName()) ;
}
QUrlQuery GetGenre::query(const GetGenreParams &params) const {
QUrlQuery GetGenreLoader::query(const GetGenreParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getgenres.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetGenres::GetGenres(ApiClient *apiClient)
GetGenresLoader::GetGenresLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetGenresParams>(apiClient) {}
QString GetGenres::path(const GetGenresParams &params) const {
QString GetGenresLoader::path(const GetGenresParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Genres");
}
QUrlQuery GetGenres::query(const GetGenresParams &params) const {
QUrlQuery GetGenresLoader::query(const GetGenresParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getguideinfo.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetGuideInfo::GetGuideInfo(ApiClient *apiClient)
GetGuideInfoLoader::GetGuideInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::GuideInfo, GetGuideInfoParams>(apiClient) {}
QString GetGuideInfo::path(const GetGuideInfoParams &params) const {
QString GetGuideInfoLoader::path(const GetGuideInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/GuideInfo");
}
QUrlQuery GetGuideInfo::query(const GetGuideInfoParams &params) const {
QUrlQuery GetGuideInfoLoader::query(const GetGuideInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getinstantmixfromalbum.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetInstantMixFromAlbum::GetInstantMixFromAlbum(ApiClient *apiClient)
GetInstantMixFromAlbumLoader::GetInstantMixFromAlbumLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromAlbumParams>(apiClient) {}
QString GetInstantMixFromAlbum::path(const GetInstantMixFromAlbumParams &params) const {
QString GetInstantMixFromAlbumLoader::path(const GetInstantMixFromAlbumParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Albums/") + Support::toString(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromAlbum::query(const GetInstantMixFromAlbumParams &params) const {
QUrlQuery GetInstantMixFromAlbumLoader::query(const GetInstantMixFromAlbumParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getinstantmixfromartists.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetInstantMixFromArtists::GetInstantMixFromArtists(ApiClient *apiClient)
GetInstantMixFromArtistsLoader::GetInstantMixFromArtistsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromArtistsParams>(apiClient) {}
QString GetInstantMixFromArtists::path(const GetInstantMixFromArtistsParams &params) const {
QString GetInstantMixFromArtistsLoader::path(const GetInstantMixFromArtistsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Artists/") + Support::toString(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromArtists::query(const GetInstantMixFromArtistsParams &params) const {
QUrlQuery GetInstantMixFromArtistsLoader::query(const GetInstantMixFromArtistsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getinstantmixfromitem.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetInstantMixFromItem::GetInstantMixFromItem(ApiClient *apiClient)
GetInstantMixFromItemLoader::GetInstantMixFromItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromItemParams>(apiClient) {}
QString GetInstantMixFromItem::path(const GetInstantMixFromItemParams &params) const {
QString GetInstantMixFromItemLoader::path(const GetInstantMixFromItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromItem::query(const GetInstantMixFromItemParams &params) const {
QUrlQuery GetInstantMixFromItemLoader::query(const GetInstantMixFromItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getinstantmixfrommusicgenre.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetInstantMixFromMusicGenre::GetInstantMixFromMusicGenre(ApiClient *apiClient)
GetInstantMixFromMusicGenreLoader::GetInstantMixFromMusicGenreLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromMusicGenreParams>(apiClient) {}
QString GetInstantMixFromMusicGenre::path(const GetInstantMixFromMusicGenreParams &params) const {
QString GetInstantMixFromMusicGenreLoader::path(const GetInstantMixFromMusicGenreParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/MusicGenres/") + Support::toString(params.name()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromMusicGenre::query(const GetInstantMixFromMusicGenreParams &params) const {
QUrlQuery GetInstantMixFromMusicGenreLoader::query(const GetInstantMixFromMusicGenreParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getinstantmixfrommusicgenres.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetInstantMixFromMusicGenres::GetInstantMixFromMusicGenres(ApiClient *apiClient)
GetInstantMixFromMusicGenresLoader::GetInstantMixFromMusicGenresLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromMusicGenresParams>(apiClient) {}
QString GetInstantMixFromMusicGenres::path(const GetInstantMixFromMusicGenresParams &params) const {
QString GetInstantMixFromMusicGenresLoader::path(const GetInstantMixFromMusicGenresParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/MusicGenres/") + Support::toString(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromMusicGenres::query(const GetInstantMixFromMusicGenresParams &params) const {
QUrlQuery GetInstantMixFromMusicGenresLoader::query(const GetInstantMixFromMusicGenresParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getinstantmixfromplaylist.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetInstantMixFromPlaylist::GetInstantMixFromPlaylist(ApiClient *apiClient)
GetInstantMixFromPlaylistLoader::GetInstantMixFromPlaylistLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromPlaylistParams>(apiClient) {}
QString GetInstantMixFromPlaylist::path(const GetInstantMixFromPlaylistParams &params) const {
QString GetInstantMixFromPlaylistLoader::path(const GetInstantMixFromPlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Playlists/") + Support::toString(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromPlaylist::query(const GetInstantMixFromPlaylistParams &params) const {
QUrlQuery GetInstantMixFromPlaylistLoader::query(const GetInstantMixFromPlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getinstantmixfromsong.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetInstantMixFromSong::GetInstantMixFromSong(ApiClient *apiClient)
GetInstantMixFromSongLoader::GetInstantMixFromSongLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromSongParams>(apiClient) {}
QString GetInstantMixFromSong::path(const GetInstantMixFromSongParams &params) const {
QString GetInstantMixFromSongLoader::path(const GetInstantMixFromSongParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Songs/") + Support::toString(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromSong::query(const GetInstantMixFromSongParams &params) const {
QUrlQuery GetInstantMixFromSongLoader::query(const GetInstantMixFromSongParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getintros.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetIntros::GetIntros(ApiClient *apiClient)
GetIntrosLoader::GetIntrosLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetIntrosParams>(apiClient) {}
QString GetIntros::path(const GetIntrosParams &params) const {
QString GetIntrosLoader::path(const GetIntrosParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString(params.userId()) + QStringLiteral("/Items/") + Support::toString(params.itemId()) + QStringLiteral("/Intros");
}
QUrlQuery GetIntros::query(const GetIntrosParams &params) const {
QUrlQuery GetIntrosLoader::query(const GetIntrosParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getitem.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetItem::GetItem(ApiClient *apiClient)
GetItemLoader::GetItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetItemParams>(apiClient) {}
QString GetItem::path(const GetItemParams &params) const {
QString GetItemLoader::path(const GetItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString(params.userId()) + QStringLiteral("/Items/") + Support::toString(params.itemId()) ;
}
QUrlQuery GetItem::query(const GetItemParams &params) const {
QUrlQuery GetItemLoader::query(const GetItemParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getitemcounts.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetItemCounts::GetItemCounts(ApiClient *apiClient)
GetItemCountsLoader::GetItemCountsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ItemCounts, GetItemCountsParams>(apiClient) {}
QString GetItemCounts::path(const GetItemCountsParams &params) const {
QString GetItemCountsLoader::path(const GetItemCountsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/Counts");
}
QUrlQuery GetItemCounts::query(const GetItemCountsParams &params) const {
QUrlQuery GetItemCountsLoader::query(const GetItemCountsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getitems.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetItems::GetItems(ApiClient *apiClient)
GetItemsLoader::GetItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetItemsParams>(apiClient) {}
QString GetItems::path(const GetItemsParams &params) const {
QString GetItemsLoader::path(const GetItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items");
}
QUrlQuery GetItems::query(const GetItemsParams &params) const {
QUrlQuery GetItemsLoader::query(const GetItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getitemsbyuserid.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetItemsByUserId::GetItemsByUserId(ApiClient *apiClient)
GetItemsByUserIdLoader::GetItemsByUserIdLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetItemsByUserIdParams>(apiClient) {}
QString GetItemsByUserId::path(const GetItemsByUserIdParams &params) const {
QString GetItemsByUserIdLoader::path(const GetItemsByUserIdParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString(params.userId()) + QStringLiteral("/Items");
}
QUrlQuery GetItemsByUserId::query(const GetItemsByUserIdParams &params) const {
QUrlQuery GetItemsByUserIdLoader::query(const GetItemsByUserIdParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getkeys.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetKeys::GetKeys(ApiClient *apiClient)
GetKeysLoader::GetKeysLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::AuthenticationInfoQueryResult, GetKeysParams>(apiClient) {}
QString GetKeys::path(const GetKeysParams &params) const {
QString GetKeysLoader::path(const GetKeysParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Auth/Keys");
}
QUrlQuery GetKeys::query(const GetKeysParams &params) const {
QUrlQuery GetKeysLoader::query(const GetKeysParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getlatestchannelitems.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetLatestChannelItems::GetLatestChannelItems(ApiClient *apiClient)
GetLatestChannelItemsLoader::GetLatestChannelItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetLatestChannelItemsParams>(apiClient) {}
QString GetLatestChannelItems::path(const GetLatestChannelItemsParams &params) const {
QString GetLatestChannelItemsLoader::path(const GetLatestChannelItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Channels/Items/Latest");
}
QUrlQuery GetLatestChannelItems::query(const GetLatestChannelItemsParams &params) const {
QUrlQuery GetLatestChannelItemsLoader::query(const GetLatestChannelItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getlibraryoptionsinfo.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetLibraryOptionsInfo::GetLibraryOptionsInfo(ApiClient *apiClient)
GetLibraryOptionsInfoLoader::GetLibraryOptionsInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::LibraryOptionsResultDto, GetLibraryOptionsInfoParams>(apiClient) {}
QString GetLibraryOptionsInfo::path(const GetLibraryOptionsInfoParams &params) const {
QString GetLibraryOptionsInfoLoader::path(const GetLibraryOptionsInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Libraries/AvailableOptions");
}
QUrlQuery GetLibraryOptionsInfo::query(const GetLibraryOptionsInfoParams &params) const {
QUrlQuery GetLibraryOptionsInfoLoader::query(const GetLibraryOptionsInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getlivetvchannels.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetLiveTvChannels::GetLiveTvChannels(ApiClient *apiClient)
GetLiveTvChannelsLoader::GetLiveTvChannelsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetLiveTvChannelsParams>(apiClient) {}
QString GetLiveTvChannels::path(const GetLiveTvChannelsParams &params) const {
QString GetLiveTvChannelsLoader::path(const GetLiveTvChannelsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Channels");
}
QUrlQuery GetLiveTvChannels::query(const GetLiveTvChannelsParams &params) const {
QUrlQuery GetLiveTvChannelsLoader::query(const GetLiveTvChannelsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getlivetvinfo.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetLiveTvInfo::GetLiveTvInfo(ApiClient *apiClient)
GetLiveTvInfoLoader::GetLiveTvInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::LiveTvInfo, GetLiveTvInfoParams>(apiClient) {}
QString GetLiveTvInfo::path(const GetLiveTvInfoParams &params) const {
QString GetLiveTvInfoLoader::path(const GetLiveTvInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Info");
}
QUrlQuery GetLiveTvInfo::query(const GetLiveTvInfoParams &params) const {
QUrlQuery GetLiveTvInfoLoader::query(const GetLiveTvInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getlivetvprograms.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetLiveTvPrograms::GetLiveTvPrograms(ApiClient *apiClient)
GetLiveTvProgramsLoader::GetLiveTvProgramsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetLiveTvProgramsParams>(apiClient) {}
QString GetLiveTvPrograms::path(const GetLiveTvProgramsParams &params) const {
QString GetLiveTvProgramsLoader::path(const GetLiveTvProgramsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Programs");
}
QUrlQuery GetLiveTvPrograms::query(const GetLiveTvProgramsParams &params) const {
QUrlQuery GetLiveTvProgramsLoader::query(const GetLiveTvProgramsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getlogentries.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetLogEntries::GetLogEntries(ApiClient *apiClient)
GetLogEntriesLoader::GetLogEntriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ActivityLogEntryQueryResult, GetLogEntriesParams>(apiClient) {}
QString GetLogEntries::path(const GetLogEntriesParams &params) const {
QString GetLogEntriesLoader::path(const GetLogEntriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/ActivityLog/Entries");
}
QUrlQuery GetLogEntries::query(const GetLogEntriesParams &params) const {
QUrlQuery GetLogEntriesLoader::query(const GetLogEntriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getmediafolders.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetMediaFolders::GetMediaFolders(ApiClient *apiClient)
GetMediaFoldersLoader::GetMediaFoldersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetMediaFoldersParams>(apiClient) {}
QString GetMediaFolders::path(const GetMediaFoldersParams &params) const {
QString GetMediaFoldersLoader::path(const GetMediaFoldersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Library/MediaFolders");
}
QUrlQuery GetMediaFolders::query(const GetMediaFoldersParams &params) const {
QUrlQuery GetMediaFoldersLoader::query(const GetMediaFoldersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getmetadataeditorinfo.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetMetadataEditorInfo::GetMetadataEditorInfo(ApiClient *apiClient)
GetMetadataEditorInfoLoader::GetMetadataEditorInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::MetadataEditorInfo, GetMetadataEditorInfoParams>(apiClient) {}
QString GetMetadataEditorInfo::path(const GetMetadataEditorInfoParams &params) const {
QString GetMetadataEditorInfoLoader::path(const GetMetadataEditorInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString(params.itemId()) + QStringLiteral("/MetadataEditor");
}
QUrlQuery GetMetadataEditorInfo::query(const GetMetadataEditorInfoParams &params) const {
QUrlQuery GetMetadataEditorInfoLoader::query(const GetMetadataEditorInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getmusicgenre.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetMusicGenre::GetMusicGenre(ApiClient *apiClient)
GetMusicGenreLoader::GetMusicGenreLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetMusicGenreParams>(apiClient) {}
QString GetMusicGenre::path(const GetMusicGenreParams &params) const {
QString GetMusicGenreLoader::path(const GetMusicGenreParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/MusicGenres/") + Support::toString(params.genreName()) ;
}
QUrlQuery GetMusicGenre::query(const GetMusicGenreParams &params) const {
QUrlQuery GetMusicGenreLoader::query(const GetMusicGenreParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getmusicgenres.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetMusicGenres::GetMusicGenres(ApiClient *apiClient)
GetMusicGenresLoader::GetMusicGenresLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetMusicGenresParams>(apiClient) {}
QString GetMusicGenres::path(const GetMusicGenresParams &params) const {
QString GetMusicGenresLoader::path(const GetMusicGenresParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/MusicGenres");
}
QUrlQuery GetMusicGenres::query(const GetMusicGenresParams &params) const {
QUrlQuery GetMusicGenresLoader::query(const GetMusicGenresParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getnextup.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetNextUp::GetNextUp(ApiClient *apiClient)
GetNextUpLoader::GetNextUpLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetNextUpParams>(apiClient) {}
QString GetNextUp::path(const GetNextUpParams &params) const {
QString GetNextUpLoader::path(const GetNextUpParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Shows/NextUp");
}
QUrlQuery GetNextUp::query(const GetNextUpParams &params) const {
QUrlQuery GetNextUpLoader::query(const GetNextUpParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getnotifications.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetNotifications::GetNotifications(ApiClient *apiClient)
GetNotificationsLoader::GetNotificationsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::NotificationResultDto, GetNotificationsParams>(apiClient) {}
QString GetNotifications::path(const GetNotificationsParams &params) const {
QString GetNotificationsLoader::path(const GetNotificationsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Notifications/") + Support::toString(params.userId()) ;
}
QUrlQuery GetNotifications::query(const GetNotificationsParams &params) const {
QUrlQuery GetNotificationsLoader::query(const GetNotificationsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getnotificationssummary.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetNotificationsSummary::GetNotificationsSummary(ApiClient *apiClient)
GetNotificationsSummaryLoader::GetNotificationsSummaryLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::NotificationsSummaryDto, GetNotificationsSummaryParams>(apiClient) {}
QString GetNotificationsSummary::path(const GetNotificationsSummaryParams &params) const {
QString GetNotificationsSummaryLoader::path(const GetNotificationsSummaryParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Notifications/") + Support::toString(params.userId()) + QStringLiteral("/Summary");
}
QUrlQuery GetNotificationsSummary::query(const GetNotificationsSummaryParams &params) const {
QUrlQuery GetNotificationsSummaryLoader::query(const GetNotificationsSummaryParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getpackageinfo.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetPackageInfo::GetPackageInfo(ApiClient *apiClient)
GetPackageInfoLoader::GetPackageInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::PackageInfo, GetPackageInfoParams>(apiClient) {}
QString GetPackageInfo::path(const GetPackageInfoParams &params) const {
QString GetPackageInfoLoader::path(const GetPackageInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Packages/") + Support::toString(params.name()) ;
}
QUrlQuery GetPackageInfo::query(const GetPackageInfoParams &params) const {
QUrlQuery GetPackageInfoLoader::query(const GetPackageInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getperson.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetPerson::GetPerson(ApiClient *apiClient)
GetPersonLoader::GetPersonLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetPersonParams>(apiClient) {}
QString GetPerson::path(const GetPersonParams &params) const {
QString GetPersonLoader::path(const GetPersonParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Persons/") + Support::toString(params.name()) ;
}
QUrlQuery GetPerson::query(const GetPersonParams &params) const {
QUrlQuery GetPersonLoader::query(const GetPersonParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getpersons.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetPersons::GetPersons(ApiClient *apiClient)
GetPersonsLoader::GetPersonsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetPersonsParams>(apiClient) {}
QString GetPersons::path(const GetPersonsParams &params) const {
QString GetPersonsLoader::path(const GetPersonsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Persons");
}
QUrlQuery GetPersons::query(const GetPersonsParams &params) const {
QUrlQuery GetPersonsLoader::query(const GetPersonsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getplaybackinfo.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetPlaybackInfo::GetPlaybackInfo(ApiClient *apiClient)
GetPlaybackInfoLoader::GetPlaybackInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::PlaybackInfoResponse, GetPlaybackInfoParams>(apiClient) {}
QString GetPlaybackInfo::path(const GetPlaybackInfoParams &params) const {
QString GetPlaybackInfoLoader::path(const GetPlaybackInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString(params.itemId()) + QStringLiteral("/PlaybackInfo");
}
QUrlQuery GetPlaybackInfo::query(const GetPlaybackInfoParams &params) const {
QUrlQuery GetPlaybackInfoLoader::query(const GetPlaybackInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getplaylistitems.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetPlaylistItems::GetPlaylistItems(ApiClient *apiClient)
GetPlaylistItemsLoader::GetPlaylistItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetPlaylistItemsParams>(apiClient) {}
QString GetPlaylistItems::path(const GetPlaylistItemsParams &params) const {
QString GetPlaylistItemsLoader::path(const GetPlaylistItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Playlists/") + Support::toString(params.playlistId()) + QStringLiteral("/Items");
}
QUrlQuery GetPlaylistItems::query(const GetPlaylistItemsParams &params) const {
QUrlQuery GetPlaylistItemsLoader::query(const GetPlaylistItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getpluginconfiguration.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetPluginConfiguration::GetPluginConfiguration(ApiClient *apiClient)
GetPluginConfigurationLoader::GetPluginConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BasePluginConfiguration, GetPluginConfigurationParams>(apiClient) {}
QString GetPluginConfiguration::path(const GetPluginConfigurationParams &params) const {
QString GetPluginConfigurationLoader::path(const GetPluginConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Plugins/") + Support::toString(params.pluginId()) + QStringLiteral("/Configuration");
}
QUrlQuery GetPluginConfiguration::query(const GetPluginConfigurationParams &params) const {
QUrlQuery GetPluginConfigurationLoader::query(const GetPluginConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getpostedplaybackinfo.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetPostedPlaybackInfo::GetPostedPlaybackInfo(ApiClient *apiClient)
GetPostedPlaybackInfoLoader::GetPostedPlaybackInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::PlaybackInfoResponse, GetPostedPlaybackInfoParams>(apiClient) {}
QString GetPostedPlaybackInfo::path(const GetPostedPlaybackInfoParams &params) const {
QString GetPostedPlaybackInfoLoader::path(const GetPostedPlaybackInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString(params.itemId()) + QStringLiteral("/PlaybackInfo");
}
QUrlQuery GetPostedPlaybackInfo::query(const GetPostedPlaybackInfoParams &params) const {
QUrlQuery GetPostedPlaybackInfoLoader::query(const GetPostedPlaybackInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getprofile.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetProfile::GetProfile(ApiClient *apiClient)
GetProfileLoader::GetProfileLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DeviceProfile, GetProfileParams>(apiClient) {}
QString GetProfile::path(const GetProfileParams &params) const {
QString GetProfileLoader::path(const GetProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Dlna/Profiles/") + Support::toString(params.profileId()) ;
}
QUrlQuery GetProfile::query(const GetProfileParams &params) const {
QUrlQuery GetProfileLoader::query(const GetProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getprogram.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetProgram::GetProgram(ApiClient *apiClient)
GetProgramLoader::GetProgramLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetProgramParams>(apiClient) {}
QString GetProgram::path(const GetProgramParams &params) const {
QString GetProgramLoader::path(const GetProgramParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Programs/") + Support::toString(params.programId()) ;
}
QUrlQuery GetProgram::query(const GetProgramParams &params) const {
QUrlQuery GetProgramLoader::query(const GetProgramParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getprograms.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetPrograms::GetPrograms(ApiClient *apiClient)
GetProgramsLoader::GetProgramsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetProgramsParams>(apiClient) {}
QString GetPrograms::path(const GetProgramsParams &params) const {
QString GetProgramsLoader::path(const GetProgramsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Programs");
}
QUrlQuery GetPrograms::query(const GetProgramsParams &params) const {
QUrlQuery GetProgramsLoader::query(const GetProgramsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getpublicsysteminfo.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetPublicSystemInfo::GetPublicSystemInfo(ApiClient *apiClient)
GetPublicSystemInfoLoader::GetPublicSystemInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::PublicSystemInfo, GetPublicSystemInfoParams>(apiClient) {}
QString GetPublicSystemInfo::path(const GetPublicSystemInfoParams &params) const {
QString GetPublicSystemInfoLoader::path(const GetPublicSystemInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/Info/Public");
}
QUrlQuery GetPublicSystemInfo::query(const GetPublicSystemInfoParams &params) const {
QUrlQuery GetPublicSystemInfoLoader::query(const GetPublicSystemInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getqueryfilters.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetQueryFilters::GetQueryFilters(ApiClient *apiClient)
GetQueryFiltersLoader::GetQueryFiltersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::QueryFilters, GetQueryFiltersParams>(apiClient) {}
QString GetQueryFilters::path(const GetQueryFiltersParams &params) const {
QString GetQueryFiltersLoader::path(const GetQueryFiltersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/Filters2");
}
QUrlQuery GetQueryFilters::query(const GetQueryFiltersParams &params) const {
QUrlQuery GetQueryFiltersLoader::query(const GetQueryFiltersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getqueryfilterslegacy.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetQueryFiltersLegacy::GetQueryFiltersLegacy(ApiClient *apiClient)
GetQueryFiltersLegacyLoader::GetQueryFiltersLegacyLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::QueryFiltersLegacy, GetQueryFiltersLegacyParams>(apiClient) {}
QString GetQueryFiltersLegacy::path(const GetQueryFiltersLegacyParams &params) const {
QString GetQueryFiltersLegacyLoader::path(const GetQueryFiltersLegacyParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/Filters");
}
QUrlQuery GetQueryFiltersLegacy::query(const GetQueryFiltersLegacyParams &params) const {
QUrlQuery GetQueryFiltersLegacyLoader::query(const GetQueryFiltersLegacyParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getrecommendedprograms.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetRecommendedPrograms::GetRecommendedPrograms(ApiClient *apiClient)
GetRecommendedProgramsLoader::GetRecommendedProgramsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetRecommendedProgramsParams>(apiClient) {}
QString GetRecommendedPrograms::path(const GetRecommendedProgramsParams &params) const {
QString GetRecommendedProgramsLoader::path(const GetRecommendedProgramsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Programs/Recommended");
}
QUrlQuery GetRecommendedPrograms::query(const GetRecommendedProgramsParams &params) const {
QUrlQuery GetRecommendedProgramsLoader::query(const GetRecommendedProgramsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getrecording.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetRecording::GetRecording(ApiClient *apiClient)
GetRecordingLoader::GetRecordingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetRecordingParams>(apiClient) {}
QString GetRecording::path(const GetRecordingParams &params) const {
QString GetRecordingLoader::path(const GetRecordingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Recordings/") + Support::toString(params.recordingId()) ;
}
QUrlQuery GetRecording::query(const GetRecordingParams &params) const {
QUrlQuery GetRecordingLoader::query(const GetRecordingParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getrecordingfolders.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetRecordingFolders::GetRecordingFolders(ApiClient *apiClient)
GetRecordingFoldersLoader::GetRecordingFoldersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetRecordingFoldersParams>(apiClient) {}
QString GetRecordingFolders::path(const GetRecordingFoldersParams &params) const {
QString GetRecordingFoldersLoader::path(const GetRecordingFoldersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Recordings/Folders");
}
QUrlQuery GetRecordingFolders::query(const GetRecordingFoldersParams &params) const {
QUrlQuery GetRecordingFoldersLoader::query(const GetRecordingFoldersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getrecordinggroups.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetRecordingGroups::GetRecordingGroups(ApiClient *apiClient)
GetRecordingGroupsLoader::GetRecordingGroupsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetRecordingGroupsParams>(apiClient) {}
QString GetRecordingGroups::path(const GetRecordingGroupsParams &params) const {
QString GetRecordingGroupsLoader::path(const GetRecordingGroupsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Recordings/Groups");
}
QUrlQuery GetRecordingGroups::query(const GetRecordingGroupsParams &params) const {
QUrlQuery GetRecordingGroupsLoader::query(const GetRecordingGroupsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getrecordings.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetRecordings::GetRecordings(ApiClient *apiClient)
GetRecordingsLoader::GetRecordingsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetRecordingsParams>(apiClient) {}
QString GetRecordings::path(const GetRecordingsParams &params) const {
QString GetRecordingsLoader::path(const GetRecordingsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Recordings");
}
QUrlQuery GetRecordings::query(const GetRecordingsParams &params) const {
QUrlQuery GetRecordingsLoader::query(const GetRecordingsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getrecordingsseries.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetRecordingsSeries::GetRecordingsSeries(ApiClient *apiClient)
GetRecordingsSeriesLoader::GetRecordingsSeriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetRecordingsSeriesParams>(apiClient) {}
QString GetRecordingsSeries::path(const GetRecordingsSeriesParams &params) const {
QString GetRecordingsSeriesLoader::path(const GetRecordingsSeriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Recordings/Series");
}
QUrlQuery GetRecordingsSeries::query(const GetRecordingsSeriesParams &params) const {
QUrlQuery GetRecordingsSeriesLoader::query(const GetRecordingsSeriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getremoteimages.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetRemoteImages::GetRemoteImages(ApiClient *apiClient)
GetRemoteImagesLoader::GetRemoteImagesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::RemoteImageResult, GetRemoteImagesParams>(apiClient) {}
QString GetRemoteImages::path(const GetRemoteImagesParams &params) const {
QString GetRemoteImagesLoader::path(const GetRemoteImagesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString(params.itemId()) + QStringLiteral("/RemoteImages");
}
QUrlQuery GetRemoteImages::query(const GetRemoteImagesParams &params) const {
QUrlQuery GetRemoteImagesLoader::query(const GetRemoteImagesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getresumeitems.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetResumeItems::GetResumeItems(ApiClient *apiClient)
GetResumeItemsLoader::GetResumeItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetResumeItemsParams>(apiClient) {}
QString GetResumeItems::path(const GetResumeItemsParams &params) const {
QString GetResumeItemsLoader::path(const GetResumeItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString(params.userId()) + QStringLiteral("/Items/Resume");
}
QUrlQuery GetResumeItems::query(const GetResumeItemsParams &params) const {
QUrlQuery GetResumeItemsLoader::query(const GetResumeItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getrootfolder.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetRootFolder::GetRootFolder(ApiClient *apiClient)
GetRootFolderLoader::GetRootFolderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetRootFolderParams>(apiClient) {}
QString GetRootFolder::path(const GetRootFolderParams &params) const {
QString GetRootFolderLoader::path(const GetRootFolderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString(params.userId()) + QStringLiteral("/Items/Root");
}
QUrlQuery GetRootFolder::query(const GetRootFolderParams &params) const {
QUrlQuery GetRootFolderLoader::query(const GetRootFolderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getseasons.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetSeasons::GetSeasons(ApiClient *apiClient)
GetSeasonsLoader::GetSeasonsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetSeasonsParams>(apiClient) {}
QString GetSeasons::path(const GetSeasonsParams &params) const {
QString GetSeasonsLoader::path(const GetSeasonsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Shows/") + Support::toString(params.seriesId()) + QStringLiteral("/Seasons");
}
QUrlQuery GetSeasons::query(const GetSeasonsParams &params) const {
QUrlQuery GetSeasonsLoader::query(const GetSeasonsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getseriestimer.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetSeriesTimer::GetSeriesTimer(ApiClient *apiClient)
GetSeriesTimerLoader::GetSeriesTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::SeriesTimerInfoDto, GetSeriesTimerParams>(apiClient) {}
QString GetSeriesTimer::path(const GetSeriesTimerParams &params) const {
QString GetSeriesTimerLoader::path(const GetSeriesTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/SeriesTimers/") + Support::toString(params.timerId()) ;
}
QUrlQuery GetSeriesTimer::query(const GetSeriesTimerParams &params) const {
QUrlQuery GetSeriesTimerLoader::query(const GetSeriesTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getseriestimers.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetSeriesTimers::GetSeriesTimers(ApiClient *apiClient)
GetSeriesTimersLoader::GetSeriesTimersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::SeriesTimerInfoDtoQueryResult, GetSeriesTimersParams>(apiClient) {}
QString GetSeriesTimers::path(const GetSeriesTimersParams &params) const {
QString GetSeriesTimersLoader::path(const GetSeriesTimersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/SeriesTimers");
}
QUrlQuery GetSeriesTimers::query(const GetSeriesTimersParams &params) const {
QUrlQuery GetSeriesTimersLoader::query(const GetSeriesTimersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getsimilaralbums.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetSimilarAlbums::GetSimilarAlbums(ApiClient *apiClient)
GetSimilarAlbumsLoader::GetSimilarAlbumsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetSimilarAlbumsParams>(apiClient) {}
QString GetSimilarAlbums::path(const GetSimilarAlbumsParams &params) const {
QString GetSimilarAlbumsLoader::path(const GetSimilarAlbumsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Albums/") + Support::toString(params.itemId()) + QStringLiteral("/Similar");
}
QUrlQuery GetSimilarAlbums::query(const GetSimilarAlbumsParams &params) const {
QUrlQuery GetSimilarAlbumsLoader::query(const GetSimilarAlbumsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getsimilarartists.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetSimilarArtists::GetSimilarArtists(ApiClient *apiClient)
GetSimilarArtistsLoader::GetSimilarArtistsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetSimilarArtistsParams>(apiClient) {}
QString GetSimilarArtists::path(const GetSimilarArtistsParams &params) const {
QString GetSimilarArtistsLoader::path(const GetSimilarArtistsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Artists/") + Support::toString(params.itemId()) + QStringLiteral("/Similar");
}
QUrlQuery GetSimilarArtists::query(const GetSimilarArtistsParams &params) const {
QUrlQuery GetSimilarArtistsLoader::query(const GetSimilarArtistsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getsimilaritems.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetSimilarItems::GetSimilarItems(ApiClient *apiClient)
GetSimilarItemsLoader::GetSimilarItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetSimilarItemsParams>(apiClient) {}
QString GetSimilarItems::path(const GetSimilarItemsParams &params) const {
QString GetSimilarItemsLoader::path(const GetSimilarItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString(params.itemId()) + QStringLiteral("/Similar");
}
QUrlQuery GetSimilarItems::query(const GetSimilarItemsParams &params) const {
QUrlQuery GetSimilarItemsLoader::query(const GetSimilarItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getsimilarmovies.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetSimilarMovies::GetSimilarMovies(ApiClient *apiClient)
GetSimilarMoviesLoader::GetSimilarMoviesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetSimilarMoviesParams>(apiClient) {}
QString GetSimilarMovies::path(const GetSimilarMoviesParams &params) const {
QString GetSimilarMoviesLoader::path(const GetSimilarMoviesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Movies/") + Support::toString(params.itemId()) + QStringLiteral("/Similar");
}
QUrlQuery GetSimilarMovies::query(const GetSimilarMoviesParams &params) const {
QUrlQuery GetSimilarMoviesLoader::query(const GetSimilarMoviesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getsimilarshows.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetSimilarShows::GetSimilarShows(ApiClient *apiClient)
GetSimilarShowsLoader::GetSimilarShowsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetSimilarShowsParams>(apiClient) {}
QString GetSimilarShows::path(const GetSimilarShowsParams &params) const {
QString GetSimilarShowsLoader::path(const GetSimilarShowsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Shows/") + Support::toString(params.itemId()) + QStringLiteral("/Similar");
}
QUrlQuery GetSimilarShows::query(const GetSimilarShowsParams &params) const {
QUrlQuery GetSimilarShowsLoader::query(const GetSimilarShowsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getsimilartrailers.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetSimilarTrailers::GetSimilarTrailers(ApiClient *apiClient)
GetSimilarTrailersLoader::GetSimilarTrailersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetSimilarTrailersParams>(apiClient) {}
QString GetSimilarTrailers::path(const GetSimilarTrailersParams &params) const {
QString GetSimilarTrailersLoader::path(const GetSimilarTrailersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Trailers/") + Support::toString(params.itemId()) + QStringLiteral("/Similar");
}
QUrlQuery GetSimilarTrailers::query(const GetSimilarTrailersParams &params) const {
QUrlQuery GetSimilarTrailersLoader::query(const GetSimilarTrailersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

6
core/src/loader/http/getstartupconfiguration.cpp
View file

@ -34,16 +34,16 @@ namespace Loader {
namespace HTTP {
GetStartupConfiguration::GetStartupConfiguration(ApiClient *apiClient)
GetStartupConfigurationLoader::GetStartupConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::StartupConfigurationDto, GetStartupConfigurationParams>(apiClient) {}
QString GetStartupConfiguration::path(const GetStartupConfigurationParams &params) const {
QString GetStartupConfigurationLoader::path(const GetStartupConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Startup/Configuration");
}
QUrlQuery GetStartupConfiguration::query(const GetStartupConfigurationParams &params) const {
QUrlQuery GetStartupConfigurationLoader::query(const GetStartupConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;

Some files were not shown because too many files have changed in this diff Show more