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: HttpLoader seems to work, Model still borked

Browse source
This commit is contained in:
Chris Josten 2021-03-28 04:00:00 +02:00
parent e421adf733
commit 729e343661
1412 changed files with 13967 additions and 33794 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
AddListingProviderLoader::AddListingProviderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ListingsProviderInfo, AddListingProviderParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<ListingsProviderInfo, AddListingProviderParams>(apiClient) {}
QString AddListingProviderLoader::path(const AddListingProviderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,13 +51,13 @@ QUrlQuery AddListingProviderLoader::query(const AddListingProviderParams &params
// Optional parameters
if (!params.pwNull()) {
result.addQueryItem("pw", Support::toString(params.pw()));
result.addQueryItem("pw", Support::toString<QString>(params.pw()));
}
if (!params.validateListingsNull()) {
result.addQueryItem("validateListings", Support::toString(params.validateListings()));
result.addQueryItem("validateListings", Support::toString<std::optional<bool>>(params.validateListings()));
}
if (!params.validateLoginNull()) {
result.addQueryItem("validateLogin", Support::toString(params.validateLogin()));
result.addQueryItem("validateLogin", Support::toString<std::optional<bool>>(params.validateLogin()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
AddTunerHostLoader::AddTunerHostLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::TunerHostInfo, AddTunerHostParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<TunerHostInfo, AddTunerHostParams>(apiClient) {}
QString AddTunerHostLoader::path(const AddTunerHostParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,24 +34,25 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
AuthenticateUserLoader::AuthenticateUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::AuthenticationResult, AuthenticateUserParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<AuthenticationResult, AuthenticateUserParams>(apiClient) {}
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");
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Authenticate");
}
QUrlQuery AuthenticateUserLoader::query(const AuthenticateUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("pw", params.pw());
result.addQueryItem("pw", Support::toString<QString>(params.pw()));
// Optional parameters
if (!params.passwordNull()) {
result.addQueryItem("password", Support::toString(params.password()));
result.addQueryItem("password", Support::toString<QString>(params.password()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
AuthenticateUserByNameLoader::AuthenticateUserByNameLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::AuthenticationResult, AuthenticateUserByNameParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<AuthenticationResult, AuthenticateUserByNameParams>(apiClient) {}
QString AuthenticateUserByNameLoader::path(const AuthenticateUserByNameParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
AuthenticateWithQuickConnectLoader::AuthenticateWithQuickConnectLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::AuthenticationResult, AuthenticateWithQuickConnectParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<AuthenticationResult, AuthenticateWithQuickConnectParams>(apiClient) {}
QString AuthenticateWithQuickConnectLoader::path(const AuthenticateWithQuickConnectParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

21
core/src/loader/http/authorize.cpp
View file

@ -34,6 +34,27 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
AuthorizeLoader::AuthorizeLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<bool, AuthorizeParams>(apiClient) {}
QString AuthorizeLoader::path(const AuthorizeParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/QuickConnect/Authorize");
}
QUrlQuery AuthorizeLoader::query(const AuthorizeParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("code", Support::toString<QString>(params.code()));
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
ConnectLoader::ConnectLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::QuickConnectResult, ConnectParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<QuickConnectResult, ConnectParams>(apiClient) {}
QString ConnectLoader::path(const ConnectParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -47,7 +48,7 @@ QUrlQuery ConnectLoader::query(const ConnectParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("secret", params.secret());
result.addQueryItem("secret", Support::toString<QString>(params.secret()));
// Optional parameters

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
CreateCollectionLoader::CreateCollectionLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::CollectionCreationResult, CreateCollectionParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<CollectionCreationResult, CreateCollectionParams>(apiClient) {}
QString CreateCollectionLoader::path(const CreateCollectionParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,16 +51,16 @@ QUrlQuery CreateCollectionLoader::query(const CreateCollectionParams &params) co
// Optional parameters
if (!params.nameNull()) {
result.addQueryItem("name", Support::toString(params.name()));
result.addQueryItem("name", Support::toString<QString>(params.name()));
}
if (!params.idsNull()) {
result.addQueryItem("ids", Support::toString(params.ids()));
result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
}
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString(params.parentId()));
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.isLockedNull()) {
result.addQueryItem("isLocked", Support::toString(params.isLocked()));
result.addQueryItem("isLocked", Support::toString<std::optional<bool>>(params.isLocked()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
CreatePlaylistLoader::CreatePlaylistLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::PlaylistCreationResult, CreatePlaylistParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<PlaylistCreationResult, CreatePlaylistParams>(apiClient) {}
QString CreatePlaylistLoader::path(const CreatePlaylistParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,16 +51,16 @@ QUrlQuery CreatePlaylistLoader::query(const CreatePlaylistParams &params) const
// Optional parameters
if (!params.nameNull()) {
result.addQueryItem("name", Support::toString(params.name()));
result.addQueryItem("name", Support::toString<QString>(params.name()));
}
if (!params.idsNull()) {
result.addQueryItem("ids", Support::toString(params.ids()));
result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.mediaTypeNull()) {
result.addQueryItem("mediaType", Support::toString(params.mediaType()));
result.addQueryItem("mediaType", Support::toString<QString>(params.mediaType()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
CreateUserByNameLoader::CreateUserByNameLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::UserDto, CreateUserByNameParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<UserDto, CreateUserByNameParams>(apiClient) {}
QString CreateUserByNameLoader::path(const CreateUserByNameParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
DeauthorizeLoader::DeauthorizeLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<qint32, DeauthorizeParams>(apiClient) {}
QString DeauthorizeLoader::path(const DeauthorizeParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/QuickConnect/Deauthorize");
}
QUrlQuery DeauthorizeLoader::query(const DeauthorizeParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
DeleteUserItemRatingLoader::DeleteUserItemRatingLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::UserItemDataDto, DeleteUserItemRatingParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<UserItemDataDto, DeleteUserItemRatingParams>(apiClient) {}
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");
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Rating");
}
QUrlQuery DeleteUserItemRatingLoader::query(const DeleteUserItemRatingParams &params) const {

23
core/src/loader/http/discovertuners.cpp
View file

@ -34,6 +34,29 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
DiscoverTunersLoader::DiscoverTunersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<TunerHostInfo>, DiscoverTunersParams>(apiClient) {}
QString DiscoverTunersLoader::path(const DiscoverTunersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Tuners/Discover");
}
QUrlQuery DiscoverTunersLoader::query(const DiscoverTunersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.newDevicesOnlyNull()) {
result.addQueryItem("newDevicesOnly", Support::toString<std::optional<bool>>(params.newDevicesOnly()));
}
return result;
}
} // NS HTTP
} // NS Loader

23
core/src/loader/http/discvovertuners.cpp
View file

@ -34,6 +34,29 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
DiscvoverTunersLoader::DiscvoverTunersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<TunerHostInfo>, DiscvoverTunersParams>(apiClient) {}
QString DiscvoverTunersLoader::path(const DiscvoverTunersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/Tuners/Discvover");
}
QUrlQuery DiscvoverTunersLoader::query(const DiscvoverTunersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.newDevicesOnlyNull()) {
result.addQueryItem("newDevicesOnly", Support::toString<std::optional<bool>>(params.newDevicesOnly()));
}
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
ForgotPasswordLoader::ForgotPasswordLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ForgotPasswordResult, ForgotPasswordParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<ForgotPasswordResult, ForgotPasswordParams>(apiClient) {}
QString ForgotPasswordLoader::path(const ForgotPasswordParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
ForgotPasswordPinLoader::ForgotPasswordPinLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::PinRedeemResult, ForgotPasswordPinParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<PinRedeemResult, ForgotPasswordPinParams>(apiClient) {}
QString ForgotPasswordPinLoader::path(const ForgotPasswordPinParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetLoader::GetLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::SearchHintResult, GetParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<SearchHintResult, GetParams>(apiClient) {}
QString GetLoader::path(const GetParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -47,59 +48,59 @@ QUrlQuery GetLoader::query(const GetParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("searchTerm", params.searchTerm());
result.addQueryItem("searchTerm", Support::toString<QString>(params.searchTerm()));
// Optional parameters
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.includeItemTypesNull()) {
result.addQueryItem("includeItemTypes", Support::toString(params.includeItemTypes()));
result.addQueryItem("includeItemTypes", Support::toString<QStringList>(params.includeItemTypes()));
}
if (!params.excludeItemTypesNull()) {
result.addQueryItem("excludeItemTypes", Support::toString(params.excludeItemTypes()));
result.addQueryItem("excludeItemTypes", Support::toString<QStringList>(params.excludeItemTypes()));
}
if (!params.mediaTypesNull()) {
result.addQueryItem("mediaTypes", Support::toString(params.mediaTypes()));
result.addQueryItem("mediaTypes", Support::toString<QStringList>(params.mediaTypes()));
}
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString(params.parentId()));
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.isMovieNull()) {
result.addQueryItem("isMovie", Support::toString(params.isMovie()));
result.addQueryItem("isMovie", Support::toString<std::optional<bool>>(params.isMovie()));
}
if (!params.isSeriesNull()) {
result.addQueryItem("isSeries", Support::toString(params.isSeries()));
result.addQueryItem("isSeries", Support::toString<std::optional<bool>>(params.isSeries()));
}
if (!params.isNewsNull()) {
result.addQueryItem("isNews", Support::toString(params.isNews()));
result.addQueryItem("isNews", Support::toString<std::optional<bool>>(params.isNews()));
}
if (!params.isKidsNull()) {
result.addQueryItem("isKids", Support::toString(params.isKids()));
result.addQueryItem("isKids", Support::toString<std::optional<bool>>(params.isKids()));
}
if (!params.isSportsNull()) {
result.addQueryItem("isSports", Support::toString(params.isSports()));
result.addQueryItem("isSports", Support::toString<std::optional<bool>>(params.isSports()));
}
if (!params.includePeopleNull()) {
result.addQueryItem("includePeople", Support::toString(params.includePeople()));
result.addQueryItem("includePeople", Support::toString<std::optional<bool>>(params.includePeople()));
}
if (!params.includeMediaNull()) {
result.addQueryItem("includeMedia", Support::toString(params.includeMedia()));
result.addQueryItem("includeMedia", Support::toString<std::optional<bool>>(params.includeMedia()));
}
if (!params.includeGenresNull()) {
result.addQueryItem("includeGenres", Support::toString(params.includeGenres()));
result.addQueryItem("includeGenres", Support::toString<std::optional<bool>>(params.includeGenres()));
}
if (!params.includeStudiosNull()) {
result.addQueryItem("includeStudios", Support::toString(params.includeStudios()));
result.addQueryItem("includeStudios", Support::toString<std::optional<bool>>(params.includeStudios()));
}
if (!params.includeArtistsNull()) {
result.addQueryItem("includeArtists", Support::toString(params.includeArtists()));
result.addQueryItem("includeArtists", Support::toString<std::optional<bool>>(params.includeArtists()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetAdditionalPartLoader::GetAdditionalPartLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetAdditionalPartParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetAdditionalPartParams>(apiClient) {}
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");
return QStringLiteral("/Videos/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/AdditionalParts");
}
QUrlQuery GetAdditionalPartLoader::query(const GetAdditionalPartParams &params) const {
@ -50,7 +51,7 @@ QUrlQuery GetAdditionalPartLoader::query(const GetAdditionalPartParams &params)
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetAlbumArtistsLoader::GetAlbumArtistsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetAlbumArtistsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetAlbumArtistsParams>(apiClient) {}
QString GetAlbumArtistsLoader::path(const GetAlbumArtistsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,94 +51,94 @@ QUrlQuery GetAlbumArtistsLoader::query(const GetAlbumArtistsParams &params) cons
// Optional parameters
if (!params.minCommunityRatingNull()) {
result.addQueryItem("minCommunityRating", Support::toString(params.minCommunityRating()));
result.addQueryItem("minCommunityRating", Support::toString<std::optional<double>>(params.minCommunityRating()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.searchTermNull()) {
result.addQueryItem("searchTerm", Support::toString(params.searchTerm()));
result.addQueryItem("searchTerm", Support::toString<QString>(params.searchTerm()));
}
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString(params.parentId()));
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.excludeItemTypesNull()) {
result.addQueryItem("excludeItemTypes", Support::toString(params.excludeItemTypes()));
result.addQueryItem("excludeItemTypes", Support::toString<QStringList>(params.excludeItemTypes()));
}
if (!params.includeItemTypesNull()) {
result.addQueryItem("includeItemTypes", Support::toString(params.includeItemTypes()));
result.addQueryItem("includeItemTypes", Support::toString<QStringList>(params.includeItemTypes()));
}
if (!params.filtersNull()) {
result.addQueryItem("filters", Support::toString(params.filters()));
result.addQueryItem("filters", Support::toString<QList<ItemFilter>>(params.filters()));
}
if (!params.isFavoriteNull()) {
result.addQueryItem("isFavorite", Support::toString(params.isFavorite()));
result.addQueryItem("isFavorite", Support::toString<std::optional<bool>>(params.isFavorite()));
}
if (!params.mediaTypesNull()) {
result.addQueryItem("mediaTypes", Support::toString(params.mediaTypes()));
result.addQueryItem("mediaTypes", Support::toString<QStringList>(params.mediaTypes()));
}
if (!params.genresNull()) {
result.addQueryItem("genres", Support::toString(params.genres()));
result.addQueryItem("genres", Support::toString<QStringList>(params.genres()));
}
if (!params.genreIdsNull()) {
result.addQueryItem("genreIds", Support::toString(params.genreIds()));
result.addQueryItem("genreIds", Support::toString<QStringList>(params.genreIds()));
}
if (!params.officialRatingsNull()) {
result.addQueryItem("officialRatings", Support::toString(params.officialRatings()));
result.addQueryItem("officialRatings", Support::toString<QStringList>(params.officialRatings()));
}
if (!params.tagsNull()) {
result.addQueryItem("tags", Support::toString(params.tags()));
result.addQueryItem("tags", Support::toString<QStringList>(params.tags()));
}
if (!params.yearsNull()) {
result.addQueryItem("years", Support::toString(params.years()));
result.addQueryItem("years", Support::toString<QList<qint32>>(params.years()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.personNull()) {
result.addQueryItem("person", Support::toString(params.person()));
result.addQueryItem("person", Support::toString<QString>(params.person()));
}
if (!params.personIdsNull()) {
result.addQueryItem("personIds", Support::toString(params.personIds()));
result.addQueryItem("personIds", Support::toString<QStringList>(params.personIds()));
}
if (!params.personTypesNull()) {
result.addQueryItem("personTypes", Support::toString(params.personTypes()));
result.addQueryItem("personTypes", Support::toString<QStringList>(params.personTypes()));
}
if (!params.studiosNull()) {
result.addQueryItem("studios", Support::toString(params.studios()));
result.addQueryItem("studios", Support::toString<QStringList>(params.studios()));
}
if (!params.studioIdsNull()) {
result.addQueryItem("studioIds", Support::toString(params.studioIds()));
result.addQueryItem("studioIds", Support::toString<QStringList>(params.studioIds()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.nameStartsWithOrGreaterNull()) {
result.addQueryItem("nameStartsWithOrGreater", Support::toString(params.nameStartsWithOrGreater()));
result.addQueryItem("nameStartsWithOrGreater", Support::toString<QString>(params.nameStartsWithOrGreater()));
}
if (!params.nameStartsWithNull()) {
result.addQueryItem("nameStartsWith", Support::toString(params.nameStartsWith()));
result.addQueryItem("nameStartsWith", Support::toString<QString>(params.nameStartsWith()));
}
if (!params.nameLessThanNull()) {
result.addQueryItem("nameLessThan", Support::toString(params.nameLessThan()));
result.addQueryItem("nameLessThan", Support::toString<QString>(params.nameLessThan()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableTotalRecordCountNull()) {
result.addQueryItem("enableTotalRecordCount", Support::toString(params.enableTotalRecordCount()));
result.addQueryItem("enableTotalRecordCount", Support::toString<std::optional<bool>>(params.enableTotalRecordCount()));
}
return result;

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetAllChannelFeaturesLoader::GetAllChannelFeaturesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ChannelFeatures>, GetAllChannelFeaturesParams>(apiClient) {}
QString GetAllChannelFeaturesLoader::path(const GetAllChannelFeaturesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Channels/Features");
}
QUrlQuery GetAllChannelFeaturesLoader::query(const GetAllChannelFeaturesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

23
core/src/loader/http/getancestors.cpp
View file

@ -34,6 +34,29 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetAncestorsLoader::GetAncestorsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<BaseItemDto>, GetAncestorsParams>(apiClient) {}
QString GetAncestorsLoader::path(const GetAncestorsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Ancestors");
}
QUrlQuery GetAncestorsLoader::query(const GetAncestorsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetArtistByNameLoader::GetArtistByNameLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetArtistByNameParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDto, GetArtistByNameParams>(apiClient) {}
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()) ;
return QStringLiteral("/Artists/") + Support::toString< QString>(params.name()) ;
}
QUrlQuery GetArtistByNameLoader::query(const GetArtistByNameParams &params) const {
@ -50,7 +51,7 @@ QUrlQuery GetArtistByNameLoader::query(const GetArtistByNameParams &params) cons
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetArtistsLoader::GetArtistsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetArtistsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetArtistsParams>(apiClient) {}
QString GetArtistsLoader::path(const GetArtistsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,94 +51,94 @@ QUrlQuery GetArtistsLoader::query(const GetArtistsParams &params) const {
// Optional parameters
if (!params.minCommunityRatingNull()) {
result.addQueryItem("minCommunityRating", Support::toString(params.minCommunityRating()));
result.addQueryItem("minCommunityRating", Support::toString<std::optional<double>>(params.minCommunityRating()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.searchTermNull()) {
result.addQueryItem("searchTerm", Support::toString(params.searchTerm()));
result.addQueryItem("searchTerm", Support::toString<QString>(params.searchTerm()));
}
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString(params.parentId()));
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.excludeItemTypesNull()) {
result.addQueryItem("excludeItemTypes", Support::toString(params.excludeItemTypes()));
result.addQueryItem("excludeItemTypes", Support::toString<QStringList>(params.excludeItemTypes()));
}
if (!params.includeItemTypesNull()) {
result.addQueryItem("includeItemTypes", Support::toString(params.includeItemTypes()));
result.addQueryItem("includeItemTypes", Support::toString<QStringList>(params.includeItemTypes()));
}
if (!params.filtersNull()) {
result.addQueryItem("filters", Support::toString(params.filters()));
result.addQueryItem("filters", Support::toString<QList<ItemFilter>>(params.filters()));
}
if (!params.isFavoriteNull()) {
result.addQueryItem("isFavorite", Support::toString(params.isFavorite()));
result.addQueryItem("isFavorite", Support::toString<std::optional<bool>>(params.isFavorite()));
}
if (!params.mediaTypesNull()) {
result.addQueryItem("mediaTypes", Support::toString(params.mediaTypes()));
result.addQueryItem("mediaTypes", Support::toString<QStringList>(params.mediaTypes()));
}
if (!params.genresNull()) {
result.addQueryItem("genres", Support::toString(params.genres()));
result.addQueryItem("genres", Support::toString<QStringList>(params.genres()));
}
if (!params.genreIdsNull()) {
result.addQueryItem("genreIds", Support::toString(params.genreIds()));
result.addQueryItem("genreIds", Support::toString<QStringList>(params.genreIds()));
}
if (!params.officialRatingsNull()) {
result.addQueryItem("officialRatings", Support::toString(params.officialRatings()));
result.addQueryItem("officialRatings", Support::toString<QStringList>(params.officialRatings()));
}
if (!params.tagsNull()) {
result.addQueryItem("tags", Support::toString(params.tags()));
result.addQueryItem("tags", Support::toString<QStringList>(params.tags()));
}
if (!params.yearsNull()) {
result.addQueryItem("years", Support::toString(params.years()));
result.addQueryItem("years", Support::toString<QList<qint32>>(params.years()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.personNull()) {
result.addQueryItem("person", Support::toString(params.person()));
result.addQueryItem("person", Support::toString<QString>(params.person()));
}
if (!params.personIdsNull()) {
result.addQueryItem("personIds", Support::toString(params.personIds()));
result.addQueryItem("personIds", Support::toString<QStringList>(params.personIds()));
}
if (!params.personTypesNull()) {
result.addQueryItem("personTypes", Support::toString(params.personTypes()));
result.addQueryItem("personTypes", Support::toString<QStringList>(params.personTypes()));
}
if (!params.studiosNull()) {
result.addQueryItem("studios", Support::toString(params.studios()));
result.addQueryItem("studios", Support::toString<QStringList>(params.studios()));
}
if (!params.studioIdsNull()) {
result.addQueryItem("studioIds", Support::toString(params.studioIds()));
result.addQueryItem("studioIds", Support::toString<QStringList>(params.studioIds()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.nameStartsWithOrGreaterNull()) {
result.addQueryItem("nameStartsWithOrGreater", Support::toString(params.nameStartsWithOrGreater()));
result.addQueryItem("nameStartsWithOrGreater", Support::toString<QString>(params.nameStartsWithOrGreater()));
}
if (!params.nameStartsWithNull()) {
result.addQueryItem("nameStartsWith", Support::toString(params.nameStartsWith()));
result.addQueryItem("nameStartsWith", Support::toString<QString>(params.nameStartsWith()));
}
if (!params.nameLessThanNull()) {
result.addQueryItem("nameLessThan", Support::toString(params.nameLessThan()));
result.addQueryItem("nameLessThan", Support::toString<QString>(params.nameLessThan()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableTotalRecordCountNull()) {
result.addQueryItem("enableTotalRecordCount", Support::toString(params.enableTotalRecordCount()));
result.addQueryItem("enableTotalRecordCount", Support::toString<std::optional<bool>>(params.enableTotalRecordCount()));
}
return result;

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetAuthProvidersLoader::GetAuthProvidersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<NameIdPair>, GetAuthProvidersParams>(apiClient) {}
QString GetAuthProvidersLoader::path(const GetAuthProvidersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Auth/Providers");
}
QUrlQuery GetAuthProvidersLoader::query(const GetAuthProvidersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetBookRemoteSearchResultsLoader::GetBookRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetBookRemoteSearchResultsParams>(apiClient) {}
QString GetBookRemoteSearchResultsLoader::path(const GetBookRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/RemoteSearch/Book");
}
QUrlQuery GetBookRemoteSearchResultsLoader::query(const GetBookRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetBoxSetRemoteSearchResultsLoader::GetBoxSetRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetBoxSetRemoteSearchResultsParams>(apiClient) {}
QString GetBoxSetRemoteSearchResultsLoader::path(const GetBoxSetRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/RemoteSearch/BoxSet");
}
QUrlQuery GetBoxSetRemoteSearchResultsLoader::query(const GetBoxSetRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetBrandingCssLoader::GetBrandingCssLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetBrandingCssParams>(apiClient) {}
QString GetBrandingCssLoader::path(const GetBrandingCssParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Branding/Css");
}
QUrlQuery GetBrandingCssLoader::query(const GetBrandingCssParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetBrandingCss_2Loader::GetBrandingCss_2Loader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetBrandingCss_2Params>(apiClient) {}
QString GetBrandingCss_2Loader::path(const GetBrandingCss_2Params &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Branding/Css.css");
}
QUrlQuery GetBrandingCss_2Loader::query(const GetBrandingCss_2Params &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetBrandingOptionsLoader::GetBrandingOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BrandingOptions, GetBrandingOptionsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BrandingOptions, GetBrandingOptionsParams>(apiClient) {}
QString GetBrandingOptionsLoader::path(const GetBrandingOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetChannelLoader::GetChannelLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetChannelParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDto, GetChannelParams>(apiClient) {}
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()) ;
return QStringLiteral("/LiveTv/Channels/") + Support::toString< QString>(params.channelId()) ;
}
QUrlQuery GetChannelLoader::query(const GetChannelParams &params) const {
@ -50,7 +51,7 @@ QUrlQuery GetChannelLoader::query(const GetChannelParams &params) const {
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetChannelFeaturesLoader::GetChannelFeaturesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ChannelFeatures, GetChannelFeaturesParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<ChannelFeatures, GetChannelFeaturesParams>(apiClient) {}
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");
return QStringLiteral("/Channels/") + Support::toString< QString>(params.channelId()) + QStringLiteral("/Features");
}
QUrlQuery GetChannelFeaturesLoader::query(const GetChannelFeaturesParams &params) const {

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetChannelItemsLoader::GetChannelItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetChannelItemsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetChannelItemsParams>(apiClient) {}
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");
return QStringLiteral("/Channels/") + Support::toString< QString>(params.channelId()) + QStringLiteral("/Items");
}
QUrlQuery GetChannelItemsLoader::query(const GetChannelItemsParams &params) const {
@ -50,28 +51,28 @@ QUrlQuery GetChannelItemsLoader::query(const GetChannelItemsParams &params) cons
// Optional parameters
if (!params.folderIdNull()) {
result.addQueryItem("folderId", Support::toString(params.folderId()));
result.addQueryItem("folderId", Support::toString<QString>(params.folderId()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.sortOrderNull()) {
result.addQueryItem("sortOrder", Support::toString(params.sortOrder()));
result.addQueryItem("sortOrder", Support::toString<QString>(params.sortOrder()));
}
if (!params.filtersNull()) {
result.addQueryItem("filters", Support::toString(params.filters()));
result.addQueryItem("filters", Support::toString<QList<ItemFilter>>(params.filters()));
}
if (!params.sortByNull()) {
result.addQueryItem("sortBy", Support::toString(params.sortBy()));
result.addQueryItem("sortBy", Support::toString<QString>(params.sortBy()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetChannelMappingOptionsLoader::GetChannelMappingOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ChannelMappingOptionsDto, GetChannelMappingOptionsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<ChannelMappingOptionsDto, GetChannelMappingOptionsParams>(apiClient) {}
QString GetChannelMappingOptionsLoader::path(const GetChannelMappingOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,7 +51,7 @@ QUrlQuery GetChannelMappingOptionsLoader::query(const GetChannelMappingOptionsPa
// Optional parameters
if (!params.providerIdNull()) {
result.addQueryItem("providerId", Support::toString(params.providerId()));
result.addQueryItem("providerId", Support::toString<QString>(params.providerId()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetChannelsLoader::GetChannelsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetChannelsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetChannelsParams>(apiClient) {}
QString GetChannelsLoader::path(const GetChannelsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,22 +51,22 @@ QUrlQuery GetChannelsLoader::query(const GetChannelsParams &params) const {
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.supportsLatestItemsNull()) {
result.addQueryItem("supportsLatestItems", Support::toString(params.supportsLatestItems()));
result.addQueryItem("supportsLatestItems", Support::toString<std::optional<bool>>(params.supportsLatestItems()));
}
if (!params.supportsMediaDeletionNull()) {
result.addQueryItem("supportsMediaDeletion", Support::toString(params.supportsMediaDeletion()));
result.addQueryItem("supportsMediaDeletion", Support::toString<std::optional<bool>>(params.supportsMediaDeletion()));
}
if (!params.isFavoriteNull()) {
result.addQueryItem("isFavorite", Support::toString(params.isFavorite()));
result.addQueryItem("isFavorite", Support::toString<std::optional<bool>>(params.isFavorite()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetConfigurationLoader::GetConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ServerConfiguration, GetConfigurationParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<ServerConfiguration, GetConfigurationParams>(apiClient) {}
QString GetConfigurationLoader::path(const GetConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

26
core/src/loader/http/getconfigurationpages.cpp
View file

@ -34,6 +34,32 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetConfigurationPagesLoader::GetConfigurationPagesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ConfigurationPageInfo>, GetConfigurationPagesParams>(apiClient) {}
QString GetConfigurationPagesLoader::path(const GetConfigurationPagesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/web/ConfigurationPages");
}
QUrlQuery GetConfigurationPagesLoader::query(const GetConfigurationPagesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.enableInMainMenuNull()) {
result.addQueryItem("enableInMainMenu", Support::toString<std::optional<bool>>(params.enableInMainMenu()));
}
if (!params.pageTypeNull()) {
result.addQueryItem("pageType", Support::toString<ConfigurationPageType>(params.pageType()));
}
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetCountriesLoader::GetCountriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<CountryInfo>, GetCountriesParams>(apiClient) {}
QString GetCountriesLoader::path(const GetCountriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Localization/Countries");
}
QUrlQuery GetCountriesLoader::query(const GetCountriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetCriticReviewsLoader::GetCriticReviewsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetCriticReviewsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetCriticReviewsParams>(apiClient) {}
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");
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/CriticReviews");
}
QUrlQuery GetCriticReviewsLoader::query(const GetCriticReviewsParams &params) const {

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetCulturesLoader::GetCulturesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<CultureDto>, GetCulturesParams>(apiClient) {}
QString GetCulturesLoader::path(const GetCulturesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Localization/Cultures");
}
QUrlQuery GetCulturesLoader::query(const GetCulturesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetCurrentUserLoader::GetCurrentUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::UserDto, GetCurrentUserParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<UserDto, GetCurrentUserParams>(apiClient) {}
QString GetCurrentUserLoader::path(const GetCurrentUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDefaultDirectoryBrowserLoader::GetDefaultDirectoryBrowserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DefaultDirectoryBrowserInfoDto, GetDefaultDirectoryBrowserParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<DefaultDirectoryBrowserInfoDto, GetDefaultDirectoryBrowserParams>(apiClient) {}
QString GetDefaultDirectoryBrowserLoader::path(const GetDefaultDirectoryBrowserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDefaultListingProviderLoader::GetDefaultListingProviderLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ListingsProviderInfo, GetDefaultListingProviderParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<ListingsProviderInfo, GetDefaultListingProviderParams>(apiClient) {}
QString GetDefaultListingProviderLoader::path(const GetDefaultListingProviderParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDefaultMetadataOptionsLoader::GetDefaultMetadataOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::MetadataOptions, GetDefaultMetadataOptionsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<MetadataOptions, GetDefaultMetadataOptionsParams>(apiClient) {}
QString GetDefaultMetadataOptionsLoader::path(const GetDefaultMetadataOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDefaultProfileLoader::GetDefaultProfileLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DeviceProfile, GetDefaultProfileParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<DeviceProfile, GetDefaultProfileParams>(apiClient) {}
QString GetDefaultProfileLoader::path(const GetDefaultProfileParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDefaultTimerLoader::GetDefaultTimerLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::SeriesTimerInfoDto, GetDefaultTimerParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<SeriesTimerInfoDto, GetDefaultTimerParams>(apiClient) {}
QString GetDefaultTimerLoader::path(const GetDefaultTimerParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,7 +51,7 @@ QUrlQuery GetDefaultTimerLoader::query(const GetDefaultTimerParams &params) cons
// Optional parameters
if (!params.programIdNull()) {
result.addQueryItem("programId", Support::toString(params.programId()));
result.addQueryItem("programId", Support::toString<QString>(params.programId()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDeviceInfoLoader::GetDeviceInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DeviceInfo, GetDeviceInfoParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<DeviceInfo, GetDeviceInfoParams>(apiClient) {}
QString GetDeviceInfoLoader::path(const GetDeviceInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -47,7 +48,7 @@ QUrlQuery GetDeviceInfoLoader::query(const GetDeviceInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("id", params.jellyfinId());
result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
// Optional parameters

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDeviceOptionsLoader::GetDeviceOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DeviceOptions, GetDeviceOptionsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<DeviceOptions, GetDeviceOptionsParams>(apiClient) {}
QString GetDeviceOptionsLoader::path(const GetDeviceOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -47,7 +48,7 @@ QUrlQuery GetDeviceOptionsLoader::query(const GetDeviceOptionsParams &params) co
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("id", params.jellyfinId());
result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
// Optional parameters

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDevicesLoader::GetDevicesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DeviceInfoQueryResult, GetDevicesParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<DeviceInfoQueryResult, GetDevicesParams>(apiClient) {}
QString GetDevicesLoader::path(const GetDevicesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,10 +51,10 @@ QUrlQuery GetDevicesLoader::query(const GetDevicesParams &params) const {
// Optional parameters
if (!params.supportsSyncNull()) {
result.addQueryItem("supportsSync", Support::toString(params.supportsSync()));
result.addQueryItem("supportsSync", Support::toString<std::optional<bool>>(params.supportsSync()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
return result;

27
core/src/loader/http/getdirectorycontents.cpp
View file

@ -34,6 +34,33 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDirectoryContentsLoader::GetDirectoryContentsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<FileSystemEntryInfo>, GetDirectoryContentsParams>(apiClient) {}
QString GetDirectoryContentsLoader::path(const GetDirectoryContentsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Environment/DirectoryContents");
}
QUrlQuery GetDirectoryContentsLoader::query(const GetDirectoryContentsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("path", Support::toString<QString>(params.path()));
// Optional parameters
if (!params.includeFilesNull()) {
result.addQueryItem("includeFiles", Support::toString<std::optional<bool>>(params.includeFiles()));
}
if (!params.includeDirectoriesNull()) {
result.addQueryItem("includeDirectories", Support::toString<std::optional<bool>>(params.includeDirectories()));
}
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,21 +34,22 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDisplayPreferencesLoader::GetDisplayPreferencesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::DisplayPreferencesDto, GetDisplayPreferencesParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<DisplayPreferencesDto, GetDisplayPreferencesParams>(apiClient) {}
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()) ;
return QStringLiteral("/DisplayPreferences/") + Support::toString< QString>(params.displayPreferencesId()) ;
}
QUrlQuery GetDisplayPreferencesLoader::query(const GetDisplayPreferencesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
result.addQueryItem("userId", params.userId());
result.addQueryItem("client", params.client());
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
result.addQueryItem("client", Support::toString<QString>(params.client()));
// Optional parameters

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetDrivesLoader::GetDrivesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<FileSystemEntryInfo>, GetDrivesParams>(apiClient) {}
QString GetDrivesLoader::path(const GetDrivesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Environment/Drives");
}
QUrlQuery GetDrivesLoader::query(const GetDrivesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetEndpointInfoLoader::GetEndpointInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::EndPointInfo, GetEndpointInfoParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<EndPointInfo, GetEndpointInfoParams>(apiClient) {}
QString GetEndpointInfoLoader::path(const GetEndpointInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetEpisodesLoader::GetEpisodesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetEpisodesParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetEpisodesParams>(apiClient) {}
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");
return QStringLiteral("/Shows/") + Support::toString< QString>(params.seriesId()) + QStringLiteral("/Episodes");
}
QUrlQuery GetEpisodesLoader::query(const GetEpisodesParams &params) const {
@ -50,46 +51,46 @@ QUrlQuery GetEpisodesLoader::query(const GetEpisodesParams &params) const {
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.seasonNull()) {
result.addQueryItem("season", Support::toString(params.season()));
result.addQueryItem("season", Support::toString<std::optional<qint32>>(params.season()));
}
if (!params.seasonIdNull()) {
result.addQueryItem("seasonId", Support::toString(params.seasonId()));
result.addQueryItem("seasonId", Support::toString<QString>(params.seasonId()));
}
if (!params.isMissingNull()) {
result.addQueryItem("isMissing", Support::toString(params.isMissing()));
result.addQueryItem("isMissing", Support::toString<std::optional<bool>>(params.isMissing()));
}
if (!params.adjacentToNull()) {
result.addQueryItem("adjacentTo", Support::toString(params.adjacentTo()));
result.addQueryItem("adjacentTo", Support::toString<QString>(params.adjacentTo()));
}
if (!params.startItemIdNull()) {
result.addQueryItem("startItemId", Support::toString(params.startItemId()));
result.addQueryItem("startItemId", Support::toString<QString>(params.startItemId()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.sortByNull()) {
result.addQueryItem("sortBy", Support::toString(params.sortBy()));
result.addQueryItem("sortBy", Support::toString<QString>(params.sortBy()));
}
return result;

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetExternalIdInfosLoader::GetExternalIdInfosLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ExternalIdInfo>, GetExternalIdInfosParams>(apiClient) {}
QString GetExternalIdInfosLoader::path(const GetExternalIdInfosParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/ExternalIdInfos");
}
QUrlQuery GetExternalIdInfosLoader::query(const GetExternalIdInfosParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetFallbackFontListLoader::GetFallbackFontListLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<FontFile>, GetFallbackFontListParams>(apiClient) {}
QString GetFallbackFontListLoader::path(const GetFallbackFontListParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/FallbackFont/Fonts");
}
QUrlQuery GetFallbackFontListLoader::query(const GetFallbackFontListParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetFirstUserLoader::GetFirstUserLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::StartupUserDto, GetFirstUserParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<StartupUserDto, GetFirstUserParams>(apiClient) {}
QString GetFirstUserLoader::path(const GetFirstUserParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetFirstUser_2Loader::GetFirstUser_2Loader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::StartupUserDto, GetFirstUser_2Params>(apiClient) {}
: Jellyfin::Support::HttpLoader<StartupUserDto, GetFirstUser_2Params>(apiClient) {}
QString GetFirstUser_2Loader::path(const GetFirstUser_2Params &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetGeneralImagesLoader::GetGeneralImagesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ImageByNameInfo>, GetGeneralImagesParams>(apiClient) {}
QString GetGeneralImagesLoader::path(const GetGeneralImagesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Images/General");
}
QUrlQuery GetGeneralImagesLoader::query(const GetGeneralImagesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetGenreLoader::GetGenreLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetGenreParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDto, GetGenreParams>(apiClient) {}
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()) ;
return QStringLiteral("/Genres/") + Support::toString< QString>(params.genreName()) ;
}
QUrlQuery GetGenreLoader::query(const GetGenreParams &params) const {
@ -50,7 +51,7 @@ QUrlQuery GetGenreLoader::query(const GetGenreParams &params) const {
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetGenresLoader::GetGenresLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetGenresParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetGenresParams>(apiClient) {}
QString GetGenresLoader::path(const GetGenresParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,52 +51,52 @@ QUrlQuery GetGenresLoader::query(const GetGenresParams &params) const {
// Optional parameters
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.searchTermNull()) {
result.addQueryItem("searchTerm", Support::toString(params.searchTerm()));
result.addQueryItem("searchTerm", Support::toString<QString>(params.searchTerm()));
}
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString(params.parentId()));
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.excludeItemTypesNull()) {
result.addQueryItem("excludeItemTypes", Support::toString(params.excludeItemTypes()));
result.addQueryItem("excludeItemTypes", Support::toString<QStringList>(params.excludeItemTypes()));
}
if (!params.includeItemTypesNull()) {
result.addQueryItem("includeItemTypes", Support::toString(params.includeItemTypes()));
result.addQueryItem("includeItemTypes", Support::toString<QStringList>(params.includeItemTypes()));
}
if (!params.isFavoriteNull()) {
result.addQueryItem("isFavorite", Support::toString(params.isFavorite()));
result.addQueryItem("isFavorite", Support::toString<std::optional<bool>>(params.isFavorite()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.nameStartsWithOrGreaterNull()) {
result.addQueryItem("nameStartsWithOrGreater", Support::toString(params.nameStartsWithOrGreater()));
result.addQueryItem("nameStartsWithOrGreater", Support::toString<QString>(params.nameStartsWithOrGreater()));
}
if (!params.nameStartsWithNull()) {
result.addQueryItem("nameStartsWith", Support::toString(params.nameStartsWith()));
result.addQueryItem("nameStartsWith", Support::toString<QString>(params.nameStartsWith()));
}
if (!params.nameLessThanNull()) {
result.addQueryItem("nameLessThan", Support::toString(params.nameLessThan()));
result.addQueryItem("nameLessThan", Support::toString<QString>(params.nameLessThan()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableTotalRecordCountNull()) {
result.addQueryItem("enableTotalRecordCount", Support::toString(params.enableTotalRecordCount()));
result.addQueryItem("enableTotalRecordCount", Support::toString<std::optional<bool>>(params.enableTotalRecordCount()));
}
return result;

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetGroupingOptionsLoader::GetGroupingOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<SpecialViewOptionDto>, GetGroupingOptionsParams>(apiClient) {}
QString GetGroupingOptionsLoader::path(const GetGroupingOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/GroupingOptions");
}
QUrlQuery GetGroupingOptionsLoader::query(const GetGroupingOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetGuideInfoLoader::GetGuideInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::GuideInfo, GetGuideInfoParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<GuideInfo, GetGuideInfoParams>(apiClient) {}
QString GetGuideInfoLoader::path(const GetGuideInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetInstantMixFromAlbumLoader::GetInstantMixFromAlbumLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromAlbumParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromAlbumParams>(apiClient) {}
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");
return QStringLiteral("/Albums/") + Support::toString< QString>(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromAlbumLoader::query(const GetInstantMixFromAlbumParams &params) const {
@ -50,25 +51,25 @@ QUrlQuery GetInstantMixFromAlbumLoader::query(const GetInstantMixFromAlbumParams
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetInstantMixFromArtistsLoader::GetInstantMixFromArtistsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromArtistsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromArtistsParams>(apiClient) {}
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");
return QStringLiteral("/Artists/") + Support::toString< QString>(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromArtistsLoader::query(const GetInstantMixFromArtistsParams &params) const {
@ -50,25 +51,25 @@ QUrlQuery GetInstantMixFromArtistsLoader::query(const GetInstantMixFromArtistsPa
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetInstantMixFromItemLoader::GetInstantMixFromItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromItemParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromItemParams>(apiClient) {}
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");
return QStringLiteral("/Items/") + Support::toString< QString>(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromItemLoader::query(const GetInstantMixFromItemParams &params) const {
@ -50,25 +51,25 @@ QUrlQuery GetInstantMixFromItemLoader::query(const GetInstantMixFromItemParams &
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetInstantMixFromMusicGenreLoader::GetInstantMixFromMusicGenreLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromMusicGenreParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromMusicGenreParams>(apiClient) {}
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");
return QStringLiteral("/MusicGenres/") + Support::toString< QString>(params.name()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromMusicGenreLoader::query(const GetInstantMixFromMusicGenreParams &params) const {
@ -50,25 +51,25 @@ QUrlQuery GetInstantMixFromMusicGenreLoader::query(const GetInstantMixFromMusicG
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetInstantMixFromMusicGenresLoader::GetInstantMixFromMusicGenresLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromMusicGenresParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromMusicGenresParams>(apiClient) {}
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");
return QStringLiteral("/MusicGenres/") + Support::toString< QString>(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromMusicGenresLoader::query(const GetInstantMixFromMusicGenresParams &params) const {
@ -50,25 +51,25 @@ QUrlQuery GetInstantMixFromMusicGenresLoader::query(const GetInstantMixFromMusic
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetInstantMixFromPlaylistLoader::GetInstantMixFromPlaylistLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromPlaylistParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromPlaylistParams>(apiClient) {}
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");
return QStringLiteral("/Playlists/") + Support::toString< QString>(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromPlaylistLoader::query(const GetInstantMixFromPlaylistParams &params) const {
@ -50,25 +51,25 @@ QUrlQuery GetInstantMixFromPlaylistLoader::query(const GetInstantMixFromPlaylist
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetInstantMixFromSongLoader::GetInstantMixFromSongLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetInstantMixFromSongParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetInstantMixFromSongParams>(apiClient) {}
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");
return QStringLiteral("/Songs/") + Support::toString< QString>(params.jellyfinId()) + QStringLiteral("/InstantMix");
}
QUrlQuery GetInstantMixFromSongLoader::query(const GetInstantMixFromSongParams &params) const {
@ -50,25 +51,25 @@ QUrlQuery GetInstantMixFromSongLoader::query(const GetInstantMixFromSongParams &
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetIntrosLoader::GetIntrosLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetIntrosParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetIntrosParams>(apiClient) {}
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");
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Intros");
}
QUrlQuery GetIntrosLoader::query(const GetIntrosParams &params) const {

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetItemLoader::GetItemLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetItemParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDto, GetItemParams>(apiClient) {}
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()) ;
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) ;
}
QUrlQuery GetItemLoader::query(const GetItemParams &params) const {

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetItemCountsLoader::GetItemCountsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ItemCounts, GetItemCountsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<ItemCounts, GetItemCountsParams>(apiClient) {}
QString GetItemCountsLoader::path(const GetItemCountsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,10 +51,10 @@ QUrlQuery GetItemCountsLoader::query(const GetItemCountsParams &params) const {
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.isFavoriteNull()) {
result.addQueryItem("isFavorite", Support::toString(params.isFavorite()));
result.addQueryItem("isFavorite", Support::toString<std::optional<bool>>(params.isFavorite()));
}
return result;

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetItemImageInfosLoader::GetItemImageInfosLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ImageInfo>, GetItemImageInfosParams>(apiClient) {}
QString GetItemImageInfosLoader::path(const GetItemImageInfosParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/Images");
}
QUrlQuery GetItemImageInfosLoader::query(const GetItemImageInfosParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetItemsLoader::GetItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetItemsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetItemsParams>(apiClient) {}
QString GetItemsLoader::path(const GetItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,244 +51,244 @@ QUrlQuery GetItemsLoader::query(const GetItemsParams &params) const {
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.maxOfficialRatingNull()) {
result.addQueryItem("maxOfficialRating", Support::toString(params.maxOfficialRating()));
result.addQueryItem("maxOfficialRating", Support::toString<QString>(params.maxOfficialRating()));
}
if (!params.hasThemeSongNull()) {
result.addQueryItem("hasThemeSong", Support::toString(params.hasThemeSong()));
result.addQueryItem("hasThemeSong", Support::toString<std::optional<bool>>(params.hasThemeSong()));
}
if (!params.hasThemeVideoNull()) {
result.addQueryItem("hasThemeVideo", Support::toString(params.hasThemeVideo()));
result.addQueryItem("hasThemeVideo", Support::toString<std::optional<bool>>(params.hasThemeVideo()));
}
if (!params.hasSubtitlesNull()) {
result.addQueryItem("hasSubtitles", Support::toString(params.hasSubtitles()));
result.addQueryItem("hasSubtitles", Support::toString<std::optional<bool>>(params.hasSubtitles()));
}
if (!params.hasSpecialFeatureNull()) {
result.addQueryItem("hasSpecialFeature", Support::toString(params.hasSpecialFeature()));
result.addQueryItem("hasSpecialFeature", Support::toString<std::optional<bool>>(params.hasSpecialFeature()));
}
if (!params.hasTrailerNull()) {
result.addQueryItem("hasTrailer", Support::toString(params.hasTrailer()));
result.addQueryItem("hasTrailer", Support::toString<std::optional<bool>>(params.hasTrailer()));
}
if (!params.adjacentToNull()) {
result.addQueryItem("adjacentTo", Support::toString(params.adjacentTo()));
result.addQueryItem("adjacentTo", Support::toString<QString>(params.adjacentTo()));
}
if (!params.parentIndexNumberNull()) {
result.addQueryItem("parentIndexNumber", Support::toString(params.parentIndexNumber()));
result.addQueryItem("parentIndexNumber", Support::toString<std::optional<qint32>>(params.parentIndexNumber()));
}
if (!params.hasParentalRatingNull()) {
result.addQueryItem("hasParentalRating", Support::toString(params.hasParentalRating()));
result.addQueryItem("hasParentalRating", Support::toString<std::optional<bool>>(params.hasParentalRating()));
}
if (!params.isHdNull()) {
result.addQueryItem("isHd", Support::toString(params.isHd()));
result.addQueryItem("isHd", Support::toString<std::optional<bool>>(params.isHd()));
}
if (!params.is4KNull()) {
result.addQueryItem("is4K", Support::toString(params.is4K()));
result.addQueryItem("is4K", Support::toString<std::optional<bool>>(params.is4K()));
}
if (!params.locationTypesNull()) {
result.addQueryItem("locationTypes", Support::toString(params.locationTypes()));
result.addQueryItem("locationTypes", Support::toString<QList<LocationType>>(params.locationTypes()));
}
if (!params.excludeLocationTypesNull()) {
result.addQueryItem("excludeLocationTypes", Support::toString(params.excludeLocationTypes()));
result.addQueryItem("excludeLocationTypes", Support::toString<QList<LocationType>>(params.excludeLocationTypes()));
}
if (!params.isMissingNull()) {
result.addQueryItem("isMissing", Support::toString(params.isMissing()));
result.addQueryItem("isMissing", Support::toString<std::optional<bool>>(params.isMissing()));
}
if (!params.isUnairedNull()) {
result.addQueryItem("isUnaired", Support::toString(params.isUnaired()));
result.addQueryItem("isUnaired", Support::toString<std::optional<bool>>(params.isUnaired()));
}
if (!params.minCommunityRatingNull()) {
result.addQueryItem("minCommunityRating", Support::toString(params.minCommunityRating()));
result.addQueryItem("minCommunityRating", Support::toString<std::optional<double>>(params.minCommunityRating()));
}
if (!params.minCriticRatingNull()) {
result.addQueryItem("minCriticRating", Support::toString(params.minCriticRating()));
result.addQueryItem("minCriticRating", Support::toString<std::optional<double>>(params.minCriticRating()));
}
if (!params.minPremiereDateNull()) {
result.addQueryItem("minPremiereDate", Support::toString(params.minPremiereDate()));
result.addQueryItem("minPremiereDate", Support::toString<QDateTime>(params.minPremiereDate()));
}
if (!params.minDateLastSavedNull()) {
result.addQueryItem("minDateLastSaved", Support::toString(params.minDateLastSaved()));
result.addQueryItem("minDateLastSaved", Support::toString<QDateTime>(params.minDateLastSaved()));
}
if (!params.minDateLastSavedForUserNull()) {
result.addQueryItem("minDateLastSavedForUser", Support::toString(params.minDateLastSavedForUser()));
result.addQueryItem("minDateLastSavedForUser", Support::toString<QDateTime>(params.minDateLastSavedForUser()));
}
if (!params.maxPremiereDateNull()) {
result.addQueryItem("maxPremiereDate", Support::toString(params.maxPremiereDate()));
result.addQueryItem("maxPremiereDate", Support::toString<QDateTime>(params.maxPremiereDate()));
}
if (!params.hasOverviewNull()) {
result.addQueryItem("hasOverview", Support::toString(params.hasOverview()));
result.addQueryItem("hasOverview", Support::toString<std::optional<bool>>(params.hasOverview()));
}
if (!params.hasImdbIdNull()) {
result.addQueryItem("hasImdbId", Support::toString(params.hasImdbId()));
result.addQueryItem("hasImdbId", Support::toString<std::optional<bool>>(params.hasImdbId()));
}
if (!params.hasTmdbIdNull()) {
result.addQueryItem("hasTmdbId", Support::toString(params.hasTmdbId()));
result.addQueryItem("hasTmdbId", Support::toString<std::optional<bool>>(params.hasTmdbId()));
}
if (!params.hasTvdbIdNull()) {
result.addQueryItem("hasTvdbId", Support::toString(params.hasTvdbId()));
result.addQueryItem("hasTvdbId", Support::toString<std::optional<bool>>(params.hasTvdbId()));
}
if (!params.excludeItemIdsNull()) {
result.addQueryItem("excludeItemIds", Support::toString(params.excludeItemIds()));
result.addQueryItem("excludeItemIds", Support::toString<QStringList>(params.excludeItemIds()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.recursiveNull()) {
result.addQueryItem("recursive", Support::toString(params.recursive()));
result.addQueryItem("recursive", Support::toString<std::optional<bool>>(params.recursive()));
}
if (!params.searchTermNull()) {
result.addQueryItem("searchTerm", Support::toString(params.searchTerm()));
result.addQueryItem("searchTerm", Support::toString<QString>(params.searchTerm()));
}
if (!params.sortOrderNull()) {
result.addQueryItem("sortOrder", Support::toString(params.sortOrder()));
result.addQueryItem("sortOrder", Support::toString<QString>(params.sortOrder()));
}
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString(params.parentId()));
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.excludeItemTypesNull()) {
result.addQueryItem("excludeItemTypes", Support::toString(params.excludeItemTypes()));
result.addQueryItem("excludeItemTypes", Support::toString<QStringList>(params.excludeItemTypes()));
}
if (!params.includeItemTypesNull()) {
result.addQueryItem("includeItemTypes", Support::toString(params.includeItemTypes()));
result.addQueryItem("includeItemTypes", Support::toString<QStringList>(params.includeItemTypes()));
}
if (!params.filtersNull()) {
result.addQueryItem("filters", Support::toString(params.filters()));
result.addQueryItem("filters", Support::toString<QList<ItemFilter>>(params.filters()));
}
if (!params.isFavoriteNull()) {
result.addQueryItem("isFavorite", Support::toString(params.isFavorite()));
result.addQueryItem("isFavorite", Support::toString<std::optional<bool>>(params.isFavorite()));
}
if (!params.mediaTypesNull()) {
result.addQueryItem("mediaTypes", Support::toString(params.mediaTypes()));
result.addQueryItem("mediaTypes", Support::toString<QStringList>(params.mediaTypes()));
}
if (!params.imageTypesNull()) {
result.addQueryItem("imageTypes", Support::toString(params.imageTypes()));
result.addQueryItem("imageTypes", Support::toString<QList<ImageType>>(params.imageTypes()));
}
if (!params.sortByNull()) {
result.addQueryItem("sortBy", Support::toString(params.sortBy()));
result.addQueryItem("sortBy", Support::toString<QString>(params.sortBy()));
}
if (!params.isPlayedNull()) {
result.addQueryItem("isPlayed", Support::toString(params.isPlayed()));
result.addQueryItem("isPlayed", Support::toString<std::optional<bool>>(params.isPlayed()));
}
if (!params.genresNull()) {
result.addQueryItem("genres", Support::toString(params.genres()));
result.addQueryItem("genres", Support::toString<QStringList>(params.genres()));
}
if (!params.officialRatingsNull()) {
result.addQueryItem("officialRatings", Support::toString(params.officialRatings()));
result.addQueryItem("officialRatings", Support::toString<QStringList>(params.officialRatings()));
}
if (!params.tagsNull()) {
result.addQueryItem("tags", Support::toString(params.tags()));
result.addQueryItem("tags", Support::toString<QStringList>(params.tags()));
}
if (!params.yearsNull()) {
result.addQueryItem("years", Support::toString(params.years()));
result.addQueryItem("years", Support::toString<QList<qint32>>(params.years()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.personNull()) {
result.addQueryItem("person", Support::toString(params.person()));
result.addQueryItem("person", Support::toString<QString>(params.person()));
}
if (!params.personIdsNull()) {
result.addQueryItem("personIds", Support::toString(params.personIds()));
result.addQueryItem("personIds", Support::toString<QStringList>(params.personIds()));
}
if (!params.personTypesNull()) {
result.addQueryItem("personTypes", Support::toString(params.personTypes()));
result.addQueryItem("personTypes", Support::toString<QStringList>(params.personTypes()));
}
if (!params.studiosNull()) {
result.addQueryItem("studios", Support::toString(params.studios()));
result.addQueryItem("studios", Support::toString<QStringList>(params.studios()));
}
if (!params.artistsNull()) {
result.addQueryItem("artists", Support::toString(params.artists()));
result.addQueryItem("artists", Support::toString<QStringList>(params.artists()));
}
if (!params.excludeArtistIdsNull()) {
result.addQueryItem("excludeArtistIds", Support::toString(params.excludeArtistIds()));
result.addQueryItem("excludeArtistIds", Support::toString<QStringList>(params.excludeArtistIds()));
}
if (!params.artistIdsNull()) {
result.addQueryItem("artistIds", Support::toString(params.artistIds()));
result.addQueryItem("artistIds", Support::toString<QStringList>(params.artistIds()));
}
if (!params.albumArtistIdsNull()) {
result.addQueryItem("albumArtistIds", Support::toString(params.albumArtistIds()));
result.addQueryItem("albumArtistIds", Support::toString<QStringList>(params.albumArtistIds()));
}
if (!params.contributingArtistIdsNull()) {
result.addQueryItem("contributingArtistIds", Support::toString(params.contributingArtistIds()));
result.addQueryItem("contributingArtistIds", Support::toString<QStringList>(params.contributingArtistIds()));
}
if (!params.albumsNull()) {
result.addQueryItem("albums", Support::toString(params.albums()));
result.addQueryItem("albums", Support::toString<QStringList>(params.albums()));
}
if (!params.albumIdsNull()) {
result.addQueryItem("albumIds", Support::toString(params.albumIds()));
result.addQueryItem("albumIds", Support::toString<QStringList>(params.albumIds()));
}
if (!params.idsNull()) {
result.addQueryItem("ids", Support::toString(params.ids()));
result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
}
if (!params.videoTypesNull()) {
result.addQueryItem("videoTypes", Support::toString(params.videoTypes()));
result.addQueryItem("videoTypes", Support::toString<QList<VideoType>>(params.videoTypes()));
}
if (!params.minOfficialRatingNull()) {
result.addQueryItem("minOfficialRating", Support::toString(params.minOfficialRating()));
result.addQueryItem("minOfficialRating", Support::toString<QString>(params.minOfficialRating()));
}
if (!params.isLockedNull()) {
result.addQueryItem("isLocked", Support::toString(params.isLocked()));
result.addQueryItem("isLocked", Support::toString<std::optional<bool>>(params.isLocked()));
}
if (!params.isPlaceHolderNull()) {
result.addQueryItem("isPlaceHolder", Support::toString(params.isPlaceHolder()));
result.addQueryItem("isPlaceHolder", Support::toString<std::optional<bool>>(params.isPlaceHolder()));
}
if (!params.hasOfficialRatingNull()) {
result.addQueryItem("hasOfficialRating", Support::toString(params.hasOfficialRating()));
result.addQueryItem("hasOfficialRating", Support::toString<std::optional<bool>>(params.hasOfficialRating()));
}
if (!params.collapseBoxSetItemsNull()) {
result.addQueryItem("collapseBoxSetItems", Support::toString(params.collapseBoxSetItems()));
result.addQueryItem("collapseBoxSetItems", Support::toString<std::optional<bool>>(params.collapseBoxSetItems()));
}
if (!params.minWidthNull()) {
result.addQueryItem("minWidth", Support::toString(params.minWidth()));
result.addQueryItem("minWidth", Support::toString<std::optional<qint32>>(params.minWidth()));
}
if (!params.minHeightNull()) {
result.addQueryItem("minHeight", Support::toString(params.minHeight()));
result.addQueryItem("minHeight", Support::toString<std::optional<qint32>>(params.minHeight()));
}
if (!params.maxWidthNull()) {
result.addQueryItem("maxWidth", Support::toString(params.maxWidth()));
result.addQueryItem("maxWidth", Support::toString<std::optional<qint32>>(params.maxWidth()));
}
if (!params.maxHeightNull()) {
result.addQueryItem("maxHeight", Support::toString(params.maxHeight()));
result.addQueryItem("maxHeight", Support::toString<std::optional<qint32>>(params.maxHeight()));
}
if (!params.is3DNull()) {
result.addQueryItem("is3D", Support::toString(params.is3D()));
result.addQueryItem("is3D", Support::toString<std::optional<bool>>(params.is3D()));
}
if (!params.seriesStatusNull()) {
result.addQueryItem("seriesStatus", Support::toString(params.seriesStatus()));
result.addQueryItem("seriesStatus", Support::toString<QList<SeriesStatus>>(params.seriesStatus()));
}
if (!params.nameStartsWithOrGreaterNull()) {
result.addQueryItem("nameStartsWithOrGreater", Support::toString(params.nameStartsWithOrGreater()));
result.addQueryItem("nameStartsWithOrGreater", Support::toString<QString>(params.nameStartsWithOrGreater()));
}
if (!params.nameStartsWithNull()) {
result.addQueryItem("nameStartsWith", Support::toString(params.nameStartsWith()));
result.addQueryItem("nameStartsWith", Support::toString<QString>(params.nameStartsWith()));
}
if (!params.nameLessThanNull()) {
result.addQueryItem("nameLessThan", Support::toString(params.nameLessThan()));
result.addQueryItem("nameLessThan", Support::toString<QString>(params.nameLessThan()));
}
if (!params.studioIdsNull()) {
result.addQueryItem("studioIds", Support::toString(params.studioIds()));
result.addQueryItem("studioIds", Support::toString<QStringList>(params.studioIds()));
}
if (!params.genreIdsNull()) {
result.addQueryItem("genreIds", Support::toString(params.genreIds()));
result.addQueryItem("genreIds", Support::toString<QStringList>(params.genreIds()));
}
if (!params.enableTotalRecordCountNull()) {
result.addQueryItem("enableTotalRecordCount", Support::toString(params.enableTotalRecordCount()));
result.addQueryItem("enableTotalRecordCount", Support::toString<std::optional<bool>>(params.enableTotalRecordCount()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetItemsByUserIdLoader::GetItemsByUserIdLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetItemsByUserIdParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetItemsByUserIdParams>(apiClient) {}
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");
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Items");
}
QUrlQuery GetItemsByUserIdLoader::query(const GetItemsByUserIdParams &params) const {
@ -50,241 +51,241 @@ QUrlQuery GetItemsByUserIdLoader::query(const GetItemsByUserIdParams &params) co
// Optional parameters
if (!params.maxOfficialRatingNull()) {
result.addQueryItem("maxOfficialRating", Support::toString(params.maxOfficialRating()));
result.addQueryItem("maxOfficialRating", Support::toString<QString>(params.maxOfficialRating()));
}
if (!params.hasThemeSongNull()) {
result.addQueryItem("hasThemeSong", Support::toString(params.hasThemeSong()));
result.addQueryItem("hasThemeSong", Support::toString<std::optional<bool>>(params.hasThemeSong()));
}
if (!params.hasThemeVideoNull()) {
result.addQueryItem("hasThemeVideo", Support::toString(params.hasThemeVideo()));
result.addQueryItem("hasThemeVideo", Support::toString<std::optional<bool>>(params.hasThemeVideo()));
}
if (!params.hasSubtitlesNull()) {
result.addQueryItem("hasSubtitles", Support::toString(params.hasSubtitles()));
result.addQueryItem("hasSubtitles", Support::toString<std::optional<bool>>(params.hasSubtitles()));
}
if (!params.hasSpecialFeatureNull()) {
result.addQueryItem("hasSpecialFeature", Support::toString(params.hasSpecialFeature()));
result.addQueryItem("hasSpecialFeature", Support::toString<std::optional<bool>>(params.hasSpecialFeature()));
}
if (!params.hasTrailerNull()) {
result.addQueryItem("hasTrailer", Support::toString(params.hasTrailer()));
result.addQueryItem("hasTrailer", Support::toString<std::optional<bool>>(params.hasTrailer()));
}
if (!params.adjacentToNull()) {
result.addQueryItem("adjacentTo", Support::toString(params.adjacentTo()));
result.addQueryItem("adjacentTo", Support::toString<QString>(params.adjacentTo()));
}
if (!params.parentIndexNumberNull()) {
result.addQueryItem("parentIndexNumber", Support::toString(params.parentIndexNumber()));
result.addQueryItem("parentIndexNumber", Support::toString<std::optional<qint32>>(params.parentIndexNumber()));
}
if (!params.hasParentalRatingNull()) {
result.addQueryItem("hasParentalRating", Support::toString(params.hasParentalRating()));
result.addQueryItem("hasParentalRating", Support::toString<std::optional<bool>>(params.hasParentalRating()));
}
if (!params.isHdNull()) {
result.addQueryItem("isHd", Support::toString(params.isHd()));
result.addQueryItem("isHd", Support::toString<std::optional<bool>>(params.isHd()));
}
if (!params.is4KNull()) {
result.addQueryItem("is4K", Support::toString(params.is4K()));
result.addQueryItem("is4K", Support::toString<std::optional<bool>>(params.is4K()));
}
if (!params.locationTypesNull()) {
result.addQueryItem("locationTypes", Support::toString(params.locationTypes()));
result.addQueryItem("locationTypes", Support::toString<QList<LocationType>>(params.locationTypes()));
}
if (!params.excludeLocationTypesNull()) {
result.addQueryItem("excludeLocationTypes", Support::toString(params.excludeLocationTypes()));
result.addQueryItem("excludeLocationTypes", Support::toString<QList<LocationType>>(params.excludeLocationTypes()));
}
if (!params.isMissingNull()) {
result.addQueryItem("isMissing", Support::toString(params.isMissing()));
result.addQueryItem("isMissing", Support::toString<std::optional<bool>>(params.isMissing()));
}
if (!params.isUnairedNull()) {
result.addQueryItem("isUnaired", Support::toString(params.isUnaired()));
result.addQueryItem("isUnaired", Support::toString<std::optional<bool>>(params.isUnaired()));
}
if (!params.minCommunityRatingNull()) {
result.addQueryItem("minCommunityRating", Support::toString(params.minCommunityRating()));
result.addQueryItem("minCommunityRating", Support::toString<std::optional<double>>(params.minCommunityRating()));
}
if (!params.minCriticRatingNull()) {
result.addQueryItem("minCriticRating", Support::toString(params.minCriticRating()));
result.addQueryItem("minCriticRating", Support::toString<std::optional<double>>(params.minCriticRating()));
}
if (!params.minPremiereDateNull()) {
result.addQueryItem("minPremiereDate", Support::toString(params.minPremiereDate()));
result.addQueryItem("minPremiereDate", Support::toString<QDateTime>(params.minPremiereDate()));
}
if (!params.minDateLastSavedNull()) {
result.addQueryItem("minDateLastSaved", Support::toString(params.minDateLastSaved()));
result.addQueryItem("minDateLastSaved", Support::toString<QDateTime>(params.minDateLastSaved()));
}
if (!params.minDateLastSavedForUserNull()) {
result.addQueryItem("minDateLastSavedForUser", Support::toString(params.minDateLastSavedForUser()));
result.addQueryItem("minDateLastSavedForUser", Support::toString<QDateTime>(params.minDateLastSavedForUser()));
}
if (!params.maxPremiereDateNull()) {
result.addQueryItem("maxPremiereDate", Support::toString(params.maxPremiereDate()));
result.addQueryItem("maxPremiereDate", Support::toString<QDateTime>(params.maxPremiereDate()));
}
if (!params.hasOverviewNull()) {
result.addQueryItem("hasOverview", Support::toString(params.hasOverview()));
result.addQueryItem("hasOverview", Support::toString<std::optional<bool>>(params.hasOverview()));
}
if (!params.hasImdbIdNull()) {
result.addQueryItem("hasImdbId", Support::toString(params.hasImdbId()));
result.addQueryItem("hasImdbId", Support::toString<std::optional<bool>>(params.hasImdbId()));
}
if (!params.hasTmdbIdNull()) {
result.addQueryItem("hasTmdbId", Support::toString(params.hasTmdbId()));
result.addQueryItem("hasTmdbId", Support::toString<std::optional<bool>>(params.hasTmdbId()));
}
if (!params.hasTvdbIdNull()) {
result.addQueryItem("hasTvdbId", Support::toString(params.hasTvdbId()));
result.addQueryItem("hasTvdbId", Support::toString<std::optional<bool>>(params.hasTvdbId()));
}
if (!params.excludeItemIdsNull()) {
result.addQueryItem("excludeItemIds", Support::toString(params.excludeItemIds()));
result.addQueryItem("excludeItemIds", Support::toString<QStringList>(params.excludeItemIds()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.recursiveNull()) {
result.addQueryItem("recursive", Support::toString(params.recursive()));
result.addQueryItem("recursive", Support::toString<std::optional<bool>>(params.recursive()));
}
if (!params.searchTermNull()) {
result.addQueryItem("searchTerm", Support::toString(params.searchTerm()));
result.addQueryItem("searchTerm", Support::toString<QString>(params.searchTerm()));
}
if (!params.sortOrderNull()) {
result.addQueryItem("sortOrder", Support::toString(params.sortOrder()));
result.addQueryItem("sortOrder", Support::toString<QString>(params.sortOrder()));
}
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString(params.parentId()));
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.excludeItemTypesNull()) {
result.addQueryItem("excludeItemTypes", Support::toString(params.excludeItemTypes()));
result.addQueryItem("excludeItemTypes", Support::toString<QStringList>(params.excludeItemTypes()));
}
if (!params.includeItemTypesNull()) {
result.addQueryItem("includeItemTypes", Support::toString(params.includeItemTypes()));
result.addQueryItem("includeItemTypes", Support::toString<QStringList>(params.includeItemTypes()));
}
if (!params.filtersNull()) {
result.addQueryItem("filters", Support::toString(params.filters()));
result.addQueryItem("filters", Support::toString<QList<ItemFilter>>(params.filters()));
}
if (!params.isFavoriteNull()) {
result.addQueryItem("isFavorite", Support::toString(params.isFavorite()));
result.addQueryItem("isFavorite", Support::toString<std::optional<bool>>(params.isFavorite()));
}
if (!params.mediaTypesNull()) {
result.addQueryItem("mediaTypes", Support::toString(params.mediaTypes()));
result.addQueryItem("mediaTypes", Support::toString<QStringList>(params.mediaTypes()));
}
if (!params.imageTypesNull()) {
result.addQueryItem("imageTypes", Support::toString(params.imageTypes()));
result.addQueryItem("imageTypes", Support::toString<QList<ImageType>>(params.imageTypes()));
}
if (!params.sortByNull()) {
result.addQueryItem("sortBy", Support::toString(params.sortBy()));
result.addQueryItem("sortBy", Support::toString<QString>(params.sortBy()));
}
if (!params.isPlayedNull()) {
result.addQueryItem("isPlayed", Support::toString(params.isPlayed()));
result.addQueryItem("isPlayed", Support::toString<std::optional<bool>>(params.isPlayed()));
}
if (!params.genresNull()) {
result.addQueryItem("genres", Support::toString(params.genres()));
result.addQueryItem("genres", Support::toString<QStringList>(params.genres()));
}
if (!params.officialRatingsNull()) {
result.addQueryItem("officialRatings", Support::toString(params.officialRatings()));
result.addQueryItem("officialRatings", Support::toString<QStringList>(params.officialRatings()));
}
if (!params.tagsNull()) {
result.addQueryItem("tags", Support::toString(params.tags()));
result.addQueryItem("tags", Support::toString<QStringList>(params.tags()));
}
if (!params.yearsNull()) {
result.addQueryItem("years", Support::toString(params.years()));
result.addQueryItem("years", Support::toString<QList<qint32>>(params.years()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.personNull()) {
result.addQueryItem("person", Support::toString(params.person()));
result.addQueryItem("person", Support::toString<QString>(params.person()));
}
if (!params.personIdsNull()) {
result.addQueryItem("personIds", Support::toString(params.personIds()));
result.addQueryItem("personIds", Support::toString<QStringList>(params.personIds()));
}
if (!params.personTypesNull()) {
result.addQueryItem("personTypes", Support::toString(params.personTypes()));
result.addQueryItem("personTypes", Support::toString<QStringList>(params.personTypes()));
}
if (!params.studiosNull()) {
result.addQueryItem("studios", Support::toString(params.studios()));
result.addQueryItem("studios", Support::toString<QStringList>(params.studios()));
}
if (!params.artistsNull()) {
result.addQueryItem("artists", Support::toString(params.artists()));
result.addQueryItem("artists", Support::toString<QStringList>(params.artists()));
}
if (!params.excludeArtistIdsNull()) {
result.addQueryItem("excludeArtistIds", Support::toString(params.excludeArtistIds()));
result.addQueryItem("excludeArtistIds", Support::toString<QStringList>(params.excludeArtistIds()));
}
if (!params.artistIdsNull()) {
result.addQueryItem("artistIds", Support::toString(params.artistIds()));
result.addQueryItem("artistIds", Support::toString<QStringList>(params.artistIds()));
}
if (!params.albumArtistIdsNull()) {
result.addQueryItem("albumArtistIds", Support::toString(params.albumArtistIds()));
result.addQueryItem("albumArtistIds", Support::toString<QStringList>(params.albumArtistIds()));
}
if (!params.contributingArtistIdsNull()) {
result.addQueryItem("contributingArtistIds", Support::toString(params.contributingArtistIds()));
result.addQueryItem("contributingArtistIds", Support::toString<QStringList>(params.contributingArtistIds()));
}
if (!params.albumsNull()) {
result.addQueryItem("albums", Support::toString(params.albums()));
result.addQueryItem("albums", Support::toString<QStringList>(params.albums()));
}
if (!params.albumIdsNull()) {
result.addQueryItem("albumIds", Support::toString(params.albumIds()));
result.addQueryItem("albumIds", Support::toString<QStringList>(params.albumIds()));
}
if (!params.idsNull()) {
result.addQueryItem("ids", Support::toString(params.ids()));
result.addQueryItem("ids", Support::toString<QStringList>(params.ids()));
}
if (!params.videoTypesNull()) {
result.addQueryItem("videoTypes", Support::toString(params.videoTypes()));
result.addQueryItem("videoTypes", Support::toString<QList<VideoType>>(params.videoTypes()));
}
if (!params.minOfficialRatingNull()) {
result.addQueryItem("minOfficialRating", Support::toString(params.minOfficialRating()));
result.addQueryItem("minOfficialRating", Support::toString<QString>(params.minOfficialRating()));
}
if (!params.isLockedNull()) {
result.addQueryItem("isLocked", Support::toString(params.isLocked()));
result.addQueryItem("isLocked", Support::toString<std::optional<bool>>(params.isLocked()));
}
if (!params.isPlaceHolderNull()) {
result.addQueryItem("isPlaceHolder", Support::toString(params.isPlaceHolder()));
result.addQueryItem("isPlaceHolder", Support::toString<std::optional<bool>>(params.isPlaceHolder()));
}
if (!params.hasOfficialRatingNull()) {
result.addQueryItem("hasOfficialRating", Support::toString(params.hasOfficialRating()));
result.addQueryItem("hasOfficialRating", Support::toString<std::optional<bool>>(params.hasOfficialRating()));
}
if (!params.collapseBoxSetItemsNull()) {
result.addQueryItem("collapseBoxSetItems", Support::toString(params.collapseBoxSetItems()));
result.addQueryItem("collapseBoxSetItems", Support::toString<std::optional<bool>>(params.collapseBoxSetItems()));
}
if (!params.minWidthNull()) {
result.addQueryItem("minWidth", Support::toString(params.minWidth()));
result.addQueryItem("minWidth", Support::toString<std::optional<qint32>>(params.minWidth()));
}
if (!params.minHeightNull()) {
result.addQueryItem("minHeight", Support::toString(params.minHeight()));
result.addQueryItem("minHeight", Support::toString<std::optional<qint32>>(params.minHeight()));
}
if (!params.maxWidthNull()) {
result.addQueryItem("maxWidth", Support::toString(params.maxWidth()));
result.addQueryItem("maxWidth", Support::toString<std::optional<qint32>>(params.maxWidth()));
}
if (!params.maxHeightNull()) {
result.addQueryItem("maxHeight", Support::toString(params.maxHeight()));
result.addQueryItem("maxHeight", Support::toString<std::optional<qint32>>(params.maxHeight()));
}
if (!params.is3DNull()) {
result.addQueryItem("is3D", Support::toString(params.is3D()));
result.addQueryItem("is3D", Support::toString<std::optional<bool>>(params.is3D()));
}
if (!params.seriesStatusNull()) {
result.addQueryItem("seriesStatus", Support::toString(params.seriesStatus()));
result.addQueryItem("seriesStatus", Support::toString<QList<SeriesStatus>>(params.seriesStatus()));
}
if (!params.nameStartsWithOrGreaterNull()) {
result.addQueryItem("nameStartsWithOrGreater", Support::toString(params.nameStartsWithOrGreater()));
result.addQueryItem("nameStartsWithOrGreater", Support::toString<QString>(params.nameStartsWithOrGreater()));
}
if (!params.nameStartsWithNull()) {
result.addQueryItem("nameStartsWith", Support::toString(params.nameStartsWith()));
result.addQueryItem("nameStartsWith", Support::toString<QString>(params.nameStartsWith()));
}
if (!params.nameLessThanNull()) {
result.addQueryItem("nameLessThan", Support::toString(params.nameLessThan()));
result.addQueryItem("nameLessThan", Support::toString<QString>(params.nameLessThan()));
}
if (!params.studioIdsNull()) {
result.addQueryItem("studioIds", Support::toString(params.studioIds()));
result.addQueryItem("studioIds", Support::toString<QStringList>(params.studioIds()));
}
if (!params.genreIdsNull()) {
result.addQueryItem("genreIds", Support::toString(params.genreIds()));
result.addQueryItem("genreIds", Support::toString<QStringList>(params.genreIds()));
}
if (!params.enableTotalRecordCountNull()) {
result.addQueryItem("enableTotalRecordCount", Support::toString(params.enableTotalRecordCount()));
result.addQueryItem("enableTotalRecordCount", Support::toString<std::optional<bool>>(params.enableTotalRecordCount()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetKeysLoader::GetKeysLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::AuthenticationInfoQueryResult, GetKeysParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<AuthenticationInfoQueryResult, GetKeysParams>(apiClient) {}
QString GetKeysLoader::path(const GetKeysParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetLatestChannelItemsLoader::GetLatestChannelItemsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetLatestChannelItemsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetLatestChannelItemsParams>(apiClient) {}
QString GetLatestChannelItemsLoader::path(const GetLatestChannelItemsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,22 +51,22 @@ QUrlQuery GetLatestChannelItemsLoader::query(const GetLatestChannelItemsParams &
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.filtersNull()) {
result.addQueryItem("filters", Support::toString(params.filters()));
result.addQueryItem("filters", Support::toString<QList<ItemFilter>>(params.filters()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.channelIdsNull()) {
result.addQueryItem("channelIds", Support::toString(params.channelIds()));
result.addQueryItem("channelIds", Support::toString<QStringList>(params.channelIds()));
}
return result;

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

@ -34,6 +34,56 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetLatestMediaLoader::GetLatestMediaLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<BaseItemDto>, GetLatestMediaParams>(apiClient) {}
QString GetLatestMediaLoader::path(const GetLatestMediaParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Users/") + Support::toString< QString>(params.userId()) + QStringLiteral("/Items/Latest");
}
QUrlQuery GetLatestMediaLoader::query(const GetLatestMediaParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.includeItemTypesNull()) {
result.addQueryItem("includeItemTypes", Support::toString<QStringList>(params.includeItemTypes()));
}
if (!params.isPlayedNull()) {
result.addQueryItem("isPlayed", Support::toString<std::optional<bool>>(params.isPlayed()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.groupItemsNull()) {
result.addQueryItem("groupItems", Support::toString<std::optional<bool>>(params.groupItems()));
}
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetLibraryOptionsInfoLoader::GetLibraryOptionsInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::LibraryOptionsResultDto, GetLibraryOptionsInfoParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<LibraryOptionsResultDto, GetLibraryOptionsInfoParams>(apiClient) {}
QString GetLibraryOptionsInfoLoader::path(const GetLibraryOptionsInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,10 +51,10 @@ QUrlQuery GetLibraryOptionsInfoLoader::query(const GetLibraryOptionsInfoParams &
// Optional parameters
if (!params.libraryContentTypeNull()) {
result.addQueryItem("libraryContentType", Support::toString(params.libraryContentType()));
result.addQueryItem("libraryContentType", Support::toString<QString>(params.libraryContentType()));
}
if (!params.isNewLibraryNull()) {
result.addQueryItem("isNewLibrary", Support::toString(params.isNewLibrary()));
result.addQueryItem("isNewLibrary", Support::toString<std::optional<bool>>(params.isNewLibrary()));
}
return result;

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

@ -34,6 +34,38 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetLineupsLoader::GetLineupsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<NameIdPair>, GetLineupsParams>(apiClient) {}
QString GetLineupsLoader::path(const GetLineupsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/LiveTv/ListingProviders/Lineups");
}
QUrlQuery GetLineupsLoader::query(const GetLineupsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.jellyfinIdNull()) {
result.addQueryItem("id", Support::toString<QString>(params.jellyfinId()));
}
if (!params.typeNull()) {
result.addQueryItem("type", Support::toString<QString>(params.type()));
}
if (!params.locationNull()) {
result.addQueryItem("location", Support::toString<QString>(params.location()));
}
if (!params.countryNull()) {
result.addQueryItem("country", Support::toString<QString>(params.country()));
}
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetLiveTvChannelsLoader::GetLiveTvChannelsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetLiveTvChannelsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetLiveTvChannelsParams>(apiClient) {}
QString GetLiveTvChannelsLoader::path(const GetLiveTvChannelsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,67 +51,67 @@ QUrlQuery GetLiveTvChannelsLoader::query(const GetLiveTvChannelsParams &params)
// Optional parameters
if (!params.typeNull()) {
result.addQueryItem("type", Support::toString(params.type()));
result.addQueryItem("type", Support::toString<ChannelType>(params.type()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.isMovieNull()) {
result.addQueryItem("isMovie", Support::toString(params.isMovie()));
result.addQueryItem("isMovie", Support::toString<std::optional<bool>>(params.isMovie()));
}
if (!params.isSeriesNull()) {
result.addQueryItem("isSeries", Support::toString(params.isSeries()));
result.addQueryItem("isSeries", Support::toString<std::optional<bool>>(params.isSeries()));
}
if (!params.isNewsNull()) {
result.addQueryItem("isNews", Support::toString(params.isNews()));
result.addQueryItem("isNews", Support::toString<std::optional<bool>>(params.isNews()));
}
if (!params.isKidsNull()) {
result.addQueryItem("isKids", Support::toString(params.isKids()));
result.addQueryItem("isKids", Support::toString<std::optional<bool>>(params.isKids()));
}
if (!params.isSportsNull()) {
result.addQueryItem("isSports", Support::toString(params.isSports()));
result.addQueryItem("isSports", Support::toString<std::optional<bool>>(params.isSports()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.isFavoriteNull()) {
result.addQueryItem("isFavorite", Support::toString(params.isFavorite()));
result.addQueryItem("isFavorite", Support::toString<std::optional<bool>>(params.isFavorite()));
}
if (!params.isLikedNull()) {
result.addQueryItem("isLiked", Support::toString(params.isLiked()));
result.addQueryItem("isLiked", Support::toString<std::optional<bool>>(params.isLiked()));
}
if (!params.isDislikedNull()) {
result.addQueryItem("isDisliked", Support::toString(params.isDisliked()));
result.addQueryItem("isDisliked", Support::toString<std::optional<bool>>(params.isDisliked()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.sortByNull()) {
result.addQueryItem("sortBy", Support::toString(params.sortBy()));
result.addQueryItem("sortBy", Support::toString<QStringList>(params.sortBy()));
}
if (!params.sortOrderNull()) {
result.addQueryItem("sortOrder", Support::toString(params.sortOrder()));
result.addQueryItem("sortOrder", Support::toString<SortOrder>(params.sortOrder()));
}
if (!params.enableFavoriteSortingNull()) {
result.addQueryItem("enableFavoriteSorting", Support::toString(params.enableFavoriteSorting()));
result.addQueryItem("enableFavoriteSorting", Support::toString<std::optional<bool>>(params.enableFavoriteSorting()));
}
if (!params.addCurrentProgramNull()) {
result.addQueryItem("addCurrentProgram", Support::toString(params.addCurrentProgram()));
result.addQueryItem("addCurrentProgram", Support::toString<std::optional<bool>>(params.addCurrentProgram()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetLiveTvInfoLoader::GetLiveTvInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::LiveTvInfo, GetLiveTvInfoParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<LiveTvInfo, GetLiveTvInfoParams>(apiClient) {}
QString GetLiveTvInfoLoader::path(const GetLiveTvInfoParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetLiveTvProgramsLoader::GetLiveTvProgramsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetLiveTvProgramsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetLiveTvProgramsParams>(apiClient) {}
QString GetLiveTvProgramsLoader::path(const GetLiveTvProgramsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,85 +51,85 @@ QUrlQuery GetLiveTvProgramsLoader::query(const GetLiveTvProgramsParams &params)
// Optional parameters
if (!params.channelIdsNull()) {
result.addQueryItem("channelIds", Support::toString(params.channelIds()));
result.addQueryItem("channelIds", Support::toString<QStringList>(params.channelIds()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.minStartDateNull()) {
result.addQueryItem("minStartDate", Support::toString(params.minStartDate()));
result.addQueryItem("minStartDate", Support::toString<QDateTime>(params.minStartDate()));
}
if (!params.hasAiredNull()) {
result.addQueryItem("hasAired", Support::toString(params.hasAired()));
result.addQueryItem("hasAired", Support::toString<std::optional<bool>>(params.hasAired()));
}
if (!params.isAiringNull()) {
result.addQueryItem("isAiring", Support::toString(params.isAiring()));
result.addQueryItem("isAiring", Support::toString<std::optional<bool>>(params.isAiring()));
}
if (!params.maxStartDateNull()) {
result.addQueryItem("maxStartDate", Support::toString(params.maxStartDate()));
result.addQueryItem("maxStartDate", Support::toString<QDateTime>(params.maxStartDate()));
}
if (!params.minEndDateNull()) {
result.addQueryItem("minEndDate", Support::toString(params.minEndDate()));
result.addQueryItem("minEndDate", Support::toString<QDateTime>(params.minEndDate()));
}
if (!params.maxEndDateNull()) {
result.addQueryItem("maxEndDate", Support::toString(params.maxEndDate()));
result.addQueryItem("maxEndDate", Support::toString<QDateTime>(params.maxEndDate()));
}
if (!params.isMovieNull()) {
result.addQueryItem("isMovie", Support::toString(params.isMovie()));
result.addQueryItem("isMovie", Support::toString<std::optional<bool>>(params.isMovie()));
}
if (!params.isSeriesNull()) {
result.addQueryItem("isSeries", Support::toString(params.isSeries()));
result.addQueryItem("isSeries", Support::toString<std::optional<bool>>(params.isSeries()));
}
if (!params.isNewsNull()) {
result.addQueryItem("isNews", Support::toString(params.isNews()));
result.addQueryItem("isNews", Support::toString<std::optional<bool>>(params.isNews()));
}
if (!params.isKidsNull()) {
result.addQueryItem("isKids", Support::toString(params.isKids()));
result.addQueryItem("isKids", Support::toString<std::optional<bool>>(params.isKids()));
}
if (!params.isSportsNull()) {
result.addQueryItem("isSports", Support::toString(params.isSports()));
result.addQueryItem("isSports", Support::toString<std::optional<bool>>(params.isSports()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.sortByNull()) {
result.addQueryItem("sortBy", Support::toString(params.sortBy()));
result.addQueryItem("sortBy", Support::toString<QString>(params.sortBy()));
}
if (!params.sortOrderNull()) {
result.addQueryItem("sortOrder", Support::toString(params.sortOrder()));
result.addQueryItem("sortOrder", Support::toString<QString>(params.sortOrder()));
}
if (!params.genresNull()) {
result.addQueryItem("genres", Support::toString(params.genres()));
result.addQueryItem("genres", Support::toString<QStringList>(params.genres()));
}
if (!params.genreIdsNull()) {
result.addQueryItem("genreIds", Support::toString(params.genreIds()));
result.addQueryItem("genreIds", Support::toString<QStringList>(params.genreIds()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.seriesTimerIdNull()) {
result.addQueryItem("seriesTimerId", Support::toString(params.seriesTimerId()));
result.addQueryItem("seriesTimerId", Support::toString<QString>(params.seriesTimerId()));
}
if (!params.librarySeriesIdNull()) {
result.addQueryItem("librarySeriesId", Support::toString(params.librarySeriesId()));
result.addQueryItem("librarySeriesId", Support::toString<QString>(params.librarySeriesId()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.enableTotalRecordCountNull()) {
result.addQueryItem("enableTotalRecordCount", Support::toString(params.enableTotalRecordCount()));
result.addQueryItem("enableTotalRecordCount", Support::toString<std::optional<bool>>(params.enableTotalRecordCount()));
}
return result;

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetLocalizationOptionsLoader::GetLocalizationOptionsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<LocalizationOption>, GetLocalizationOptionsParams>(apiClient) {}
QString GetLocalizationOptionsLoader::path(const GetLocalizationOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Localization/Options");
}
QUrlQuery GetLocalizationOptionsLoader::query(const GetLocalizationOptionsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

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

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetLogEntriesLoader::GetLogEntriesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::ActivityLogEntryQueryResult, GetLogEntriesParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<ActivityLogEntryQueryResult, GetLogEntriesParams>(apiClient) {}
QString GetLogEntriesLoader::path(const GetLogEntriesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,16 +51,16 @@ QUrlQuery GetLogEntriesLoader::query(const GetLogEntriesParams &params) const {
// Optional parameters
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.minDateNull()) {
result.addQueryItem("minDate", Support::toString(params.minDate()));
result.addQueryItem("minDate", Support::toString<QDateTime>(params.minDate()));
}
if (!params.hasUserIdNull()) {
result.addQueryItem("hasUserId", Support::toString(params.hasUserId()));
result.addQueryItem("hasUserId", Support::toString<std::optional<bool>>(params.hasUserId()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetMediaFoldersLoader::GetMediaFoldersLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetMediaFoldersParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetMediaFoldersParams>(apiClient) {}
QString GetMediaFoldersLoader::path(const GetMediaFoldersParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,7 +51,7 @@ QUrlQuery GetMediaFoldersLoader::query(const GetMediaFoldersParams &params) cons
// Optional parameters
if (!params.isHiddenNull()) {
result.addQueryItem("isHidden", Support::toString(params.isHidden()));
result.addQueryItem("isHidden", Support::toString<std::optional<bool>>(params.isHidden()));
}
return result;

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetMediaInfoImagesLoader::GetMediaInfoImagesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<ImageByNameInfo>, GetMediaInfoImagesParams>(apiClient) {}
QString GetMediaInfoImagesLoader::path(const GetMediaInfoImagesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Images/MediaInfo");
}
QUrlQuery GetMediaInfoImagesLoader::query(const GetMediaInfoImagesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetMetadataEditorInfoLoader::GetMetadataEditorInfoLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::MetadataEditorInfo, GetMetadataEditorInfoParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<MetadataEditorInfo, GetMetadataEditorInfoParams>(apiClient) {}
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");
return QStringLiteral("/Items/") + Support::toString< QString>(params.itemId()) + QStringLiteral("/MetadataEditor");
}
QUrlQuery GetMetadataEditorInfoLoader::query(const GetMetadataEditorInfoParams &params) const {

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

@ -34,6 +34,41 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetMovieRecommendationsLoader::GetMovieRecommendationsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RecommendationDto>, GetMovieRecommendationsParams>(apiClient) {}
QString GetMovieRecommendationsLoader::path(const GetMovieRecommendationsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Movies/Recommendations");
}
QUrlQuery GetMovieRecommendationsLoader::query(const GetMovieRecommendationsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.categoryLimitNull()) {
result.addQueryItem("categoryLimit", Support::toString<std::optional<qint32>>(params.categoryLimit()));
}
if (!params.itemLimitNull()) {
result.addQueryItem("itemLimit", Support::toString<std::optional<qint32>>(params.itemLimit()));
}
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetMovieRemoteSearchResultsLoader::GetMovieRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetMovieRemoteSearchResultsParams>(apiClient) {}
QString GetMovieRemoteSearchResultsLoader::path(const GetMovieRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/RemoteSearch/Movie");
}
QUrlQuery GetMovieRemoteSearchResultsLoader::query(const GetMovieRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetMusicAlbumRemoteSearchResultsLoader::GetMusicAlbumRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetMusicAlbumRemoteSearchResultsParams>(apiClient) {}
QString GetMusicAlbumRemoteSearchResultsLoader::path(const GetMusicAlbumRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/RemoteSearch/MusicAlbum");
}
QUrlQuery GetMusicAlbumRemoteSearchResultsLoader::query(const GetMusicAlbumRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetMusicArtistRemoteSearchResultsLoader::GetMusicArtistRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetMusicArtistRemoteSearchResultsParams>(apiClient) {}
QString GetMusicArtistRemoteSearchResultsLoader::path(const GetMusicArtistRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/RemoteSearch/MusicArtist");
}
QUrlQuery GetMusicArtistRemoteSearchResultsLoader::query(const GetMusicArtistRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetMusicGenreLoader::GetMusicGenreLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDto, GetMusicGenreParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDto, GetMusicGenreParams>(apiClient) {}
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()) ;
return QStringLiteral("/MusicGenres/") + Support::toString< QString>(params.genreName()) ;
}
QUrlQuery GetMusicGenreLoader::query(const GetMusicGenreParams &params) const {
@ -50,7 +51,7 @@ QUrlQuery GetMusicGenreLoader::query(const GetMusicGenreParams &params) const {
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
return result;

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetMusicGenresLoader::GetMusicGenresLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetMusicGenresParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetMusicGenresParams>(apiClient) {}
QString GetMusicGenresLoader::path(const GetMusicGenresParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,52 +51,52 @@ QUrlQuery GetMusicGenresLoader::query(const GetMusicGenresParams &params) const
// Optional parameters
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.searchTermNull()) {
result.addQueryItem("searchTerm", Support::toString(params.searchTerm()));
result.addQueryItem("searchTerm", Support::toString<QString>(params.searchTerm()));
}
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString(params.parentId()));
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.excludeItemTypesNull()) {
result.addQueryItem("excludeItemTypes", Support::toString(params.excludeItemTypes()));
result.addQueryItem("excludeItemTypes", Support::toString<QStringList>(params.excludeItemTypes()));
}
if (!params.includeItemTypesNull()) {
result.addQueryItem("includeItemTypes", Support::toString(params.includeItemTypes()));
result.addQueryItem("includeItemTypes", Support::toString<QStringList>(params.includeItemTypes()));
}
if (!params.isFavoriteNull()) {
result.addQueryItem("isFavorite", Support::toString(params.isFavorite()));
result.addQueryItem("isFavorite", Support::toString<std::optional<bool>>(params.isFavorite()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.nameStartsWithOrGreaterNull()) {
result.addQueryItem("nameStartsWithOrGreater", Support::toString(params.nameStartsWithOrGreater()));
result.addQueryItem("nameStartsWithOrGreater", Support::toString<QString>(params.nameStartsWithOrGreater()));
}
if (!params.nameStartsWithNull()) {
result.addQueryItem("nameStartsWith", Support::toString(params.nameStartsWith()));
result.addQueryItem("nameStartsWith", Support::toString<QString>(params.nameStartsWith()));
}
if (!params.nameLessThanNull()) {
result.addQueryItem("nameLessThan", Support::toString(params.nameLessThan()));
result.addQueryItem("nameLessThan", Support::toString<QString>(params.nameLessThan()));
}
if (!params.enableImagesNull()) {
result.addQueryItem("enableImages", Support::toString(params.enableImages()));
result.addQueryItem("enableImages", Support::toString<std::optional<bool>>(params.enableImages()));
}
if (!params.enableTotalRecordCountNull()) {
result.addQueryItem("enableTotalRecordCount", Support::toString(params.enableTotalRecordCount()));
result.addQueryItem("enableTotalRecordCount", Support::toString<std::optional<bool>>(params.enableTotalRecordCount()));
}
return result;

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetMusicVideoRemoteSearchResultsLoader::GetMusicVideoRemoteSearchResultsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<RemoteSearchResult>, GetMusicVideoRemoteSearchResultsParams>(apiClient) {}
QString GetMusicVideoRemoteSearchResultsLoader::path(const GetMusicVideoRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Items/RemoteSearch/MusicVideo");
}
QUrlQuery GetMusicVideoRemoteSearchResultsLoader::query(const GetMusicVideoRemoteSearchResultsParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetNamedConfigurationLoader::GetNamedConfigurationLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QString, GetNamedConfigurationParams>(apiClient) {}
QString GetNamedConfigurationLoader::path(const GetNamedConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/System/Configuration/") + Support::toString< QString>(params.key()) ;
}
QUrlQuery GetNamedConfigurationLoader::query(const GetNamedConfigurationParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,6 +34,26 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetNetworkSharesLoader::GetNetworkSharesLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<QList<FileSystemEntryInfo>, GetNetworkSharesParams>(apiClient) {}
QString GetNetworkSharesLoader::path(const GetNetworkSharesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
return QStringLiteral("/Environment/NetworkShares");
}
QUrlQuery GetNetworkSharesLoader::query(const GetNetworkSharesParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
QUrlQuery result;
// Optional parameters
return result;
}
} // NS HTTP
} // NS Loader

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

@ -34,8 +34,9 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetNextUpLoader::GetNextUpLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::BaseItemDtoQueryResult, GetNextUpParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<BaseItemDtoQueryResult, GetNextUpParams>(apiClient) {}
QString GetNextUpLoader::path(const GetNextUpParams &params) const {
Q_UNUSED(params) // Might be overzealous, but I don't like theses kind of warnings
@ -50,40 +51,40 @@ QUrlQuery GetNextUpLoader::query(const GetNextUpParams &params) const {
// Optional parameters
if (!params.userIdNull()) {
result.addQueryItem("userId", Support::toString(params.userId()));
result.addQueryItem("userId", Support::toString<QString>(params.userId()));
}
if (!params.startIndexNull()) {
result.addQueryItem("startIndex", Support::toString(params.startIndex()));
result.addQueryItem("startIndex", Support::toString<std::optional<qint32>>(params.startIndex()));
}
if (!params.limitNull()) {
result.addQueryItem("limit", Support::toString(params.limit()));
result.addQueryItem("limit", Support::toString<std::optional<qint32>>(params.limit()));
}
if (!params.fieldsNull()) {
result.addQueryItem("fields", Support::toString(params.fields()));
result.addQueryItem("fields", Support::toString<QList<ItemFields>>(params.fields()));
}
if (!params.seriesIdNull()) {
result.addQueryItem("seriesId", Support::toString(params.seriesId()));
result.addQueryItem("seriesId", Support::toString<QString>(params.seriesId()));
}
if (!params.parentIdNull()) {
result.addQueryItem("parentId", Support::toString(params.parentId()));
result.addQueryItem("parentId", Support::toString<QString>(params.parentId()));
}
if (!params.enableImgesNull()) {
result.addQueryItem("enableImges", Support::toString(params.enableImges()));
result.addQueryItem("enableImges", Support::toString<std::optional<bool>>(params.enableImges()));
}
if (!params.imageTypeLimitNull()) {
result.addQueryItem("imageTypeLimit", Support::toString(params.imageTypeLimit()));
result.addQueryItem("imageTypeLimit", Support::toString<std::optional<qint32>>(params.imageTypeLimit()));
}
if (!params.enableImageTypesNull()) {
result.addQueryItem("enableImageTypes", Support::toString(params.enableImageTypes()));
result.addQueryItem("enableImageTypes", Support::toString<QList<ImageType>>(params.enableImageTypes()));
}
if (!params.enableUserDataNull()) {
result.addQueryItem("enableUserData", Support::toString(params.enableUserData()));
result.addQueryItem("enableUserData", Support::toString<std::optional<bool>>(params.enableUserData()));
}
if (!params.enableTotalRecordCountNull()) {
result.addQueryItem("enableTotalRecordCount", Support::toString(params.enableTotalRecordCount()));
result.addQueryItem("enableTotalRecordCount", Support::toString<std::optional<bool>>(params.enableTotalRecordCount()));
}
if (!params.disableFirstEpisodeNull()) {
result.addQueryItem("disableFirstEpisode", Support::toString(params.disableFirstEpisode()));
result.addQueryItem("disableFirstEpisode", Support::toString<std::optional<bool>>(params.disableFirstEpisode()));
}
return result;

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

@ -34,13 +34,14 @@ namespace Loader {
namespace HTTP {
using namespace Jellyfin::DTO;
GetNotificationsLoader::GetNotificationsLoader(ApiClient *apiClient)
: Jellyfin::Support::HttpLoader<Jellyfin::DTO::NotificationResultDto, GetNotificationsParams>(apiClient) {}
: Jellyfin::Support::HttpLoader<NotificationResultDto, GetNotificationsParams>(apiClient) {}
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()) ;
return QStringLiteral("/Notifications/") + Support::toString< QString>(params.userId()) ;
}
QUrlQuery GetNotificationsLoader::query(const GetNotificationsParams &params) const {

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