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

WIP: Reimplementation of ListModels.

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

8
core/src/dto/activitylogentryqueryresult.cpp
View file

@ -55,7 +55,7 @@ ActivityLogEntryQueryResult ActivityLogEntryQueryResult::fromJson(QJsonObject so
void ActivityLogEntryQueryResult::setFromJson(QJsonObject source) {
m_items = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ActivityLogEntry>>>(source["Items"]);
m_items = Jellyfin::Support::fromJsonValue<QList<ActivityLogEntry>>(source["Items"]);
m_totalRecordCount = Jellyfin::Support::fromJsonValue<qint32>(source["TotalRecordCount"]);
m_startIndex = Jellyfin::Support::fromJsonValue<qint32>(source["StartIndex"]);
@ -63,16 +63,16 @@ void ActivityLogEntryQueryResult::setFromJson(QJsonObject source) {
QJsonObject ActivityLogEntryQueryResult::toJson() {
QJsonObject result;
result["Items"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ActivityLogEntry>>>(m_items);
result["Items"] = Jellyfin::Support::toJsonValue<QList<ActivityLogEntry>>(m_items);
result["TotalRecordCount"] = Jellyfin::Support::toJsonValue<qint32>(m_totalRecordCount);
result["StartIndex"] = Jellyfin::Support::toJsonValue<qint32>(m_startIndex);
return result;
}
QList<QSharedPointer<ActivityLogEntry>> ActivityLogEntryQueryResult::items() const { return m_items; }
QList<ActivityLogEntry> ActivityLogEntryQueryResult::items() const { return m_items; }
void ActivityLogEntryQueryResult::setItems(QList<QSharedPointer<ActivityLogEntry>> newItems) {
void ActivityLogEntryQueryResult::setItems(QList<ActivityLogEntry> newItems) {
m_items = newItems;
}
bool ActivityLogEntryQueryResult::itemsNull() const {

8
core/src/dto/albuminfo.cpp
View file

@ -87,7 +87,7 @@ void AlbumInfo::setFromJson(QJsonObject source) {
m_isAutomated = Jellyfin::Support::fromJsonValue<bool>(source["IsAutomated"]);
m_albumArtists = Jellyfin::Support::fromJsonValue<QStringList>(source["AlbumArtists"]);
m_artistProviderIds = Jellyfin::Support::fromJsonValue<std::optional<QJsonObject>>(source["ArtistProviderIds"]);
m_songInfos = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<SongInfo>>>(source["SongInfos"]);
m_songInfos = Jellyfin::Support::fromJsonValue<QList<SongInfo>>(source["SongInfos"]);
}
@ -105,7 +105,7 @@ QJsonObject AlbumInfo::toJson() {
result["IsAutomated"] = Jellyfin::Support::toJsonValue<bool>(m_isAutomated);
result["AlbumArtists"] = Jellyfin::Support::toJsonValue<QStringList>(m_albumArtists);
result["ArtistProviderIds"] = Jellyfin::Support::toJsonValue<std::optional<QJsonObject>>(m_artistProviderIds);
result["SongInfos"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<SongInfo>>>(m_songInfos);
result["SongInfos"] = Jellyfin::Support::toJsonValue<QList<SongInfo>>(m_songInfos);
return result;
}
@ -259,9 +259,9 @@ void AlbumInfo::setArtistProviderIdsNull() {
m_artistProviderIds = std::nullopt;
}
QList<QSharedPointer<SongInfo>> AlbumInfo::songInfos() const { return m_songInfos; }
QList<SongInfo> AlbumInfo::songInfos() const { return m_songInfos; }
void AlbumInfo::setSongInfos(QList<QSharedPointer<SongInfo>> newSongInfos) {
void AlbumInfo::setSongInfos(QList<SongInfo> newSongInfos) {
m_songInfos = newSongInfos;
}
bool AlbumInfo::songInfosNull() const {

8
core/src/dto/artistinfo.cpp
View file

@ -81,7 +81,7 @@ void ArtistInfo::setFromJson(QJsonObject source) {
m_parentIndexNumber = Jellyfin::Support::fromJsonValue<std::optional<qint32>>(source["ParentIndexNumber"]);
m_premiereDate = Jellyfin::Support::fromJsonValue<QDateTime>(source["PremiereDate"]);
m_isAutomated = Jellyfin::Support::fromJsonValue<bool>(source["IsAutomated"]);
m_songInfos = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<SongInfo>>>(source["SongInfos"]);
m_songInfos = Jellyfin::Support::fromJsonValue<QList<SongInfo>>(source["SongInfos"]);
}
@ -97,7 +97,7 @@ QJsonObject ArtistInfo::toJson() {
result["ParentIndexNumber"] = Jellyfin::Support::toJsonValue<std::optional<qint32>>(m_parentIndexNumber);
result["PremiereDate"] = Jellyfin::Support::toJsonValue<QDateTime>(m_premiereDate);
result["IsAutomated"] = Jellyfin::Support::toJsonValue<bool>(m_isAutomated);
result["SongInfos"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<SongInfo>>>(m_songInfos);
result["SongInfos"] = Jellyfin::Support::toJsonValue<QList<SongInfo>>(m_songInfos);
return result;
}
@ -225,9 +225,9 @@ void ArtistInfo::setIsAutomated(bool newIsAutomated) {
m_isAutomated = newIsAutomated;
}
QList<QSharedPointer<SongInfo>> ArtistInfo::songInfos() const { return m_songInfos; }
QList<SongInfo> ArtistInfo::songInfos() const { return m_songInfos; }
void ArtistInfo::setSongInfos(QList<QSharedPointer<SongInfo>> newSongInfos) {
void ArtistInfo::setSongInfos(QList<SongInfo> newSongInfos) {
m_songInfos = newSongInfos;
}
bool ArtistInfo::songInfosNull() const {

8
core/src/dto/authenticationinfoqueryresult.cpp
View file

@ -55,7 +55,7 @@ AuthenticationInfoQueryResult AuthenticationInfoQueryResult::fromJson(QJsonObjec
void AuthenticationInfoQueryResult::setFromJson(QJsonObject source) {
m_items = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<AuthenticationInfo>>>(source["Items"]);
m_items = Jellyfin::Support::fromJsonValue<QList<AuthenticationInfo>>(source["Items"]);
m_totalRecordCount = Jellyfin::Support::fromJsonValue<qint32>(source["TotalRecordCount"]);
m_startIndex = Jellyfin::Support::fromJsonValue<qint32>(source["StartIndex"]);
@ -63,16 +63,16 @@ void AuthenticationInfoQueryResult::setFromJson(QJsonObject source) {
QJsonObject AuthenticationInfoQueryResult::toJson() {
QJsonObject result;
result["Items"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<AuthenticationInfo>>>(m_items);
result["Items"] = Jellyfin::Support::toJsonValue<QList<AuthenticationInfo>>(m_items);
result["TotalRecordCount"] = Jellyfin::Support::toJsonValue<qint32>(m_totalRecordCount);
result["StartIndex"] = Jellyfin::Support::toJsonValue<qint32>(m_startIndex);
return result;
}
QList<QSharedPointer<AuthenticationInfo>> AuthenticationInfoQueryResult::items() const { return m_items; }
QList<AuthenticationInfo> AuthenticationInfoQueryResult::items() const { return m_items; }
void AuthenticationInfoQueryResult::setItems(QList<QSharedPointer<AuthenticationInfo>> newItems) {
void AuthenticationInfoQueryResult::setItems(QList<AuthenticationInfo> newItems) {
m_items = newItems;
}
bool AuthenticationInfoQueryResult::itemsNull() const {

8
core/src/dto/baseitem.cpp
View file

@ -74,7 +74,7 @@ void BaseItem::setFromJson(QJsonObject source) {
m_size = Jellyfin::Support::fromJsonValue<std::optional<qint64>>(source["Size"]);
m_container = Jellyfin::Support::fromJsonValue<QString>(source["Container"]);
m_dateLastSaved = Jellyfin::Support::fromJsonValue<QDateTime>(source["DateLastSaved"]);
m_remoteTrailers = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<MediaUrl>>>(source["RemoteTrailers"]);
m_remoteTrailers = Jellyfin::Support::fromJsonValue<QList<MediaUrl>>(source["RemoteTrailers"]);
m_isHD = Jellyfin::Support::fromJsonValue<bool>(source["IsHD"]);
m_isShortcut = Jellyfin::Support::fromJsonValue<bool>(source["IsShortcut"]);
m_shortcutPath = Jellyfin::Support::fromJsonValue<QString>(source["ShortcutPath"]);
@ -90,7 +90,7 @@ QJsonObject BaseItem::toJson() {
result["Size"] = Jellyfin::Support::toJsonValue<std::optional<qint64>>(m_size);
result["Container"] = Jellyfin::Support::toJsonValue<QString>(m_container);
result["DateLastSaved"] = Jellyfin::Support::toJsonValue<QDateTime>(m_dateLastSaved);
result["RemoteTrailers"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<MediaUrl>>>(m_remoteTrailers);
result["RemoteTrailers"] = Jellyfin::Support::toJsonValue<QList<MediaUrl>>(m_remoteTrailers);
result["IsHD"] = Jellyfin::Support::toJsonValue<bool>(m_isHD);
result["IsShortcut"] = Jellyfin::Support::toJsonValue<bool>(m_isShortcut);
result["ShortcutPath"] = Jellyfin::Support::toJsonValue<QString>(m_shortcutPath);
@ -134,9 +134,9 @@ void BaseItem::setDateLastSaved(QDateTime newDateLastSaved) {
m_dateLastSaved = newDateLastSaved;
}
QList<QSharedPointer<MediaUrl>> BaseItem::remoteTrailers() const { return m_remoteTrailers; }
QList<MediaUrl> BaseItem::remoteTrailers() const { return m_remoteTrailers; }
void BaseItem::setRemoteTrailers(QList<QSharedPointer<MediaUrl>> newRemoteTrailers) {
void BaseItem::setRemoteTrailers(QList<MediaUrl> newRemoteTrailers) {
m_remoteTrailers = newRemoteTrailers;
}
bool BaseItem::remoteTrailersNull() const {

80
core/src/dto/baseitemdto.cpp
View file

@ -375,8 +375,8 @@ void BaseItemDto::setFromJson(QJsonObject source) {
m_forcedSortName = Jellyfin::Support::fromJsonValue<QString>(source["ForcedSortName"]);
m_video3DFormat = Jellyfin::Support::fromJsonValue<Video3DFormat>(source["Video3DFormat"]);
m_premiereDate = Jellyfin::Support::fromJsonValue<QDateTime>(source["PremiereDate"]);
m_externalUrls = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ExternalUrl>>>(source["ExternalUrls"]);
m_mediaSources = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<MediaSourceInfo>>>(source["MediaSources"]);
m_externalUrls = Jellyfin::Support::fromJsonValue<QList<ExternalUrl>>(source["ExternalUrls"]);
m_mediaSources = Jellyfin::Support::fromJsonValue<QList<MediaSourceInfo>>(source["MediaSources"]);
m_criticRating = Jellyfin::Support::fromJsonValue<std::optional<float>>(source["CriticRating"]);
m_productionLocations = Jellyfin::Support::fromJsonValue<QStringList>(source["ProductionLocations"]);
m_path = Jellyfin::Support::fromJsonValue<QString>(source["Path"]);
@ -400,15 +400,15 @@ void BaseItemDto::setFromJson(QJsonObject source) {
m_indexNumber = Jellyfin::Support::fromJsonValue<std::optional<qint32>>(source["IndexNumber"]);
m_indexNumberEnd = Jellyfin::Support::fromJsonValue<std::optional<qint32>>(source["IndexNumberEnd"]);
m_parentIndexNumber = Jellyfin::Support::fromJsonValue<std::optional<qint32>>(source["ParentIndexNumber"]);
m_remoteTrailers = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<MediaUrl>>>(source["RemoteTrailers"]);
m_remoteTrailers = Jellyfin::Support::fromJsonValue<QList<MediaUrl>>(source["RemoteTrailers"]);
m_providerIds = Jellyfin::Support::fromJsonValue<std::optional<QJsonObject>>(source["ProviderIds"]);
m_isHD = Jellyfin::Support::fromJsonValue<std::optional<bool>>(source["IsHD"]);
m_isFolder = Jellyfin::Support::fromJsonValue<std::optional<bool>>(source["IsFolder"]);
m_parentId = Jellyfin::Support::fromJsonValue<QString>(source["ParentId"]);
m_type = Jellyfin::Support::fromJsonValue<QString>(source["Type"]);
m_people = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<BaseItemPerson>>>(source["People"]);
m_studios = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NameGuidPair>>>(source["Studios"]);
m_genreItems = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NameGuidPair>>>(source["GenreItems"]);
m_people = Jellyfin::Support::fromJsonValue<QList<BaseItemPerson>>(source["People"]);
m_studios = Jellyfin::Support::fromJsonValue<QList<NameGuidPair>>(source["Studios"]);
m_genreItems = Jellyfin::Support::fromJsonValue<QList<NameGuidPair>>(source["GenreItems"]);
m_parentLogoItemId = Jellyfin::Support::fromJsonValue<QString>(source["ParentLogoItemId"]);
m_parentBackdropItemId = Jellyfin::Support::fromJsonValue<QString>(source["ParentBackdropItemId"]);
m_parentBackdropImageTags = Jellyfin::Support::fromJsonValue<QStringList>(source["ParentBackdropImageTags"]);
@ -427,7 +427,7 @@ void BaseItemDto::setFromJson(QJsonObject source) {
m_tags = Jellyfin::Support::fromJsonValue<QStringList>(source["Tags"]);
m_primaryImageAspectRatio = Jellyfin::Support::fromJsonValue<std::optional<double>>(source["PrimaryImageAspectRatio"]);
m_artists = Jellyfin::Support::fromJsonValue<QStringList>(source["Artists"]);
m_artistItems = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NameGuidPair>>>(source["ArtistItems"]);
m_artistItems = Jellyfin::Support::fromJsonValue<QList<NameGuidPair>>(source["ArtistItems"]);
m_album = Jellyfin::Support::fromJsonValue<QString>(source["Album"]);
m_collectionType = Jellyfin::Support::fromJsonValue<QString>(source["CollectionType"]);
m_displayOrder = Jellyfin::Support::fromJsonValue<QString>(source["DisplayOrder"]);
@ -435,9 +435,9 @@ void BaseItemDto::setFromJson(QJsonObject source) {
m_albumPrimaryImageTag = Jellyfin::Support::fromJsonValue<QString>(source["AlbumPrimaryImageTag"]);
m_seriesPrimaryImageTag = Jellyfin::Support::fromJsonValue<QString>(source["SeriesPrimaryImageTag"]);
m_albumArtist = Jellyfin::Support::fromJsonValue<QString>(source["AlbumArtist"]);
m_albumArtists = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NameGuidPair>>>(source["AlbumArtists"]);
m_albumArtists = Jellyfin::Support::fromJsonValue<QList<NameGuidPair>>(source["AlbumArtists"]);
m_seasonName = Jellyfin::Support::fromJsonValue<QString>(source["SeasonName"]);
m_mediaStreams = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<MediaStream>>>(source["MediaStreams"]);
m_mediaStreams = Jellyfin::Support::fromJsonValue<QList<MediaStream>>(source["MediaStreams"]);
m_videoType = Jellyfin::Support::fromJsonValue<VideoType>(source["VideoType"]);
m_partCount = Jellyfin::Support::fromJsonValue<std::optional<qint32>>(source["PartCount"]);
m_mediaSourceCount = Jellyfin::Support::fromJsonValue<std::optional<qint32>>(source["MediaSourceCount"]);
@ -454,7 +454,7 @@ void BaseItemDto::setFromJson(QJsonObject source) {
m_parentThumbImageTag = Jellyfin::Support::fromJsonValue<QString>(source["ParentThumbImageTag"]);
m_parentPrimaryImageItemId = Jellyfin::Support::fromJsonValue<QString>(source["ParentPrimaryImageItemId"]);
m_parentPrimaryImageTag = Jellyfin::Support::fromJsonValue<QString>(source["ParentPrimaryImageTag"]);
m_chapters = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ChapterInfo>>>(source["Chapters"]);
m_chapters = Jellyfin::Support::fromJsonValue<QList<ChapterInfo>>(source["Chapters"]);
m_locationType = Jellyfin::Support::fromJsonValue<LocationType>(source["LocationType"]);
m_isoType = Jellyfin::Support::fromJsonValue<IsoType>(source["IsoType"]);
m_mediaType = Jellyfin::Support::fromJsonValue<QString>(source["MediaType"]);
@ -531,8 +531,8 @@ QJsonObject BaseItemDto::toJson() {
result["ForcedSortName"] = Jellyfin::Support::toJsonValue<QString>(m_forcedSortName);
result["Video3DFormat"] = Jellyfin::Support::toJsonValue<Video3DFormat>(m_video3DFormat);
result["PremiereDate"] = Jellyfin::Support::toJsonValue<QDateTime>(m_premiereDate);
result["ExternalUrls"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ExternalUrl>>>(m_externalUrls);
result["MediaSources"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<MediaSourceInfo>>>(m_mediaSources);
result["ExternalUrls"] = Jellyfin::Support::toJsonValue<QList<ExternalUrl>>(m_externalUrls);
result["MediaSources"] = Jellyfin::Support::toJsonValue<QList<MediaSourceInfo>>(m_mediaSources);
result["CriticRating"] = Jellyfin::Support::toJsonValue<std::optional<float>>(m_criticRating);
result["ProductionLocations"] = Jellyfin::Support::toJsonValue<QStringList>(m_productionLocations);
result["Path"] = Jellyfin::Support::toJsonValue<QString>(m_path);
@ -556,15 +556,15 @@ QJsonObject BaseItemDto::toJson() {
result["IndexNumber"] = Jellyfin::Support::toJsonValue<std::optional<qint32>>(m_indexNumber);
result["IndexNumberEnd"] = Jellyfin::Support::toJsonValue<std::optional<qint32>>(m_indexNumberEnd);
result["ParentIndexNumber"] = Jellyfin::Support::toJsonValue<std::optional<qint32>>(m_parentIndexNumber);
result["RemoteTrailers"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<MediaUrl>>>(m_remoteTrailers);
result["RemoteTrailers"] = Jellyfin::Support::toJsonValue<QList<MediaUrl>>(m_remoteTrailers);
result["ProviderIds"] = Jellyfin::Support::toJsonValue<std::optional<QJsonObject>>(m_providerIds);
result["IsHD"] = Jellyfin::Support::toJsonValue<std::optional<bool>>(m_isHD);
result["IsFolder"] = Jellyfin::Support::toJsonValue<std::optional<bool>>(m_isFolder);
result["ParentId"] = Jellyfin::Support::toJsonValue<QString>(m_parentId);
result["Type"] = Jellyfin::Support::toJsonValue<QString>(m_type);
result["People"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<BaseItemPerson>>>(m_people);
result["Studios"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NameGuidPair>>>(m_studios);
result["GenreItems"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NameGuidPair>>>(m_genreItems);
result["People"] = Jellyfin::Support::toJsonValue<QList<BaseItemPerson>>(m_people);
result["Studios"] = Jellyfin::Support::toJsonValue<QList<NameGuidPair>>(m_studios);
result["GenreItems"] = Jellyfin::Support::toJsonValue<QList<NameGuidPair>>(m_genreItems);
result["ParentLogoItemId"] = Jellyfin::Support::toJsonValue<QString>(m_parentLogoItemId);
result["ParentBackdropItemId"] = Jellyfin::Support::toJsonValue<QString>(m_parentBackdropItemId);
result["ParentBackdropImageTags"] = Jellyfin::Support::toJsonValue<QStringList>(m_parentBackdropImageTags);
@ -583,7 +583,7 @@ QJsonObject BaseItemDto::toJson() {
result["Tags"] = Jellyfin::Support::toJsonValue<QStringList>(m_tags);
result["PrimaryImageAspectRatio"] = Jellyfin::Support::toJsonValue<std::optional<double>>(m_primaryImageAspectRatio);
result["Artists"] = Jellyfin::Support::toJsonValue<QStringList>(m_artists);
result["ArtistItems"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NameGuidPair>>>(m_artistItems);
result["ArtistItems"] = Jellyfin::Support::toJsonValue<QList<NameGuidPair>>(m_artistItems);
result["Album"] = Jellyfin::Support::toJsonValue<QString>(m_album);
result["CollectionType"] = Jellyfin::Support::toJsonValue<QString>(m_collectionType);
result["DisplayOrder"] = Jellyfin::Support::toJsonValue<QString>(m_displayOrder);
@ -591,9 +591,9 @@ QJsonObject BaseItemDto::toJson() {
result["AlbumPrimaryImageTag"] = Jellyfin::Support::toJsonValue<QString>(m_albumPrimaryImageTag);
result["SeriesPrimaryImageTag"] = Jellyfin::Support::toJsonValue<QString>(m_seriesPrimaryImageTag);
result["AlbumArtist"] = Jellyfin::Support::toJsonValue<QString>(m_albumArtist);
result["AlbumArtists"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NameGuidPair>>>(m_albumArtists);
result["AlbumArtists"] = Jellyfin::Support::toJsonValue<QList<NameGuidPair>>(m_albumArtists);
result["SeasonName"] = Jellyfin::Support::toJsonValue<QString>(m_seasonName);
result["MediaStreams"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<MediaStream>>>(m_mediaStreams);
result["MediaStreams"] = Jellyfin::Support::toJsonValue<QList<MediaStream>>(m_mediaStreams);
result["VideoType"] = Jellyfin::Support::toJsonValue<VideoType>(m_videoType);
result["PartCount"] = Jellyfin::Support::toJsonValue<std::optional<qint32>>(m_partCount);
result["MediaSourceCount"] = Jellyfin::Support::toJsonValue<std::optional<qint32>>(m_mediaSourceCount);
@ -610,7 +610,7 @@ QJsonObject BaseItemDto::toJson() {
result["ParentThumbImageTag"] = Jellyfin::Support::toJsonValue<QString>(m_parentThumbImageTag);
result["ParentPrimaryImageItemId"] = Jellyfin::Support::toJsonValue<QString>(m_parentPrimaryImageItemId);
result["ParentPrimaryImageTag"] = Jellyfin::Support::toJsonValue<QString>(m_parentPrimaryImageTag);
result["Chapters"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ChapterInfo>>>(m_chapters);
result["Chapters"] = Jellyfin::Support::toJsonValue<QList<ChapterInfo>>(m_chapters);
result["LocationType"] = Jellyfin::Support::toJsonValue<LocationType>(m_locationType);
result["IsoType"] = Jellyfin::Support::toJsonValue<IsoType>(m_isoType);
result["MediaType"] = Jellyfin::Support::toJsonValue<QString>(m_mediaType);
@ -960,9 +960,9 @@ void BaseItemDto::setPremiereDateNull() {
m_premiereDate= QDateTime();
}
QList<QSharedPointer<ExternalUrl>> BaseItemDto::externalUrls() const { return m_externalUrls; }
QList<ExternalUrl> BaseItemDto::externalUrls() const { return m_externalUrls; }
void BaseItemDto::setExternalUrls(QList<QSharedPointer<ExternalUrl>> newExternalUrls) {
void BaseItemDto::setExternalUrls(QList<ExternalUrl> newExternalUrls) {
m_externalUrls = newExternalUrls;
}
bool BaseItemDto::externalUrlsNull() const {
@ -973,9 +973,9 @@ void BaseItemDto::setExternalUrlsNull() {
m_externalUrls.clear();
}
QList<QSharedPointer<MediaSourceInfo>> BaseItemDto::mediaSources() const { return m_mediaSources; }
QList<MediaSourceInfo> BaseItemDto::mediaSources() const { return m_mediaSources; }
void BaseItemDto::setMediaSources(QList<QSharedPointer<MediaSourceInfo>> newMediaSources) {
void BaseItemDto::setMediaSources(QList<MediaSourceInfo> newMediaSources) {
m_mediaSources = newMediaSources;
}
bool BaseItemDto::mediaSourcesNull() const {
@ -1278,9 +1278,9 @@ void BaseItemDto::setParentIndexNumberNull() {
m_parentIndexNumber = std::nullopt;
}
QList<QSharedPointer<MediaUrl>> BaseItemDto::remoteTrailers() const { return m_remoteTrailers; }
QList<MediaUrl> BaseItemDto::remoteTrailers() const { return m_remoteTrailers; }
void BaseItemDto::setRemoteTrailers(QList<QSharedPointer<MediaUrl>> newRemoteTrailers) {
void BaseItemDto::setRemoteTrailers(QList<MediaUrl> newRemoteTrailers) {
m_remoteTrailers = newRemoteTrailers;
}
bool BaseItemDto::remoteTrailersNull() const {
@ -1356,9 +1356,9 @@ void BaseItemDto::setTypeNull() {
m_type.clear();
}
QList<QSharedPointer<BaseItemPerson>> BaseItemDto::people() const { return m_people; }
QList<BaseItemPerson> BaseItemDto::people() const { return m_people; }
void BaseItemDto::setPeople(QList<QSharedPointer<BaseItemPerson>> newPeople) {
void BaseItemDto::setPeople(QList<BaseItemPerson> newPeople) {
m_people = newPeople;
}
bool BaseItemDto::peopleNull() const {
@ -1369,9 +1369,9 @@ void BaseItemDto::setPeopleNull() {
m_people.clear();
}
QList<QSharedPointer<NameGuidPair>> BaseItemDto::studios() const { return m_studios; }
QList<NameGuidPair> BaseItemDto::studios() const { return m_studios; }
void BaseItemDto::setStudios(QList<QSharedPointer<NameGuidPair>> newStudios) {
void BaseItemDto::setStudios(QList<NameGuidPair> newStudios) {
m_studios = newStudios;
}
bool BaseItemDto::studiosNull() const {
@ -1382,9 +1382,9 @@ void BaseItemDto::setStudiosNull() {
m_studios.clear();
}
QList<QSharedPointer<NameGuidPair>> BaseItemDto::genreItems() const { return m_genreItems; }
QList<NameGuidPair> BaseItemDto::genreItems() const { return m_genreItems; }
void BaseItemDto::setGenreItems(QList<QSharedPointer<NameGuidPair>> newGenreItems) {
void BaseItemDto::setGenreItems(QList<NameGuidPair> newGenreItems) {
m_genreItems = newGenreItems;
}
bool BaseItemDto::genreItemsNull() const {
@ -1622,9 +1622,9 @@ void BaseItemDto::setArtistsNull() {
m_artists.clear();
}
QList<QSharedPointer<NameGuidPair>> BaseItemDto::artistItems() const { return m_artistItems; }
QList<NameGuidPair> BaseItemDto::artistItems() const { return m_artistItems; }
void BaseItemDto::setArtistItems(QList<QSharedPointer<NameGuidPair>> newArtistItems) {
void BaseItemDto::setArtistItems(QList<NameGuidPair> newArtistItems) {
m_artistItems = newArtistItems;
}
bool BaseItemDto::artistItemsNull() const {
@ -1726,9 +1726,9 @@ void BaseItemDto::setAlbumArtistNull() {
m_albumArtist.clear();
}
QList<QSharedPointer<NameGuidPair>> BaseItemDto::albumArtists() const { return m_albumArtists; }
QList<NameGuidPair> BaseItemDto::albumArtists() const { return m_albumArtists; }
void BaseItemDto::setAlbumArtists(QList<QSharedPointer<NameGuidPair>> newAlbumArtists) {
void BaseItemDto::setAlbumArtists(QList<NameGuidPair> newAlbumArtists) {
m_albumArtists = newAlbumArtists;
}
bool BaseItemDto::albumArtistsNull() const {
@ -1752,9 +1752,9 @@ void BaseItemDto::setSeasonNameNull() {
m_seasonName.clear();
}
QList<QSharedPointer<MediaStream>> BaseItemDto::mediaStreams() const { return m_mediaStreams; }
QList<MediaStream> BaseItemDto::mediaStreams() const { return m_mediaStreams; }
void BaseItemDto::setMediaStreams(QList<QSharedPointer<MediaStream>> newMediaStreams) {
void BaseItemDto::setMediaStreams(QList<MediaStream> newMediaStreams) {
m_mediaStreams = newMediaStreams;
}
bool BaseItemDto::mediaStreamsNull() const {
@ -1966,9 +1966,9 @@ void BaseItemDto::setParentPrimaryImageTagNull() {
m_parentPrimaryImageTag.clear();
}
QList<QSharedPointer<ChapterInfo>> BaseItemDto::chapters() const { return m_chapters; }
QList<ChapterInfo> BaseItemDto::chapters() const { return m_chapters; }
void BaseItemDto::setChapters(QList<QSharedPointer<ChapterInfo>> newChapters) {
void BaseItemDto::setChapters(QList<ChapterInfo> newChapters) {
m_chapters = newChapters;
}
bool BaseItemDto::chaptersNull() const {

8
core/src/dto/baseitemdtoqueryresult.cpp
View file

@ -55,7 +55,7 @@ BaseItemDtoQueryResult BaseItemDtoQueryResult::fromJson(QJsonObject source) {
void BaseItemDtoQueryResult::setFromJson(QJsonObject source) {
m_items = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<BaseItemDto>>>(source["Items"]);
m_items = Jellyfin::Support::fromJsonValue<QList<BaseItemDto>>(source["Items"]);
m_totalRecordCount = Jellyfin::Support::fromJsonValue<qint32>(source["TotalRecordCount"]);
m_startIndex = Jellyfin::Support::fromJsonValue<qint32>(source["StartIndex"]);
@ -63,16 +63,16 @@ void BaseItemDtoQueryResult::setFromJson(QJsonObject source) {
QJsonObject BaseItemDtoQueryResult::toJson() {
QJsonObject result;
result["Items"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<BaseItemDto>>>(m_items);
result["Items"] = Jellyfin::Support::toJsonValue<QList<BaseItemDto>>(m_items);
result["TotalRecordCount"] = Jellyfin::Support::toJsonValue<qint32>(m_totalRecordCount);
result["StartIndex"] = Jellyfin::Support::toJsonValue<qint32>(m_startIndex);
return result;
}
QList<QSharedPointer<BaseItemDto>> BaseItemDtoQueryResult::items() const { return m_items; }
QList<BaseItemDto> BaseItemDtoQueryResult::items() const { return m_items; }
void BaseItemDtoQueryResult::setItems(QList<QSharedPointer<BaseItemDto>> newItems) {
void BaseItemDtoQueryResult::setItems(QList<BaseItemDto> newItems) {
m_items = newItems;
}
bool BaseItemDtoQueryResult::itemsNull() const {

24
core/src/dto/channelmappingoptionsdto.cpp
View file

@ -57,26 +57,26 @@ ChannelMappingOptionsDto ChannelMappingOptionsDto::fromJson(QJsonObject source)
void ChannelMappingOptionsDto::setFromJson(QJsonObject source) {
m_tunerChannels = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<TunerChannelMapping>>>(source["TunerChannels"]);
m_providerChannels = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NameIdPair>>>(source["ProviderChannels"]);
m_mappings = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NameValuePair>>>(source["Mappings"]);
m_tunerChannels = Jellyfin::Support::fromJsonValue<QList<TunerChannelMapping>>(source["TunerChannels"]);
m_providerChannels = Jellyfin::Support::fromJsonValue<QList<NameIdPair>>(source["ProviderChannels"]);
m_mappings = Jellyfin::Support::fromJsonValue<QList<NameValuePair>>(source["Mappings"]);
m_providerName = Jellyfin::Support::fromJsonValue<QString>(source["ProviderName"]);
}
QJsonObject ChannelMappingOptionsDto::toJson() {
QJsonObject result;
result["TunerChannels"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<TunerChannelMapping>>>(m_tunerChannels);
result["ProviderChannels"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NameIdPair>>>(m_providerChannels);
result["Mappings"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NameValuePair>>>(m_mappings);
result["TunerChannels"] = Jellyfin::Support::toJsonValue<QList<TunerChannelMapping>>(m_tunerChannels);
result["ProviderChannels"] = Jellyfin::Support::toJsonValue<QList<NameIdPair>>(m_providerChannels);
result["Mappings"] = Jellyfin::Support::toJsonValue<QList<NameValuePair>>(m_mappings);
result["ProviderName"] = Jellyfin::Support::toJsonValue<QString>(m_providerName);
return result;
}
QList<QSharedPointer<TunerChannelMapping>> ChannelMappingOptionsDto::tunerChannels() const { return m_tunerChannels; }
QList<TunerChannelMapping> ChannelMappingOptionsDto::tunerChannels() const { return m_tunerChannels; }
void ChannelMappingOptionsDto::setTunerChannels(QList<QSharedPointer<TunerChannelMapping>> newTunerChannels) {
void ChannelMappingOptionsDto::setTunerChannels(QList<TunerChannelMapping> newTunerChannels) {
m_tunerChannels = newTunerChannels;
}
bool ChannelMappingOptionsDto::tunerChannelsNull() const {
@ -87,9 +87,9 @@ void ChannelMappingOptionsDto::setTunerChannelsNull() {
m_tunerChannels.clear();
}
QList<QSharedPointer<NameIdPair>> ChannelMappingOptionsDto::providerChannels() const { return m_providerChannels; }
QList<NameIdPair> ChannelMappingOptionsDto::providerChannels() const { return m_providerChannels; }
void ChannelMappingOptionsDto::setProviderChannels(QList<QSharedPointer<NameIdPair>> newProviderChannels) {
void ChannelMappingOptionsDto::setProviderChannels(QList<NameIdPair> newProviderChannels) {
m_providerChannels = newProviderChannels;
}
bool ChannelMappingOptionsDto::providerChannelsNull() const {
@ -100,9 +100,9 @@ void ChannelMappingOptionsDto::setProviderChannelsNull() {
m_providerChannels.clear();
}
QList<QSharedPointer<NameValuePair>> ChannelMappingOptionsDto::mappings() const { return m_mappings; }
QList<NameValuePair> ChannelMappingOptionsDto::mappings() const { return m_mappings; }
void ChannelMappingOptionsDto::setMappings(QList<QSharedPointer<NameValuePair>> newMappings) {
void ChannelMappingOptionsDto::setMappings(QList<NameValuePair> newMappings) {
m_mappings = newMappings;
}
bool ChannelMappingOptionsDto::mappingsNull() const {

16
core/src/dto/codecprofile.cpp
View file

@ -60,8 +60,8 @@ CodecProfile CodecProfile::fromJson(QJsonObject source) {
void CodecProfile::setFromJson(QJsonObject source) {
m_type = Jellyfin::Support::fromJsonValue<CodecType>(source["Type"]);
m_conditions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ProfileCondition>>>(source["Conditions"]);
m_applyConditions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ProfileCondition>>>(source["ApplyConditions"]);
m_conditions = Jellyfin::Support::fromJsonValue<QList<ProfileCondition>>(source["Conditions"]);
m_applyConditions = Jellyfin::Support::fromJsonValue<QList<ProfileCondition>>(source["ApplyConditions"]);
m_codec = Jellyfin::Support::fromJsonValue<QString>(source["Codec"]);
m_container = Jellyfin::Support::fromJsonValue<QString>(source["Container"]);
@ -70,8 +70,8 @@ void CodecProfile::setFromJson(QJsonObject source) {
QJsonObject CodecProfile::toJson() {
QJsonObject result;
result["Type"] = Jellyfin::Support::toJsonValue<CodecType>(m_type);
result["Conditions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ProfileCondition>>>(m_conditions);
result["ApplyConditions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ProfileCondition>>>(m_applyConditions);
result["Conditions"] = Jellyfin::Support::toJsonValue<QList<ProfileCondition>>(m_conditions);
result["ApplyConditions"] = Jellyfin::Support::toJsonValue<QList<ProfileCondition>>(m_applyConditions);
result["Codec"] = Jellyfin::Support::toJsonValue<QString>(m_codec);
result["Container"] = Jellyfin::Support::toJsonValue<QString>(m_container);
@ -84,9 +84,9 @@ void CodecProfile::setType(CodecType newType) {
m_type = newType;
}
QList<QSharedPointer<ProfileCondition>> CodecProfile::conditions() const { return m_conditions; }
QList<ProfileCondition> CodecProfile::conditions() const { return m_conditions; }
void CodecProfile::setConditions(QList<QSharedPointer<ProfileCondition>> newConditions) {
void CodecProfile::setConditions(QList<ProfileCondition> newConditions) {
m_conditions = newConditions;
}
bool CodecProfile::conditionsNull() const {
@ -97,9 +97,9 @@ void CodecProfile::setConditionsNull() {
m_conditions.clear();
}
QList<QSharedPointer<ProfileCondition>> CodecProfile::applyConditions() const { return m_applyConditions; }
QList<ProfileCondition> CodecProfile::applyConditions() const { return m_applyConditions; }
void CodecProfile::setApplyConditions(QList<QSharedPointer<ProfileCondition>> newApplyConditions) {
void CodecProfile::setApplyConditions(QList<ProfileCondition> newApplyConditions) {
m_applyConditions = newApplyConditions;
}
bool CodecProfile::applyConditionsNull() const {

8
core/src/dto/containerprofile.cpp
View file

@ -56,7 +56,7 @@ ContainerProfile ContainerProfile::fromJson(QJsonObject source) {
void ContainerProfile::setFromJson(QJsonObject source) {
m_type = Jellyfin::Support::fromJsonValue<DlnaProfileType>(source["Type"]);
m_conditions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ProfileCondition>>>(source["Conditions"]);
m_conditions = Jellyfin::Support::fromJsonValue<QList<ProfileCondition>>(source["Conditions"]);
m_container = Jellyfin::Support::fromJsonValue<QString>(source["Container"]);
}
@ -64,7 +64,7 @@ void ContainerProfile::setFromJson(QJsonObject source) {
QJsonObject ContainerProfile::toJson() {
QJsonObject result;
result["Type"] = Jellyfin::Support::toJsonValue<DlnaProfileType>(m_type);
result["Conditions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ProfileCondition>>>(m_conditions);
result["Conditions"] = Jellyfin::Support::toJsonValue<QList<ProfileCondition>>(m_conditions);
result["Container"] = Jellyfin::Support::toJsonValue<QString>(m_container);
return result;
@ -76,9 +76,9 @@ void ContainerProfile::setType(DlnaProfileType newType) {
m_type = newType;
}
QList<QSharedPointer<ProfileCondition>> ContainerProfile::conditions() const { return m_conditions; }
QList<ProfileCondition> ContainerProfile::conditions() const { return m_conditions; }
void ContainerProfile::setConditions(QList<QSharedPointer<ProfileCondition>> newConditions) {
void ContainerProfile::setConditions(QList<ProfileCondition> newConditions) {
m_conditions = newConditions;
}
bool ContainerProfile::conditionsNull() const {

8
core/src/dto/deviceidentification.cpp
View file

@ -75,7 +75,7 @@ void DeviceIdentification::setFromJson(QJsonObject source) {
m_modelUrl = Jellyfin::Support::fromJsonValue<QString>(source["ModelUrl"]);
m_manufacturer = Jellyfin::Support::fromJsonValue<QString>(source["Manufacturer"]);
m_manufacturerUrl = Jellyfin::Support::fromJsonValue<QString>(source["ManufacturerUrl"]);
m_headers = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<HttpHeaderInfo>>>(source["Headers"]);
m_headers = Jellyfin::Support::fromJsonValue<QList<HttpHeaderInfo>>(source["Headers"]);
}
@ -89,7 +89,7 @@ QJsonObject DeviceIdentification::toJson() {
result["ModelUrl"] = Jellyfin::Support::toJsonValue<QString>(m_modelUrl);
result["Manufacturer"] = Jellyfin::Support::toJsonValue<QString>(m_manufacturer);
result["ManufacturerUrl"] = Jellyfin::Support::toJsonValue<QString>(m_manufacturerUrl);
result["Headers"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<HttpHeaderInfo>>>(m_headers);
result["Headers"] = Jellyfin::Support::toJsonValue<QList<HttpHeaderInfo>>(m_headers);
return result;
}
@ -198,9 +198,9 @@ void DeviceIdentification::setManufacturerUrlNull() {
m_manufacturerUrl.clear();
}
QList<QSharedPointer<HttpHeaderInfo>> DeviceIdentification::headers() const { return m_headers; }
QList<HttpHeaderInfo> DeviceIdentification::headers() const { return m_headers; }
void DeviceIdentification::setHeaders(QList<QSharedPointer<HttpHeaderInfo>> newHeaders) {
void DeviceIdentification::setHeaders(QList<HttpHeaderInfo> newHeaders) {
m_headers = newHeaders;
}
bool DeviceIdentification::headersNull() const {

8
core/src/dto/deviceinfoqueryresult.cpp
View file

@ -55,7 +55,7 @@ DeviceInfoQueryResult DeviceInfoQueryResult::fromJson(QJsonObject source) {
void DeviceInfoQueryResult::setFromJson(QJsonObject source) {
m_items = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<DeviceInfo>>>(source["Items"]);
m_items = Jellyfin::Support::fromJsonValue<QList<DeviceInfo>>(source["Items"]);
m_totalRecordCount = Jellyfin::Support::fromJsonValue<qint32>(source["TotalRecordCount"]);
m_startIndex = Jellyfin::Support::fromJsonValue<qint32>(source["StartIndex"]);
@ -63,16 +63,16 @@ void DeviceInfoQueryResult::setFromJson(QJsonObject source) {
QJsonObject DeviceInfoQueryResult::toJson() {
QJsonObject result;
result["Items"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<DeviceInfo>>>(m_items);
result["Items"] = Jellyfin::Support::toJsonValue<QList<DeviceInfo>>(m_items);
result["TotalRecordCount"] = Jellyfin::Support::toJsonValue<qint32>(m_totalRecordCount);
result["StartIndex"] = Jellyfin::Support::toJsonValue<qint32>(m_startIndex);
return result;
}
QList<QSharedPointer<DeviceInfo>> DeviceInfoQueryResult::items() const { return m_items; }
QList<DeviceInfo> DeviceInfoQueryResult::items() const { return m_items; }
void DeviceInfoQueryResult::setItems(QList<QSharedPointer<DeviceInfo>> newItems) {
void DeviceInfoQueryResult::setItems(QList<DeviceInfo> newItems) {
m_items = newItems;
}
bool DeviceInfoQueryResult::itemsNull() const {

56
core/src/dto/deviceprofile.cpp
View file

@ -159,13 +159,13 @@ void DeviceProfile::setFromJson(QJsonObject source) {
m_requiresPlainFolders = Jellyfin::Support::fromJsonValue<bool>(source["RequiresPlainFolders"]);
m_enableMSMediaReceiverRegistrar = Jellyfin::Support::fromJsonValue<bool>(source["EnableMSMediaReceiverRegistrar"]);
m_ignoreTranscodeByteRangeRequests = Jellyfin::Support::fromJsonValue<bool>(source["IgnoreTranscodeByteRangeRequests"]);
m_xmlRootAttributes = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<XmlAttribute>>>(source["XmlRootAttributes"]);
m_directPlayProfiles = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<DirectPlayProfile>>>(source["DirectPlayProfiles"]);
m_transcodingProfiles = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<TranscodingProfile>>>(source["TranscodingProfiles"]);
m_containerProfiles = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ContainerProfile>>>(source["ContainerProfiles"]);
m_codecProfiles = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<CodecProfile>>>(source["CodecProfiles"]);
m_responseProfiles = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ResponseProfile>>>(source["ResponseProfiles"]);
m_subtitleProfiles = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<SubtitleProfile>>>(source["SubtitleProfiles"]);
m_xmlRootAttributes = Jellyfin::Support::fromJsonValue<QList<XmlAttribute>>(source["XmlRootAttributes"]);
m_directPlayProfiles = Jellyfin::Support::fromJsonValue<QList<DirectPlayProfile>>(source["DirectPlayProfiles"]);
m_transcodingProfiles = Jellyfin::Support::fromJsonValue<QList<TranscodingProfile>>(source["TranscodingProfiles"]);
m_containerProfiles = Jellyfin::Support::fromJsonValue<QList<ContainerProfile>>(source["ContainerProfiles"]);
m_codecProfiles = Jellyfin::Support::fromJsonValue<QList<CodecProfile>>(source["CodecProfiles"]);
m_responseProfiles = Jellyfin::Support::fromJsonValue<QList<ResponseProfile>>(source["ResponseProfiles"]);
m_subtitleProfiles = Jellyfin::Support::fromJsonValue<QList<SubtitleProfile>>(source["SubtitleProfiles"]);
}
@ -203,13 +203,13 @@ QJsonObject DeviceProfile::toJson() {
result["RequiresPlainFolders"] = Jellyfin::Support::toJsonValue<bool>(m_requiresPlainFolders);
result["EnableMSMediaReceiverRegistrar"] = Jellyfin::Support::toJsonValue<bool>(m_enableMSMediaReceiverRegistrar);
result["IgnoreTranscodeByteRangeRequests"] = Jellyfin::Support::toJsonValue<bool>(m_ignoreTranscodeByteRangeRequests);
result["XmlRootAttributes"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<XmlAttribute>>>(m_xmlRootAttributes);
result["DirectPlayProfiles"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<DirectPlayProfile>>>(m_directPlayProfiles);
result["TranscodingProfiles"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<TranscodingProfile>>>(m_transcodingProfiles);
result["ContainerProfiles"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ContainerProfile>>>(m_containerProfiles);
result["CodecProfiles"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<CodecProfile>>>(m_codecProfiles);
result["ResponseProfiles"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ResponseProfile>>>(m_responseProfiles);
result["SubtitleProfiles"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<SubtitleProfile>>>(m_subtitleProfiles);
result["XmlRootAttributes"] = Jellyfin::Support::toJsonValue<QList<XmlAttribute>>(m_xmlRootAttributes);
result["DirectPlayProfiles"] = Jellyfin::Support::toJsonValue<QList<DirectPlayProfile>>(m_directPlayProfiles);
result["TranscodingProfiles"] = Jellyfin::Support::toJsonValue<QList<TranscodingProfile>>(m_transcodingProfiles);
result["ContainerProfiles"] = Jellyfin::Support::toJsonValue<QList<ContainerProfile>>(m_containerProfiles);
result["CodecProfiles"] = Jellyfin::Support::toJsonValue<QList<CodecProfile>>(m_codecProfiles);
result["ResponseProfiles"] = Jellyfin::Support::toJsonValue<QList<ResponseProfile>>(m_responseProfiles);
result["SubtitleProfiles"] = Jellyfin::Support::toJsonValue<QList<SubtitleProfile>>(m_subtitleProfiles);
return result;
}
@ -553,9 +553,9 @@ void DeviceProfile::setIgnoreTranscodeByteRangeRequests(bool newIgnoreTranscodeB
m_ignoreTranscodeByteRangeRequests = newIgnoreTranscodeByteRangeRequests;
}
QList<QSharedPointer<XmlAttribute>> DeviceProfile::xmlRootAttributes() const { return m_xmlRootAttributes; }
QList<XmlAttribute> DeviceProfile::xmlRootAttributes() const { return m_xmlRootAttributes; }
void DeviceProfile::setXmlRootAttributes(QList<QSharedPointer<XmlAttribute>> newXmlRootAttributes) {
void DeviceProfile::setXmlRootAttributes(QList<XmlAttribute> newXmlRootAttributes) {
m_xmlRootAttributes = newXmlRootAttributes;
}
bool DeviceProfile::xmlRootAttributesNull() const {
@ -566,9 +566,9 @@ void DeviceProfile::setXmlRootAttributesNull() {
m_xmlRootAttributes.clear();
}
QList<QSharedPointer<DirectPlayProfile>> DeviceProfile::directPlayProfiles() const { return m_directPlayProfiles; }
QList<DirectPlayProfile> DeviceProfile::directPlayProfiles() const { return m_directPlayProfiles; }
void DeviceProfile::setDirectPlayProfiles(QList<QSharedPointer<DirectPlayProfile>> newDirectPlayProfiles) {
void DeviceProfile::setDirectPlayProfiles(QList<DirectPlayProfile> newDirectPlayProfiles) {
m_directPlayProfiles = newDirectPlayProfiles;
}
bool DeviceProfile::directPlayProfilesNull() const {
@ -579,9 +579,9 @@ void DeviceProfile::setDirectPlayProfilesNull() {
m_directPlayProfiles.clear();
}
QList<QSharedPointer<TranscodingProfile>> DeviceProfile::transcodingProfiles() const { return m_transcodingProfiles; }
QList<TranscodingProfile> DeviceProfile::transcodingProfiles() const { return m_transcodingProfiles; }
void DeviceProfile::setTranscodingProfiles(QList<QSharedPointer<TranscodingProfile>> newTranscodingProfiles) {
void DeviceProfile::setTranscodingProfiles(QList<TranscodingProfile> newTranscodingProfiles) {
m_transcodingProfiles = newTranscodingProfiles;
}
bool DeviceProfile::transcodingProfilesNull() const {
@ -592,9 +592,9 @@ void DeviceProfile::setTranscodingProfilesNull() {
m_transcodingProfiles.clear();
}
QList<QSharedPointer<ContainerProfile>> DeviceProfile::containerProfiles() const { return m_containerProfiles; }
QList<ContainerProfile> DeviceProfile::containerProfiles() const { return m_containerProfiles; }
void DeviceProfile::setContainerProfiles(QList<QSharedPointer<ContainerProfile>> newContainerProfiles) {
void DeviceProfile::setContainerProfiles(QList<ContainerProfile> newContainerProfiles) {
m_containerProfiles = newContainerProfiles;
}
bool DeviceProfile::containerProfilesNull() const {
@ -605,9 +605,9 @@ void DeviceProfile::setContainerProfilesNull() {
m_containerProfiles.clear();
}
QList<QSharedPointer<CodecProfile>> DeviceProfile::codecProfiles() const { return m_codecProfiles; }
QList<CodecProfile> DeviceProfile::codecProfiles() const { return m_codecProfiles; }
void DeviceProfile::setCodecProfiles(QList<QSharedPointer<CodecProfile>> newCodecProfiles) {
void DeviceProfile::setCodecProfiles(QList<CodecProfile> newCodecProfiles) {
m_codecProfiles = newCodecProfiles;
}
bool DeviceProfile::codecProfilesNull() const {
@ -618,9 +618,9 @@ void DeviceProfile::setCodecProfilesNull() {
m_codecProfiles.clear();
}
QList<QSharedPointer<ResponseProfile>> DeviceProfile::responseProfiles() const { return m_responseProfiles; }
QList<ResponseProfile> DeviceProfile::responseProfiles() const { return m_responseProfiles; }
void DeviceProfile::setResponseProfiles(QList<QSharedPointer<ResponseProfile>> newResponseProfiles) {
void DeviceProfile::setResponseProfiles(QList<ResponseProfile> newResponseProfiles) {
m_responseProfiles = newResponseProfiles;
}
bool DeviceProfile::responseProfilesNull() const {
@ -631,9 +631,9 @@ void DeviceProfile::setResponseProfilesNull() {
m_responseProfiles.clear();
}
QList<QSharedPointer<SubtitleProfile>> DeviceProfile::subtitleProfiles() const { return m_subtitleProfiles; }
QList<SubtitleProfile> DeviceProfile::subtitleProfiles() const { return m_subtitleProfiles; }
void DeviceProfile::setSubtitleProfiles(QList<QSharedPointer<SubtitleProfile>> newSubtitleProfiles) {
void DeviceProfile::setSubtitleProfiles(QList<SubtitleProfile> newSubtitleProfiles) {
m_subtitleProfiles = newSubtitleProfiles;
}
bool DeviceProfile::subtitleProfilesNull() const {

16
core/src/dto/libraryoptions.cpp
View file

@ -103,7 +103,7 @@ void LibraryOptions::setFromJson(QJsonObject source) {
m_enableRealtimeMonitor = Jellyfin::Support::fromJsonValue<bool>(source["EnableRealtimeMonitor"]);
m_enableChapterImageExtraction = Jellyfin::Support::fromJsonValue<bool>(source["EnableChapterImageExtraction"]);
m_extractChapterImagesDuringLibraryScan = Jellyfin::Support::fromJsonValue<bool>(source["ExtractChapterImagesDuringLibraryScan"]);
m_pathInfos = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<MediaPathInfo>>>(source["PathInfos"]);
m_pathInfos = Jellyfin::Support::fromJsonValue<QList<MediaPathInfo>>(source["PathInfos"]);
m_saveLocalMetadata = Jellyfin::Support::fromJsonValue<bool>(source["SaveLocalMetadata"]);
m_enableInternetProviders = Jellyfin::Support::fromJsonValue<bool>(source["EnableInternetProviders"]);
m_enableAutomaticSeriesGrouping = Jellyfin::Support::fromJsonValue<bool>(source["EnableAutomaticSeriesGrouping"]);
@ -123,7 +123,7 @@ void LibraryOptions::setFromJson(QJsonObject source) {
m_subtitleDownloadLanguages = Jellyfin::Support::fromJsonValue<QStringList>(source["SubtitleDownloadLanguages"]);
m_requirePerfectSubtitleMatch = Jellyfin::Support::fromJsonValue<bool>(source["RequirePerfectSubtitleMatch"]);
m_saveSubtitlesWithMedia = Jellyfin::Support::fromJsonValue<bool>(source["SaveSubtitlesWithMedia"]);
m_typeOptions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<TypeOptions>>>(source["TypeOptions"]);
m_typeOptions = Jellyfin::Support::fromJsonValue<QList<TypeOptions>>(source["TypeOptions"]);
}
@ -133,7 +133,7 @@ QJsonObject LibraryOptions::toJson() {
result["EnableRealtimeMonitor"] = Jellyfin::Support::toJsonValue<bool>(m_enableRealtimeMonitor);
result["EnableChapterImageExtraction"] = Jellyfin::Support::toJsonValue<bool>(m_enableChapterImageExtraction);
result["ExtractChapterImagesDuringLibraryScan"] = Jellyfin::Support::toJsonValue<bool>(m_extractChapterImagesDuringLibraryScan);
result["PathInfos"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<MediaPathInfo>>>(m_pathInfos);
result["PathInfos"] = Jellyfin::Support::toJsonValue<QList<MediaPathInfo>>(m_pathInfos);
result["SaveLocalMetadata"] = Jellyfin::Support::toJsonValue<bool>(m_saveLocalMetadata);
result["EnableInternetProviders"] = Jellyfin::Support::toJsonValue<bool>(m_enableInternetProviders);
result["EnableAutomaticSeriesGrouping"] = Jellyfin::Support::toJsonValue<bool>(m_enableAutomaticSeriesGrouping);
@ -153,7 +153,7 @@ QJsonObject LibraryOptions::toJson() {
result["SubtitleDownloadLanguages"] = Jellyfin::Support::toJsonValue<QStringList>(m_subtitleDownloadLanguages);
result["RequirePerfectSubtitleMatch"] = Jellyfin::Support::toJsonValue<bool>(m_requirePerfectSubtitleMatch);
result["SaveSubtitlesWithMedia"] = Jellyfin::Support::toJsonValue<bool>(m_saveSubtitlesWithMedia);
result["TypeOptions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<TypeOptions>>>(m_typeOptions);
result["TypeOptions"] = Jellyfin::Support::toJsonValue<QList<TypeOptions>>(m_typeOptions);
return result;
}
@ -182,9 +182,9 @@ void LibraryOptions::setExtractChapterImagesDuringLibraryScan(bool newExtractCha
m_extractChapterImagesDuringLibraryScan = newExtractChapterImagesDuringLibraryScan;
}
QList<QSharedPointer<MediaPathInfo>> LibraryOptions::pathInfos() const { return m_pathInfos; }
QList<MediaPathInfo> LibraryOptions::pathInfos() const { return m_pathInfos; }
void LibraryOptions::setPathInfos(QList<QSharedPointer<MediaPathInfo>> newPathInfos) {
void LibraryOptions::setPathInfos(QList<MediaPathInfo> newPathInfos) {
m_pathInfos = newPathInfos;
}
bool LibraryOptions::pathInfosNull() const {
@ -372,9 +372,9 @@ void LibraryOptions::setSaveSubtitlesWithMedia(bool newSaveSubtitlesWithMedia) {
m_saveSubtitlesWithMedia = newSaveSubtitlesWithMedia;
}
QList<QSharedPointer<TypeOptions>> LibraryOptions::typeOptions() const { return m_typeOptions; }
QList<TypeOptions> LibraryOptions::typeOptions() const { return m_typeOptions; }
void LibraryOptions::setTypeOptions(QList<QSharedPointer<TypeOptions>> newTypeOptions) {
void LibraryOptions::setTypeOptions(QList<TypeOptions> newTypeOptions) {
m_typeOptions = newTypeOptions;
}
bool LibraryOptions::typeOptionsNull() const {

32
core/src/dto/libraryoptionsresultdto.cpp
View file

@ -57,26 +57,26 @@ LibraryOptionsResultDto LibraryOptionsResultDto::fromJson(QJsonObject source) {
void LibraryOptionsResultDto::setFromJson(QJsonObject source) {
m_metadataSavers = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(source["MetadataSavers"]);
m_metadataReaders = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(source["MetadataReaders"]);
m_subtitleFetchers = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(source["SubtitleFetchers"]);
m_typeOptions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<LibraryTypeOptionsDto>>>(source["TypeOptions"]);
m_metadataSavers = Jellyfin::Support::fromJsonValue<QList<LibraryOptionInfoDto>>(source["MetadataSavers"]);
m_metadataReaders = Jellyfin::Support::fromJsonValue<QList<LibraryOptionInfoDto>>(source["MetadataReaders"]);
m_subtitleFetchers = Jellyfin::Support::fromJsonValue<QList<LibraryOptionInfoDto>>(source["SubtitleFetchers"]);
m_typeOptions = Jellyfin::Support::fromJsonValue<QList<LibraryTypeOptionsDto>>(source["TypeOptions"]);
}
QJsonObject LibraryOptionsResultDto::toJson() {
QJsonObject result;
result["MetadataSavers"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(m_metadataSavers);
result["MetadataReaders"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(m_metadataReaders);
result["SubtitleFetchers"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(m_subtitleFetchers);
result["TypeOptions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<LibraryTypeOptionsDto>>>(m_typeOptions);
result["MetadataSavers"] = Jellyfin::Support::toJsonValue<QList<LibraryOptionInfoDto>>(m_metadataSavers);
result["MetadataReaders"] = Jellyfin::Support::toJsonValue<QList<LibraryOptionInfoDto>>(m_metadataReaders);
result["SubtitleFetchers"] = Jellyfin::Support::toJsonValue<QList<LibraryOptionInfoDto>>(m_subtitleFetchers);
result["TypeOptions"] = Jellyfin::Support::toJsonValue<QList<LibraryTypeOptionsDto>>(m_typeOptions);
return result;
}
QList<QSharedPointer<LibraryOptionInfoDto>> LibraryOptionsResultDto::metadataSavers() const { return m_metadataSavers; }
QList<LibraryOptionInfoDto> LibraryOptionsResultDto::metadataSavers() const { return m_metadataSavers; }
void LibraryOptionsResultDto::setMetadataSavers(QList<QSharedPointer<LibraryOptionInfoDto>> newMetadataSavers) {
void LibraryOptionsResultDto::setMetadataSavers(QList<LibraryOptionInfoDto> newMetadataSavers) {
m_metadataSavers = newMetadataSavers;
}
bool LibraryOptionsResultDto::metadataSaversNull() const {
@ -87,9 +87,9 @@ void LibraryOptionsResultDto::setMetadataSaversNull() {
m_metadataSavers.clear();
}
QList<QSharedPointer<LibraryOptionInfoDto>> LibraryOptionsResultDto::metadataReaders() const { return m_metadataReaders; }
QList<LibraryOptionInfoDto> LibraryOptionsResultDto::metadataReaders() const { return m_metadataReaders; }
void LibraryOptionsResultDto::setMetadataReaders(QList<QSharedPointer<LibraryOptionInfoDto>> newMetadataReaders) {
void LibraryOptionsResultDto::setMetadataReaders(QList<LibraryOptionInfoDto> newMetadataReaders) {
m_metadataReaders = newMetadataReaders;
}
bool LibraryOptionsResultDto::metadataReadersNull() const {
@ -100,9 +100,9 @@ void LibraryOptionsResultDto::setMetadataReadersNull() {
m_metadataReaders.clear();
}
QList<QSharedPointer<LibraryOptionInfoDto>> LibraryOptionsResultDto::subtitleFetchers() const { return m_subtitleFetchers; }
QList<LibraryOptionInfoDto> LibraryOptionsResultDto::subtitleFetchers() const { return m_subtitleFetchers; }
void LibraryOptionsResultDto::setSubtitleFetchers(QList<QSharedPointer<LibraryOptionInfoDto>> newSubtitleFetchers) {
void LibraryOptionsResultDto::setSubtitleFetchers(QList<LibraryOptionInfoDto> newSubtitleFetchers) {
m_subtitleFetchers = newSubtitleFetchers;
}
bool LibraryOptionsResultDto::subtitleFetchersNull() const {
@ -113,9 +113,9 @@ void LibraryOptionsResultDto::setSubtitleFetchersNull() {
m_subtitleFetchers.clear();
}
QList<QSharedPointer<LibraryTypeOptionsDto>> LibraryOptionsResultDto::typeOptions() const { return m_typeOptions; }
QList<LibraryTypeOptionsDto> LibraryOptionsResultDto::typeOptions() const { return m_typeOptions; }
void LibraryOptionsResultDto::setTypeOptions(QList<QSharedPointer<LibraryTypeOptionsDto>> newTypeOptions) {
void LibraryOptionsResultDto::setTypeOptions(QList<LibraryTypeOptionsDto> newTypeOptions) {
m_typeOptions = newTypeOptions;
}
bool LibraryOptionsResultDto::typeOptionsNull() const {

24
core/src/dto/librarytypeoptionsdto.cpp
View file

@ -60,20 +60,20 @@ LibraryTypeOptionsDto LibraryTypeOptionsDto::fromJson(QJsonObject source) {
void LibraryTypeOptionsDto::setFromJson(QJsonObject source) {
m_type = Jellyfin::Support::fromJsonValue<QString>(source["Type"]);
m_metadataFetchers = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(source["MetadataFetchers"]);
m_imageFetchers = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(source["ImageFetchers"]);
m_metadataFetchers = Jellyfin::Support::fromJsonValue<QList<LibraryOptionInfoDto>>(source["MetadataFetchers"]);
m_imageFetchers = Jellyfin::Support::fromJsonValue<QList<LibraryOptionInfoDto>>(source["ImageFetchers"]);
m_supportedImageTypes = Jellyfin::Support::fromJsonValue<QList<ImageType>>(source["SupportedImageTypes"]);
m_defaultImageOptions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ImageOption>>>(source["DefaultImageOptions"]);
m_defaultImageOptions = Jellyfin::Support::fromJsonValue<QList<ImageOption>>(source["DefaultImageOptions"]);
}
QJsonObject LibraryTypeOptionsDto::toJson() {
QJsonObject result;
result["Type"] = Jellyfin::Support::toJsonValue<QString>(m_type);
result["MetadataFetchers"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(m_metadataFetchers);
result["ImageFetchers"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<LibraryOptionInfoDto>>>(m_imageFetchers);
result["MetadataFetchers"] = Jellyfin::Support::toJsonValue<QList<LibraryOptionInfoDto>>(m_metadataFetchers);
result["ImageFetchers"] = Jellyfin::Support::toJsonValue<QList<LibraryOptionInfoDto>>(m_imageFetchers);
result["SupportedImageTypes"] = Jellyfin::Support::toJsonValue<QList<ImageType>>(m_supportedImageTypes);
result["DefaultImageOptions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ImageOption>>>(m_defaultImageOptions);
result["DefaultImageOptions"] = Jellyfin::Support::toJsonValue<QList<ImageOption>>(m_defaultImageOptions);
return result;
}
@ -91,9 +91,9 @@ void LibraryTypeOptionsDto::setTypeNull() {
m_type.clear();
}
QList<QSharedPointer<LibraryOptionInfoDto>> LibraryTypeOptionsDto::metadataFetchers() const { return m_metadataFetchers; }
QList<LibraryOptionInfoDto> LibraryTypeOptionsDto::metadataFetchers() const { return m_metadataFetchers; }
void LibraryTypeOptionsDto::setMetadataFetchers(QList<QSharedPointer<LibraryOptionInfoDto>> newMetadataFetchers) {
void LibraryTypeOptionsDto::setMetadataFetchers(QList<LibraryOptionInfoDto> newMetadataFetchers) {
m_metadataFetchers = newMetadataFetchers;
}
bool LibraryTypeOptionsDto::metadataFetchersNull() const {
@ -104,9 +104,9 @@ void LibraryTypeOptionsDto::setMetadataFetchersNull() {
m_metadataFetchers.clear();
}
QList<QSharedPointer<LibraryOptionInfoDto>> LibraryTypeOptionsDto::imageFetchers() const { return m_imageFetchers; }
QList<LibraryOptionInfoDto> LibraryTypeOptionsDto::imageFetchers() const { return m_imageFetchers; }
void LibraryTypeOptionsDto::setImageFetchers(QList<QSharedPointer<LibraryOptionInfoDto>> newImageFetchers) {
void LibraryTypeOptionsDto::setImageFetchers(QList<LibraryOptionInfoDto> newImageFetchers) {
m_imageFetchers = newImageFetchers;
}
bool LibraryTypeOptionsDto::imageFetchersNull() const {
@ -130,9 +130,9 @@ void LibraryTypeOptionsDto::setSupportedImageTypesNull() {
m_supportedImageTypes.clear();
}
QList<QSharedPointer<ImageOption>> LibraryTypeOptionsDto::defaultImageOptions() const { return m_defaultImageOptions; }
QList<ImageOption> LibraryTypeOptionsDto::defaultImageOptions() const { return m_defaultImageOptions; }
void LibraryTypeOptionsDto::setDefaultImageOptions(QList<QSharedPointer<ImageOption>> newDefaultImageOptions) {
void LibraryTypeOptionsDto::setDefaultImageOptions(QList<ImageOption> newDefaultImageOptions) {
m_defaultImageOptions = newDefaultImageOptions;
}
bool LibraryTypeOptionsDto::defaultImageOptionsNull() const {

8
core/src/dto/listingsproviderinfo.cpp
View file

@ -99,7 +99,7 @@ void ListingsProviderInfo::setFromJson(QJsonObject source) {
m_sportsCategories = Jellyfin::Support::fromJsonValue<QStringList>(source["SportsCategories"]);
m_kidsCategories = Jellyfin::Support::fromJsonValue<QStringList>(source["KidsCategories"]);
m_movieCategories = Jellyfin::Support::fromJsonValue<QStringList>(source["MovieCategories"]);
m_channelMappings = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NameValuePair>>>(source["ChannelMappings"]);
m_channelMappings = Jellyfin::Support::fromJsonValue<QList<NameValuePair>>(source["ChannelMappings"]);
m_moviePrefix = Jellyfin::Support::fromJsonValue<QString>(source["MoviePrefix"]);
m_preferredLanguage = Jellyfin::Support::fromJsonValue<QString>(source["PreferredLanguage"]);
m_userAgent = Jellyfin::Support::fromJsonValue<QString>(source["UserAgent"]);
@ -122,7 +122,7 @@ QJsonObject ListingsProviderInfo::toJson() {
result["SportsCategories"] = Jellyfin::Support::toJsonValue<QStringList>(m_sportsCategories);
result["KidsCategories"] = Jellyfin::Support::toJsonValue<QStringList>(m_kidsCategories);
result["MovieCategories"] = Jellyfin::Support::toJsonValue<QStringList>(m_movieCategories);
result["ChannelMappings"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NameValuePair>>>(m_channelMappings);
result["ChannelMappings"] = Jellyfin::Support::toJsonValue<QList<NameValuePair>>(m_channelMappings);
result["MoviePrefix"] = Jellyfin::Support::toJsonValue<QString>(m_moviePrefix);
result["PreferredLanguage"] = Jellyfin::Support::toJsonValue<QString>(m_preferredLanguage);
result["UserAgent"] = Jellyfin::Support::toJsonValue<QString>(m_userAgent);
@ -305,9 +305,9 @@ void ListingsProviderInfo::setMovieCategoriesNull() {
m_movieCategories.clear();
}
QList<QSharedPointer<NameValuePair>> ListingsProviderInfo::channelMappings() const { return m_channelMappings; }
QList<NameValuePair> ListingsProviderInfo::channelMappings() const { return m_channelMappings; }
void ListingsProviderInfo::setChannelMappings(QList<QSharedPointer<NameValuePair>> newChannelMappings) {
void ListingsProviderInfo::setChannelMappings(QList<NameValuePair> newChannelMappings) {
m_channelMappings = newChannelMappings;
}
bool ListingsProviderInfo::channelMappingsNull() const {

8
core/src/dto/livetvinfo.cpp
View file

@ -55,7 +55,7 @@ LiveTvInfo LiveTvInfo::fromJson(QJsonObject source) {
void LiveTvInfo::setFromJson(QJsonObject source) {
m_services = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<LiveTvServiceInfo>>>(source["Services"]);
m_services = Jellyfin::Support::fromJsonValue<QList<LiveTvServiceInfo>>(source["Services"]);
m_isEnabled = Jellyfin::Support::fromJsonValue<bool>(source["IsEnabled"]);
m_enabledUsers = Jellyfin::Support::fromJsonValue<QStringList>(source["EnabledUsers"]);
@ -63,16 +63,16 @@ void LiveTvInfo::setFromJson(QJsonObject source) {
QJsonObject LiveTvInfo::toJson() {
QJsonObject result;
result["Services"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<LiveTvServiceInfo>>>(m_services);
result["Services"] = Jellyfin::Support::toJsonValue<QList<LiveTvServiceInfo>>(m_services);
result["IsEnabled"] = Jellyfin::Support::toJsonValue<bool>(m_isEnabled);
result["EnabledUsers"] = Jellyfin::Support::toJsonValue<QStringList>(m_enabledUsers);
return result;
}
QList<QSharedPointer<LiveTvServiceInfo>> LiveTvInfo::services() const { return m_services; }
QList<LiveTvServiceInfo> LiveTvInfo::services() const { return m_services; }
void LiveTvInfo::setServices(QList<QSharedPointer<LiveTvServiceInfo>> newServices) {
void LiveTvInfo::setServices(QList<LiveTvServiceInfo> newServices) {
m_services = newServices;
}
bool LiveTvInfo::servicesNull() const {

16
core/src/dto/mediasourceinfo.cpp
View file

@ -163,8 +163,8 @@ void MediaSourceInfo::setFromJson(QJsonObject source) {
m_videoType = Jellyfin::Support::fromJsonValue<VideoType>(source["VideoType"]);
m_isoType = Jellyfin::Support::fromJsonValue<IsoType>(source["IsoType"]);
m_video3DFormat = Jellyfin::Support::fromJsonValue<Video3DFormat>(source["Video3DFormat"]);
m_mediaStreams = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<MediaStream>>>(source["MediaStreams"]);
m_mediaAttachments = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<MediaAttachment>>>(source["MediaAttachments"]);
m_mediaStreams = Jellyfin::Support::fromJsonValue<QList<MediaStream>>(source["MediaStreams"]);
m_mediaAttachments = Jellyfin::Support::fromJsonValue<QList<MediaAttachment>>(source["MediaAttachments"]);
m_formats = Jellyfin::Support::fromJsonValue<QStringList>(source["Formats"]);
m_bitrate = Jellyfin::Support::fromJsonValue<std::optional<qint32>>(source["Bitrate"]);
m_timestamp = Jellyfin::Support::fromJsonValue<TransportStreamTimestamp>(source["Timestamp"]);
@ -210,8 +210,8 @@ QJsonObject MediaSourceInfo::toJson() {
result["VideoType"] = Jellyfin::Support::toJsonValue<VideoType>(m_videoType);
result["IsoType"] = Jellyfin::Support::toJsonValue<IsoType>(m_isoType);
result["Video3DFormat"] = Jellyfin::Support::toJsonValue<Video3DFormat>(m_video3DFormat);
result["MediaStreams"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<MediaStream>>>(m_mediaStreams);
result["MediaAttachments"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<MediaAttachment>>>(m_mediaAttachments);
result["MediaStreams"] = Jellyfin::Support::toJsonValue<QList<MediaStream>>(m_mediaStreams);
result["MediaAttachments"] = Jellyfin::Support::toJsonValue<QList<MediaAttachment>>(m_mediaAttachments);
result["Formats"] = Jellyfin::Support::toJsonValue<QStringList>(m_formats);
result["Bitrate"] = Jellyfin::Support::toJsonValue<std::optional<qint32>>(m_bitrate);
result["Timestamp"] = Jellyfin::Support::toJsonValue<TransportStreamTimestamp>(m_timestamp);
@ -483,9 +483,9 @@ void MediaSourceInfo::setVideo3DFormat(Video3DFormat newVideo3DFormat) {
m_video3DFormat = newVideo3DFormat;
}
QList<QSharedPointer<MediaStream>> MediaSourceInfo::mediaStreams() const { return m_mediaStreams; }
QList<MediaStream> MediaSourceInfo::mediaStreams() const { return m_mediaStreams; }
void MediaSourceInfo::setMediaStreams(QList<QSharedPointer<MediaStream>> newMediaStreams) {
void MediaSourceInfo::setMediaStreams(QList<MediaStream> newMediaStreams) {
m_mediaStreams = newMediaStreams;
}
bool MediaSourceInfo::mediaStreamsNull() const {
@ -496,9 +496,9 @@ void MediaSourceInfo::setMediaStreamsNull() {
m_mediaStreams.clear();
}
QList<QSharedPointer<MediaAttachment>> MediaSourceInfo::mediaAttachments() const { return m_mediaAttachments; }
QList<MediaAttachment> MediaSourceInfo::mediaAttachments() const { return m_mediaAttachments; }
void MediaSourceInfo::setMediaAttachments(QList<QSharedPointer<MediaAttachment>> newMediaAttachments) {
void MediaSourceInfo::setMediaAttachments(QList<MediaAttachment> newMediaAttachments) {
m_mediaAttachments = newMediaAttachments;
}
bool MediaSourceInfo::mediaAttachmentsNull() const {

40
core/src/dto/metadataeditorinfo.cpp
View file

@ -61,30 +61,30 @@ MetadataEditorInfo MetadataEditorInfo::fromJson(QJsonObject source) {
void MetadataEditorInfo::setFromJson(QJsonObject source) {
m_parentalRatingOptions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ParentalRating>>>(source["ParentalRatingOptions"]);
m_countries = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<CountryInfo>>>(source["Countries"]);
m_cultures = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<CultureDto>>>(source["Cultures"]);
m_externalIdInfos = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ExternalIdInfo>>>(source["ExternalIdInfos"]);
m_parentalRatingOptions = Jellyfin::Support::fromJsonValue<QList<ParentalRating>>(source["ParentalRatingOptions"]);
m_countries = Jellyfin::Support::fromJsonValue<QList<CountryInfo>>(source["Countries"]);
m_cultures = Jellyfin::Support::fromJsonValue<QList<CultureDto>>(source["Cultures"]);
m_externalIdInfos = Jellyfin::Support::fromJsonValue<QList<ExternalIdInfo>>(source["ExternalIdInfos"]);
m_contentType = Jellyfin::Support::fromJsonValue<QString>(source["ContentType"]);
m_contentTypeOptions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NameValuePair>>>(source["ContentTypeOptions"]);
m_contentTypeOptions = Jellyfin::Support::fromJsonValue<QList<NameValuePair>>(source["ContentTypeOptions"]);
}
QJsonObject MetadataEditorInfo::toJson() {
QJsonObject result;
result["ParentalRatingOptions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ParentalRating>>>(m_parentalRatingOptions);
result["Countries"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<CountryInfo>>>(m_countries);
result["Cultures"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<CultureDto>>>(m_cultures);
result["ExternalIdInfos"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ExternalIdInfo>>>(m_externalIdInfos);
result["ParentalRatingOptions"] = Jellyfin::Support::toJsonValue<QList<ParentalRating>>(m_parentalRatingOptions);
result["Countries"] = Jellyfin::Support::toJsonValue<QList<CountryInfo>>(m_countries);
result["Cultures"] = Jellyfin::Support::toJsonValue<QList<CultureDto>>(m_cultures);
result["ExternalIdInfos"] = Jellyfin::Support::toJsonValue<QList<ExternalIdInfo>>(m_externalIdInfos);
result["ContentType"] = Jellyfin::Support::toJsonValue<QString>(m_contentType);
result["ContentTypeOptions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NameValuePair>>>(m_contentTypeOptions);
result["ContentTypeOptions"] = Jellyfin::Support::toJsonValue<QList<NameValuePair>>(m_contentTypeOptions);
return result;
}
QList<QSharedPointer<ParentalRating>> MetadataEditorInfo::parentalRatingOptions() const { return m_parentalRatingOptions; }
QList<ParentalRating> MetadataEditorInfo::parentalRatingOptions() const { return m_parentalRatingOptions; }
void MetadataEditorInfo::setParentalRatingOptions(QList<QSharedPointer<ParentalRating>> newParentalRatingOptions) {
void MetadataEditorInfo::setParentalRatingOptions(QList<ParentalRating> newParentalRatingOptions) {
m_parentalRatingOptions = newParentalRatingOptions;
}
bool MetadataEditorInfo::parentalRatingOptionsNull() const {
@ -95,9 +95,9 @@ void MetadataEditorInfo::setParentalRatingOptionsNull() {
m_parentalRatingOptions.clear();
}
QList<QSharedPointer<CountryInfo>> MetadataEditorInfo::countries() const { return m_countries; }
QList<CountryInfo> MetadataEditorInfo::countries() const { return m_countries; }
void MetadataEditorInfo::setCountries(QList<QSharedPointer<CountryInfo>> newCountries) {
void MetadataEditorInfo::setCountries(QList<CountryInfo> newCountries) {
m_countries = newCountries;
}
bool MetadataEditorInfo::countriesNull() const {
@ -108,9 +108,9 @@ void MetadataEditorInfo::setCountriesNull() {
m_countries.clear();
}
QList<QSharedPointer<CultureDto>> MetadataEditorInfo::cultures() const { return m_cultures; }
QList<CultureDto> MetadataEditorInfo::cultures() const { return m_cultures; }
void MetadataEditorInfo::setCultures(QList<QSharedPointer<CultureDto>> newCultures) {
void MetadataEditorInfo::setCultures(QList<CultureDto> newCultures) {
m_cultures = newCultures;
}
bool MetadataEditorInfo::culturesNull() const {
@ -121,9 +121,9 @@ void MetadataEditorInfo::setCulturesNull() {
m_cultures.clear();
}
QList<QSharedPointer<ExternalIdInfo>> MetadataEditorInfo::externalIdInfos() const { return m_externalIdInfos; }
QList<ExternalIdInfo> MetadataEditorInfo::externalIdInfos() const { return m_externalIdInfos; }
void MetadataEditorInfo::setExternalIdInfos(QList<QSharedPointer<ExternalIdInfo>> newExternalIdInfos) {
void MetadataEditorInfo::setExternalIdInfos(QList<ExternalIdInfo> newExternalIdInfos) {
m_externalIdInfos = newExternalIdInfos;
}
bool MetadataEditorInfo::externalIdInfosNull() const {
@ -147,9 +147,9 @@ void MetadataEditorInfo::setContentTypeNull() {
m_contentType.clear();
}
QList<QSharedPointer<NameValuePair>> MetadataEditorInfo::contentTypeOptions() const { return m_contentTypeOptions; }
QList<NameValuePair> MetadataEditorInfo::contentTypeOptions() const { return m_contentTypeOptions; }
void MetadataEditorInfo::setContentTypeOptions(QList<QSharedPointer<NameValuePair>> newContentTypeOptions) {
void MetadataEditorInfo::setContentTypeOptions(QList<NameValuePair> newContentTypeOptions) {
m_contentTypeOptions = newContentTypeOptions;
}
bool MetadataEditorInfo::contentTypeOptionsNull() const {

8
core/src/dto/notificationresultdto.cpp
View file

@ -53,22 +53,22 @@ NotificationResultDto NotificationResultDto::fromJson(QJsonObject source) {
void NotificationResultDto::setFromJson(QJsonObject source) {
m_notifications = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NotificationDto>>>(source["Notifications"]);
m_notifications = Jellyfin::Support::fromJsonValue<QList<NotificationDto>>(source["Notifications"]);
m_totalRecordCount = Jellyfin::Support::fromJsonValue<qint32>(source["TotalRecordCount"]);
}
QJsonObject NotificationResultDto::toJson() {
QJsonObject result;
result["Notifications"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NotificationDto>>>(m_notifications);
result["Notifications"] = Jellyfin::Support::toJsonValue<QList<NotificationDto>>(m_notifications);
result["TotalRecordCount"] = Jellyfin::Support::toJsonValue<qint32>(m_totalRecordCount);
return result;
}
QList<QSharedPointer<NotificationDto>> NotificationResultDto::notifications() const { return m_notifications; }
QList<NotificationDto> NotificationResultDto::notifications() const { return m_notifications; }
void NotificationResultDto::setNotifications(QList<QSharedPointer<NotificationDto>> newNotifications) {
void NotificationResultDto::setNotifications(QList<NotificationDto> newNotifications) {
m_notifications = newNotifications;
}
bool NotificationResultDto::notificationsNull() const {

8
core/src/dto/packageinfo.cpp
View file

@ -71,7 +71,7 @@ void PackageInfo::setFromJson(QJsonObject source) {
m_owner = Jellyfin::Support::fromJsonValue<QString>(source["owner"]);
m_category = Jellyfin::Support::fromJsonValue<QString>(source["category"]);
m_guid = Jellyfin::Support::fromJsonValue<QString>(source["guid"]);
m_versions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<VersionInfo>>>(source["versions"]);
m_versions = Jellyfin::Support::fromJsonValue<QList<VersionInfo>>(source["versions"]);
m_imageUrl = Jellyfin::Support::fromJsonValue<QString>(source["imageUrl"]);
}
@ -84,7 +84,7 @@ QJsonObject PackageInfo::toJson() {
result["owner"] = Jellyfin::Support::toJsonValue<QString>(m_owner);
result["category"] = Jellyfin::Support::toJsonValue<QString>(m_category);
result["guid"] = Jellyfin::Support::toJsonValue<QString>(m_guid);
result["versions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<VersionInfo>>>(m_versions);
result["versions"] = Jellyfin::Support::toJsonValue<QList<VersionInfo>>(m_versions);
result["imageUrl"] = Jellyfin::Support::toJsonValue<QString>(m_imageUrl);
return result;
@ -168,9 +168,9 @@ void PackageInfo::setGuidNull() {
m_guid.clear();
}
QList<QSharedPointer<VersionInfo>> PackageInfo::versions() const { return m_versions; }
QList<VersionInfo> PackageInfo::versions() const { return m_versions; }
void PackageInfo::setVersions(QList<QSharedPointer<VersionInfo>> newVersions) {
void PackageInfo::setVersions(QList<VersionInfo> newVersions) {
m_versions = newVersions;
}
bool PackageInfo::versionsNull() const {

8
core/src/dto/playbackinforesponse.cpp
View file

@ -55,7 +55,7 @@ PlaybackInfoResponse PlaybackInfoResponse::fromJson(QJsonObject source) {
void PlaybackInfoResponse::setFromJson(QJsonObject source) {
m_mediaSources = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<MediaSourceInfo>>>(source["MediaSources"]);
m_mediaSources = Jellyfin::Support::fromJsonValue<QList<MediaSourceInfo>>(source["MediaSources"]);
m_playSessionId = Jellyfin::Support::fromJsonValue<QString>(source["PlaySessionId"]);
m_errorCode = Jellyfin::Support::fromJsonValue<PlaybackErrorCode>(source["ErrorCode"]);
@ -63,16 +63,16 @@ void PlaybackInfoResponse::setFromJson(QJsonObject source) {
QJsonObject PlaybackInfoResponse::toJson() {
QJsonObject result;
result["MediaSources"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<MediaSourceInfo>>>(m_mediaSources);
result["MediaSources"] = Jellyfin::Support::toJsonValue<QList<MediaSourceInfo>>(m_mediaSources);
result["PlaySessionId"] = Jellyfin::Support::toJsonValue<QString>(m_playSessionId);
result["ErrorCode"] = Jellyfin::Support::toJsonValue<PlaybackErrorCode>(m_errorCode);
return result;
}
QList<QSharedPointer<MediaSourceInfo>> PlaybackInfoResponse::mediaSources() const { return m_mediaSources; }
QList<MediaSourceInfo> PlaybackInfoResponse::mediaSources() const { return m_mediaSources; }
void PlaybackInfoResponse::setMediaSources(QList<QSharedPointer<MediaSourceInfo>> newMediaSources) {
void PlaybackInfoResponse::setMediaSources(QList<MediaSourceInfo> newMediaSources) {
m_mediaSources = newMediaSources;
}
bool PlaybackInfoResponse::mediaSourcesNull() const {

8
core/src/dto/playbackprogressinfo.cpp
View file

@ -107,7 +107,7 @@ void PlaybackProgressInfo::setFromJson(QJsonObject source) {
m_liveStreamId = Jellyfin::Support::fromJsonValue<QString>(source["LiveStreamId"]);
m_playSessionId = Jellyfin::Support::fromJsonValue<QString>(source["PlaySessionId"]);
m_repeatMode = Jellyfin::Support::fromJsonValue<RepeatMode>(source["RepeatMode"]);
m_nowPlayingQueue = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<QueueItem>>>(source["NowPlayingQueue"]);
m_nowPlayingQueue = Jellyfin::Support::fromJsonValue<QList<QueueItem>>(source["NowPlayingQueue"]);
m_playlistItemId = Jellyfin::Support::fromJsonValue<QString>(source["PlaylistItemId"]);
}
@ -132,7 +132,7 @@ QJsonObject PlaybackProgressInfo::toJson() {
result["LiveStreamId"] = Jellyfin::Support::toJsonValue<QString>(m_liveStreamId);
result["PlaySessionId"] = Jellyfin::Support::toJsonValue<QString>(m_playSessionId);
result["RepeatMode"] = Jellyfin::Support::toJsonValue<RepeatMode>(m_repeatMode);
result["NowPlayingQueue"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<QueueItem>>>(m_nowPlayingQueue);
result["NowPlayingQueue"] = Jellyfin::Support::toJsonValue<QList<QueueItem>>(m_nowPlayingQueue);
result["PlaylistItemId"] = Jellyfin::Support::toJsonValue<QString>(m_playlistItemId);
return result;
@ -323,9 +323,9 @@ void PlaybackProgressInfo::setRepeatMode(RepeatMode newRepeatMode) {
m_repeatMode = newRepeatMode;
}
QList<QSharedPointer<QueueItem>> PlaybackProgressInfo::nowPlayingQueue() const { return m_nowPlayingQueue; }
QList<QueueItem> PlaybackProgressInfo::nowPlayingQueue() const { return m_nowPlayingQueue; }
void PlaybackProgressInfo::setNowPlayingQueue(QList<QSharedPointer<QueueItem>> newNowPlayingQueue) {
void PlaybackProgressInfo::setNowPlayingQueue(QList<QueueItem> newNowPlayingQueue) {
m_nowPlayingQueue = newNowPlayingQueue;
}
bool PlaybackProgressInfo::nowPlayingQueueNull() const {

8
core/src/dto/playbackstartinfo.cpp
View file

@ -107,7 +107,7 @@ void PlaybackStartInfo::setFromJson(QJsonObject source) {
m_liveStreamId = Jellyfin::Support::fromJsonValue<QString>(source["LiveStreamId"]);
m_playSessionId = Jellyfin::Support::fromJsonValue<QString>(source["PlaySessionId"]);
m_repeatMode = Jellyfin::Support::fromJsonValue<RepeatMode>(source["RepeatMode"]);
m_nowPlayingQueue = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<QueueItem>>>(source["NowPlayingQueue"]);
m_nowPlayingQueue = Jellyfin::Support::fromJsonValue<QList<QueueItem>>(source["NowPlayingQueue"]);
m_playlistItemId = Jellyfin::Support::fromJsonValue<QString>(source["PlaylistItemId"]);
}
@ -132,7 +132,7 @@ QJsonObject PlaybackStartInfo::toJson() {
result["LiveStreamId"] = Jellyfin::Support::toJsonValue<QString>(m_liveStreamId);
result["PlaySessionId"] = Jellyfin::Support::toJsonValue<QString>(m_playSessionId);
result["RepeatMode"] = Jellyfin::Support::toJsonValue<RepeatMode>(m_repeatMode);
result["NowPlayingQueue"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<QueueItem>>>(m_nowPlayingQueue);
result["NowPlayingQueue"] = Jellyfin::Support::toJsonValue<QList<QueueItem>>(m_nowPlayingQueue);
result["PlaylistItemId"] = Jellyfin::Support::toJsonValue<QString>(m_playlistItemId);
return result;
@ -323,9 +323,9 @@ void PlaybackStartInfo::setRepeatMode(RepeatMode newRepeatMode) {
m_repeatMode = newRepeatMode;
}
QList<QSharedPointer<QueueItem>> PlaybackStartInfo::nowPlayingQueue() const { return m_nowPlayingQueue; }
QList<QueueItem> PlaybackStartInfo::nowPlayingQueue() const { return m_nowPlayingQueue; }
void PlaybackStartInfo::setNowPlayingQueue(QList<QSharedPointer<QueueItem>> newNowPlayingQueue) {
void PlaybackStartInfo::setNowPlayingQueue(QList<QueueItem> newNowPlayingQueue) {
m_nowPlayingQueue = newNowPlayingQueue;
}
bool PlaybackStartInfo::nowPlayingQueueNull() const {

8
core/src/dto/playbackstopinfo.cpp
View file

@ -81,7 +81,7 @@ void PlaybackStopInfo::setFromJson(QJsonObject source) {
m_failed = Jellyfin::Support::fromJsonValue<bool>(source["Failed"]);
m_nextMediaType = Jellyfin::Support::fromJsonValue<QString>(source["NextMediaType"]);
m_playlistItemId = Jellyfin::Support::fromJsonValue<QString>(source["PlaylistItemId"]);
m_nowPlayingQueue = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<QueueItem>>>(source["NowPlayingQueue"]);
m_nowPlayingQueue = Jellyfin::Support::fromJsonValue<QList<QueueItem>>(source["NowPlayingQueue"]);
}
@ -97,7 +97,7 @@ QJsonObject PlaybackStopInfo::toJson() {
result["Failed"] = Jellyfin::Support::toJsonValue<bool>(m_failed);
result["NextMediaType"] = Jellyfin::Support::toJsonValue<QString>(m_nextMediaType);
result["PlaylistItemId"] = Jellyfin::Support::toJsonValue<QString>(m_playlistItemId);
result["NowPlayingQueue"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<QueueItem>>>(m_nowPlayingQueue);
result["NowPlayingQueue"] = Jellyfin::Support::toJsonValue<QList<QueueItem>>(m_nowPlayingQueue);
return result;
}
@ -211,9 +211,9 @@ void PlaybackStopInfo::setPlaylistItemIdNull() {
m_playlistItemId.clear();
}
QList<QSharedPointer<QueueItem>> PlaybackStopInfo::nowPlayingQueue() const { return m_nowPlayingQueue; }
QList<QueueItem> PlaybackStopInfo::nowPlayingQueue() const { return m_nowPlayingQueue; }
void PlaybackStopInfo::setNowPlayingQueue(QList<QSharedPointer<QueueItem>> newNowPlayingQueue) {
void PlaybackStopInfo::setNowPlayingQueue(QList<QueueItem> newNowPlayingQueue) {
m_nowPlayingQueue = newNowPlayingQueue;
}
bool PlaybackStopInfo::nowPlayingQueueNull() const {

8
core/src/dto/queryfilters.cpp
View file

@ -53,22 +53,22 @@ QueryFilters QueryFilters::fromJson(QJsonObject source) {
void QueryFilters::setFromJson(QJsonObject source) {
m_genres = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NameGuidPair>>>(source["Genres"]);
m_genres = Jellyfin::Support::fromJsonValue<QList<NameGuidPair>>(source["Genres"]);
m_tags = Jellyfin::Support::fromJsonValue<QStringList>(source["Tags"]);
}
QJsonObject QueryFilters::toJson() {
QJsonObject result;
result["Genres"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NameGuidPair>>>(m_genres);
result["Genres"] = Jellyfin::Support::toJsonValue<QList<NameGuidPair>>(m_genres);
result["Tags"] = Jellyfin::Support::toJsonValue<QStringList>(m_tags);
return result;
}
QList<QSharedPointer<NameGuidPair>> QueryFilters::genres() const { return m_genres; }
QList<NameGuidPair> QueryFilters::genres() const { return m_genres; }
void QueryFilters::setGenres(QList<QSharedPointer<NameGuidPair>> newGenres) {
void QueryFilters::setGenres(QList<NameGuidPair> newGenres) {
m_genres = newGenres;
}
bool QueryFilters::genresNull() const {

8
core/src/dto/recommendationdto.cpp
View file

@ -57,7 +57,7 @@ RecommendationDto RecommendationDto::fromJson(QJsonObject source) {
void RecommendationDto::setFromJson(QJsonObject source) {
m_items = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<BaseItemDto>>>(source["Items"]);
m_items = Jellyfin::Support::fromJsonValue<QList<BaseItemDto>>(source["Items"]);
m_recommendationType = Jellyfin::Support::fromJsonValue<RecommendationType>(source["RecommendationType"]);
m_baselineItemName = Jellyfin::Support::fromJsonValue<QString>(source["BaselineItemName"]);
m_categoryId = Jellyfin::Support::fromJsonValue<QString>(source["CategoryId"]);
@ -66,7 +66,7 @@ void RecommendationDto::setFromJson(QJsonObject source) {
QJsonObject RecommendationDto::toJson() {
QJsonObject result;
result["Items"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<BaseItemDto>>>(m_items);
result["Items"] = Jellyfin::Support::toJsonValue<QList<BaseItemDto>>(m_items);
result["RecommendationType"] = Jellyfin::Support::toJsonValue<RecommendationType>(m_recommendationType);
result["BaselineItemName"] = Jellyfin::Support::toJsonValue<QString>(m_baselineItemName);
result["CategoryId"] = Jellyfin::Support::toJsonValue<QString>(m_categoryId);
@ -74,9 +74,9 @@ QJsonObject RecommendationDto::toJson() {
return result;
}
QList<QSharedPointer<BaseItemDto>> RecommendationDto::items() const { return m_items; }
QList<BaseItemDto> RecommendationDto::items() const { return m_items; }
void RecommendationDto::setItems(QList<QSharedPointer<BaseItemDto>> newItems) {
void RecommendationDto::setItems(QList<BaseItemDto> newItems) {
m_items = newItems;
}
bool RecommendationDto::itemsNull() const {

8
core/src/dto/remoteimageresult.cpp
View file

@ -55,7 +55,7 @@ RemoteImageResult RemoteImageResult::fromJson(QJsonObject source) {
void RemoteImageResult::setFromJson(QJsonObject source) {
m_images = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<RemoteImageInfo>>>(source["Images"]);
m_images = Jellyfin::Support::fromJsonValue<QList<RemoteImageInfo>>(source["Images"]);
m_totalRecordCount = Jellyfin::Support::fromJsonValue<qint32>(source["TotalRecordCount"]);
m_providers = Jellyfin::Support::fromJsonValue<QStringList>(source["Providers"]);
@ -63,16 +63,16 @@ void RemoteImageResult::setFromJson(QJsonObject source) {
QJsonObject RemoteImageResult::toJson() {
QJsonObject result;
result["Images"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<RemoteImageInfo>>>(m_images);
result["Images"] = Jellyfin::Support::toJsonValue<QList<RemoteImageInfo>>(m_images);
result["TotalRecordCount"] = Jellyfin::Support::toJsonValue<qint32>(m_totalRecordCount);
result["Providers"] = Jellyfin::Support::toJsonValue<QStringList>(m_providers);
return result;
}
QList<QSharedPointer<RemoteImageInfo>> RemoteImageResult::images() const { return m_images; }
QList<RemoteImageInfo> RemoteImageResult::images() const { return m_images; }
void RemoteImageResult::setImages(QList<QSharedPointer<RemoteImageInfo>> newImages) {
void RemoteImageResult::setImages(QList<RemoteImageInfo> newImages) {
m_images = newImages;
}
bool RemoteImageResult::imagesNull() const {

8
core/src/dto/remotesearchresult.cpp
View file

@ -84,7 +84,7 @@ void RemoteSearchResult::setFromJson(QJsonObject source) {
m_searchProviderName = Jellyfin::Support::fromJsonValue<QString>(source["SearchProviderName"]);
m_overview = Jellyfin::Support::fromJsonValue<QString>(source["Overview"]);
m_albumArtist = Jellyfin::Support::fromJsonValue<QSharedPointer<RemoteSearchResult>>(source["AlbumArtist"]);
m_artists = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<RemoteSearchResult>>>(source["Artists"]);
m_artists = Jellyfin::Support::fromJsonValue<QList<RemoteSearchResult>>(source["Artists"]);
}
@ -101,7 +101,7 @@ QJsonObject RemoteSearchResult::toJson() {
result["SearchProviderName"] = Jellyfin::Support::toJsonValue<QString>(m_searchProviderName);
result["Overview"] = Jellyfin::Support::toJsonValue<QString>(m_overview);
result["AlbumArtist"] = Jellyfin::Support::toJsonValue<QSharedPointer<RemoteSearchResult>>(m_albumArtist);
result["Artists"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<RemoteSearchResult>>>(m_artists);
result["Artists"] = Jellyfin::Support::toJsonValue<QList<RemoteSearchResult>>(m_artists);
return result;
}
@ -242,9 +242,9 @@ void RemoteSearchResult::setAlbumArtist(QSharedPointer<RemoteSearchResult> newAl
m_albumArtist = newAlbumArtist;
}
QList<QSharedPointer<RemoteSearchResult>> RemoteSearchResult::artists() const { return m_artists; }
QList<RemoteSearchResult> RemoteSearchResult::artists() const { return m_artists; }
void RemoteSearchResult::setArtists(QList<QSharedPointer<RemoteSearchResult>> newArtists) {
void RemoteSearchResult::setArtists(QList<RemoteSearchResult> newArtists) {
m_artists = newArtists;
}
bool RemoteSearchResult::artistsNull() const {

8
core/src/dto/responseprofile.cpp
View file

@ -69,7 +69,7 @@ void ResponseProfile::setFromJson(QJsonObject source) {
m_type = Jellyfin::Support::fromJsonValue<DlnaProfileType>(source["Type"]);
m_orgPn = Jellyfin::Support::fromJsonValue<QString>(source["OrgPn"]);
m_mimeType = Jellyfin::Support::fromJsonValue<QString>(source["MimeType"]);
m_conditions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ProfileCondition>>>(source["Conditions"]);
m_conditions = Jellyfin::Support::fromJsonValue<QList<ProfileCondition>>(source["Conditions"]);
}
@ -81,7 +81,7 @@ QJsonObject ResponseProfile::toJson() {
result["Type"] = Jellyfin::Support::toJsonValue<DlnaProfileType>(m_type);
result["OrgPn"] = Jellyfin::Support::toJsonValue<QString>(m_orgPn);
result["MimeType"] = Jellyfin::Support::toJsonValue<QString>(m_mimeType);
result["Conditions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ProfileCondition>>>(m_conditions);
result["Conditions"] = Jellyfin::Support::toJsonValue<QList<ProfileCondition>>(m_conditions);
return result;
}
@ -157,9 +157,9 @@ void ResponseProfile::setMimeTypeNull() {
m_mimeType.clear();
}
QList<QSharedPointer<ProfileCondition>> ResponseProfile::conditions() const { return m_conditions; }
QList<ProfileCondition> ResponseProfile::conditions() const { return m_conditions; }
void ResponseProfile::setConditions(QList<QSharedPointer<ProfileCondition>> newConditions) {
void ResponseProfile::setConditions(QList<ProfileCondition> newConditions) {
m_conditions = newConditions;
}
bool ResponseProfile::conditionsNull() const {

8
core/src/dto/searchhintresult.cpp
View file

@ -53,22 +53,22 @@ SearchHintResult SearchHintResult::fromJson(QJsonObject source) {
void SearchHintResult::setFromJson(QJsonObject source) {
m_searchHints = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<SearchHint>>>(source["SearchHints"]);
m_searchHints = Jellyfin::Support::fromJsonValue<QList<SearchHint>>(source["SearchHints"]);
m_totalRecordCount = Jellyfin::Support::fromJsonValue<qint32>(source["TotalRecordCount"]);
}
QJsonObject SearchHintResult::toJson() {
QJsonObject result;
result["SearchHints"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<SearchHint>>>(m_searchHints);
result["SearchHints"] = Jellyfin::Support::toJsonValue<QList<SearchHint>>(m_searchHints);
result["TotalRecordCount"] = Jellyfin::Support::toJsonValue<qint32>(m_totalRecordCount);
return result;
}
QList<QSharedPointer<SearchHint>> SearchHintResult::searchHints() const { return m_searchHints; }
QList<SearchHint> SearchHintResult::searchHints() const { return m_searchHints; }
void SearchHintResult::setSearchHints(QList<QSharedPointer<SearchHint>> newSearchHints) {
void SearchHintResult::setSearchHints(QList<SearchHint> newSearchHints) {
m_searchHints = newSearchHints;
}
bool SearchHintResult::searchHintsNull() const {

8
core/src/dto/seriestimerinfodtoqueryresult.cpp
View file

@ -55,7 +55,7 @@ SeriesTimerInfoDtoQueryResult SeriesTimerInfoDtoQueryResult::fromJson(QJsonObjec
void SeriesTimerInfoDtoQueryResult::setFromJson(QJsonObject source) {
m_items = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<SeriesTimerInfoDto>>>(source["Items"]);
m_items = Jellyfin::Support::fromJsonValue<QList<SeriesTimerInfoDto>>(source["Items"]);
m_totalRecordCount = Jellyfin::Support::fromJsonValue<qint32>(source["TotalRecordCount"]);
m_startIndex = Jellyfin::Support::fromJsonValue<qint32>(source["StartIndex"]);
@ -63,16 +63,16 @@ void SeriesTimerInfoDtoQueryResult::setFromJson(QJsonObject source) {
QJsonObject SeriesTimerInfoDtoQueryResult::toJson() {
QJsonObject result;
result["Items"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<SeriesTimerInfoDto>>>(m_items);
result["Items"] = Jellyfin::Support::toJsonValue<QList<SeriesTimerInfoDto>>(m_items);
result["TotalRecordCount"] = Jellyfin::Support::toJsonValue<qint32>(m_totalRecordCount);
result["StartIndex"] = Jellyfin::Support::toJsonValue<qint32>(m_startIndex);
return result;
}
QList<QSharedPointer<SeriesTimerInfoDto>> SeriesTimerInfoDtoQueryResult::items() const { return m_items; }
QList<SeriesTimerInfoDto> SeriesTimerInfoDtoQueryResult::items() const { return m_items; }
void SeriesTimerInfoDtoQueryResult::setItems(QList<QSharedPointer<SeriesTimerInfoDto>> newItems) {
void SeriesTimerInfoDtoQueryResult::setItems(QList<SeriesTimerInfoDto> newItems) {
m_items = newItems;
}
bool SeriesTimerInfoDtoQueryResult::itemsNull() const {

32
core/src/dto/serverconfiguration.cpp
View file

@ -271,13 +271,13 @@ void ServerConfiguration::setFromJson(QJsonObject source) {
m_libraryMonitorDelay = Jellyfin::Support::fromJsonValue<qint32>(source["LibraryMonitorDelay"]);
m_enableDashboardResponseCaching = Jellyfin::Support::fromJsonValue<bool>(source["EnableDashboardResponseCaching"]);
m_imageSavingConvention = Jellyfin::Support::fromJsonValue<ImageSavingConvention>(source["ImageSavingConvention"]);
m_metadataOptions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<MetadataOptions>>>(source["MetadataOptions"]);
m_metadataOptions = Jellyfin::Support::fromJsonValue<QList<MetadataOptions>>(source["MetadataOptions"]);
m_skipDeserializationForBasicTypes = Jellyfin::Support::fromJsonValue<bool>(source["SkipDeserializationForBasicTypes"]);
m_serverName = Jellyfin::Support::fromJsonValue<QString>(source["ServerName"]);
m_baseUrl = Jellyfin::Support::fromJsonValue<QString>(source["BaseUrl"]);
m_uICulture = Jellyfin::Support::fromJsonValue<QString>(source["UICulture"]);
m_saveMetadataHidden = Jellyfin::Support::fromJsonValue<bool>(source["SaveMetadataHidden"]);
m_contentTypes = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<NameValuePair>>>(source["ContentTypes"]);
m_contentTypes = Jellyfin::Support::fromJsonValue<QList<NameValuePair>>(source["ContentTypes"]);
m_remoteClientBitrateLimit = Jellyfin::Support::fromJsonValue<qint32>(source["RemoteClientBitrateLimit"]);
m_enableFolderView = Jellyfin::Support::fromJsonValue<bool>(source["EnableFolderView"]);
m_enableGroupingIntoCollections = Jellyfin::Support::fromJsonValue<bool>(source["EnableGroupingIntoCollections"]);
@ -285,14 +285,14 @@ void ServerConfiguration::setFromJson(QJsonObject source) {
m_localNetworkSubnets = Jellyfin::Support::fromJsonValue<QStringList>(source["LocalNetworkSubnets"]);
m_localNetworkAddresses = Jellyfin::Support::fromJsonValue<QStringList>(source["LocalNetworkAddresses"]);
m_codecsUsed = Jellyfin::Support::fromJsonValue<QStringList>(source["CodecsUsed"]);
m_pluginRepositories = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<RepositoryInfo>>>(source["PluginRepositories"]);
m_pluginRepositories = Jellyfin::Support::fromJsonValue<QList<RepositoryInfo>>(source["PluginRepositories"]);
m_enableExternalContentInSuggestions = Jellyfin::Support::fromJsonValue<bool>(source["EnableExternalContentInSuggestions"]);
m_requireHttps = Jellyfin::Support::fromJsonValue<bool>(source["RequireHttps"]);
m_enableNewOmdbSupport = Jellyfin::Support::fromJsonValue<bool>(source["EnableNewOmdbSupport"]);
m_remoteIPFilter = Jellyfin::Support::fromJsonValue<QStringList>(source["RemoteIPFilter"]);
m_isRemoteIPFilterBlacklist = Jellyfin::Support::fromJsonValue<bool>(source["IsRemoteIPFilterBlacklist"]);
m_imageExtractionTimeoutMs = Jellyfin::Support::fromJsonValue<qint32>(source["ImageExtractionTimeoutMs"]);
m_pathSubstitutions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<PathSubstitution>>>(source["PathSubstitutions"]);
m_pathSubstitutions = Jellyfin::Support::fromJsonValue<QList<PathSubstitution>>(source["PathSubstitutions"]);
m_enableSimpleArtistDetection = Jellyfin::Support::fromJsonValue<bool>(source["EnableSimpleArtistDetection"]);
m_uninstalledPlugins = Jellyfin::Support::fromJsonValue<QStringList>(source["UninstalledPlugins"]);
m_enableSlowResponseWarning = Jellyfin::Support::fromJsonValue<bool>(source["EnableSlowResponseWarning"]);
@ -361,13 +361,13 @@ QJsonObject ServerConfiguration::toJson() {
result["LibraryMonitorDelay"] = Jellyfin::Support::toJsonValue<qint32>(m_libraryMonitorDelay);
result["EnableDashboardResponseCaching"] = Jellyfin::Support::toJsonValue<bool>(m_enableDashboardResponseCaching);
result["ImageSavingConvention"] = Jellyfin::Support::toJsonValue<ImageSavingConvention>(m_imageSavingConvention);
result["MetadataOptions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<MetadataOptions>>>(m_metadataOptions);
result["MetadataOptions"] = Jellyfin::Support::toJsonValue<QList<MetadataOptions>>(m_metadataOptions);
result["SkipDeserializationForBasicTypes"] = Jellyfin::Support::toJsonValue<bool>(m_skipDeserializationForBasicTypes);
result["ServerName"] = Jellyfin::Support::toJsonValue<QString>(m_serverName);
result["BaseUrl"] = Jellyfin::Support::toJsonValue<QString>(m_baseUrl);
result["UICulture"] = Jellyfin::Support::toJsonValue<QString>(m_uICulture);
result["SaveMetadataHidden"] = Jellyfin::Support::toJsonValue<bool>(m_saveMetadataHidden);
result["ContentTypes"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<NameValuePair>>>(m_contentTypes);
result["ContentTypes"] = Jellyfin::Support::toJsonValue<QList<NameValuePair>>(m_contentTypes);
result["RemoteClientBitrateLimit"] = Jellyfin::Support::toJsonValue<qint32>(m_remoteClientBitrateLimit);
result["EnableFolderView"] = Jellyfin::Support::toJsonValue<bool>(m_enableFolderView);
result["EnableGroupingIntoCollections"] = Jellyfin::Support::toJsonValue<bool>(m_enableGroupingIntoCollections);
@ -375,14 +375,14 @@ QJsonObject ServerConfiguration::toJson() {
result["LocalNetworkSubnets"] = Jellyfin::Support::toJsonValue<QStringList>(m_localNetworkSubnets);
result["LocalNetworkAddresses"] = Jellyfin::Support::toJsonValue<QStringList>(m_localNetworkAddresses);
result["CodecsUsed"] = Jellyfin::Support::toJsonValue<QStringList>(m_codecsUsed);
result["PluginRepositories"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<RepositoryInfo>>>(m_pluginRepositories);
result["PluginRepositories"] = Jellyfin::Support::toJsonValue<QList<RepositoryInfo>>(m_pluginRepositories);
result["EnableExternalContentInSuggestions"] = Jellyfin::Support::toJsonValue<bool>(m_enableExternalContentInSuggestions);
result["RequireHttps"] = Jellyfin::Support::toJsonValue<bool>(m_requireHttps);
result["EnableNewOmdbSupport"] = Jellyfin::Support::toJsonValue<bool>(m_enableNewOmdbSupport);
result["RemoteIPFilter"] = Jellyfin::Support::toJsonValue<QStringList>(m_remoteIPFilter);
result["IsRemoteIPFilterBlacklist"] = Jellyfin::Support::toJsonValue<bool>(m_isRemoteIPFilterBlacklist);
result["ImageExtractionTimeoutMs"] = Jellyfin::Support::toJsonValue<qint32>(m_imageExtractionTimeoutMs);
result["PathSubstitutions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<PathSubstitution>>>(m_pathSubstitutions);
result["PathSubstitutions"] = Jellyfin::Support::toJsonValue<QList<PathSubstitution>>(m_pathSubstitutions);
result["EnableSimpleArtistDetection"] = Jellyfin::Support::toJsonValue<bool>(m_enableSimpleArtistDetection);
result["UninstalledPlugins"] = Jellyfin::Support::toJsonValue<QStringList>(m_uninstalledPlugins);
result["EnableSlowResponseWarning"] = Jellyfin::Support::toJsonValue<bool>(m_enableSlowResponseWarning);
@ -822,9 +822,9 @@ void ServerConfiguration::setImageSavingConvention(ImageSavingConvention newImag
m_imageSavingConvention = newImageSavingConvention;
}
QList<QSharedPointer<MetadataOptions>> ServerConfiguration::metadataOptions() const { return m_metadataOptions; }
QList<MetadataOptions> ServerConfiguration::metadataOptions() const { return m_metadataOptions; }
void ServerConfiguration::setMetadataOptions(QList<QSharedPointer<MetadataOptions>> newMetadataOptions) {
void ServerConfiguration::setMetadataOptions(QList<MetadataOptions> newMetadataOptions) {
m_metadataOptions = newMetadataOptions;
}
bool ServerConfiguration::metadataOptionsNull() const {
@ -886,9 +886,9 @@ void ServerConfiguration::setSaveMetadataHidden(bool newSaveMetadataHidden) {
m_saveMetadataHidden = newSaveMetadataHidden;
}
QList<QSharedPointer<NameValuePair>> ServerConfiguration::contentTypes() const { return m_contentTypes; }
QList<NameValuePair> ServerConfiguration::contentTypes() const { return m_contentTypes; }
void ServerConfiguration::setContentTypes(QList<QSharedPointer<NameValuePair>> newContentTypes) {
void ServerConfiguration::setContentTypes(QList<NameValuePair> newContentTypes) {
m_contentTypes = newContentTypes;
}
bool ServerConfiguration::contentTypesNull() const {
@ -962,9 +962,9 @@ void ServerConfiguration::setCodecsUsedNull() {
m_codecsUsed.clear();
}
QList<QSharedPointer<RepositoryInfo>> ServerConfiguration::pluginRepositories() const { return m_pluginRepositories; }
QList<RepositoryInfo> ServerConfiguration::pluginRepositories() const { return m_pluginRepositories; }
void ServerConfiguration::setPluginRepositories(QList<QSharedPointer<RepositoryInfo>> newPluginRepositories) {
void ServerConfiguration::setPluginRepositories(QList<RepositoryInfo> newPluginRepositories) {
m_pluginRepositories = newPluginRepositories;
}
bool ServerConfiguration::pluginRepositoriesNull() const {
@ -1018,9 +1018,9 @@ void ServerConfiguration::setImageExtractionTimeoutMs(qint32 newImageExtractionT
m_imageExtractionTimeoutMs = newImageExtractionTimeoutMs;
}
QList<QSharedPointer<PathSubstitution>> ServerConfiguration::pathSubstitutions() const { return m_pathSubstitutions; }
QList<PathSubstitution> ServerConfiguration::pathSubstitutions() const { return m_pathSubstitutions; }
void ServerConfiguration::setPathSubstitutions(QList<QSharedPointer<PathSubstitution>> newPathSubstitutions) {
void ServerConfiguration::setPathSubstitutions(QList<PathSubstitution> newPathSubstitutions) {
m_pathSubstitutions = newPathSubstitutions;
}
bool ServerConfiguration::pathSubstitutionsNull() const {

16
core/src/dto/sessioninfo.cpp
View file

@ -106,7 +106,7 @@ SessionInfo SessionInfo::fromJson(QJsonObject source) {
void SessionInfo::setFromJson(QJsonObject source) {
m_playState = Jellyfin::Support::fromJsonValue<QSharedPointer<PlayerStateInfo>>(source["PlayState"]);
m_additionalUsers = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<SessionUserInfo>>>(source["AdditionalUsers"]);
m_additionalUsers = Jellyfin::Support::fromJsonValue<QList<SessionUserInfo>>(source["AdditionalUsers"]);
m_capabilities = Jellyfin::Support::fromJsonValue<QSharedPointer<ClientCapabilities>>(source["Capabilities"]);
m_remoteEndPoint = Jellyfin::Support::fromJsonValue<QString>(source["RemoteEndPoint"]);
m_playableMediaTypes = Jellyfin::Support::fromJsonValue<QStringList>(source["PlayableMediaTypes"]);
@ -127,7 +127,7 @@ void SessionInfo::setFromJson(QJsonObject source) {
m_isActive = Jellyfin::Support::fromJsonValue<bool>(source["IsActive"]);
m_supportsMediaControl = Jellyfin::Support::fromJsonValue<bool>(source["SupportsMediaControl"]);
m_supportsRemoteControl = Jellyfin::Support::fromJsonValue<bool>(source["SupportsRemoteControl"]);
m_nowPlayingQueue = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<QueueItem>>>(source["NowPlayingQueue"]);
m_nowPlayingQueue = Jellyfin::Support::fromJsonValue<QList<QueueItem>>(source["NowPlayingQueue"]);
m_hasCustomDeviceName = Jellyfin::Support::fromJsonValue<bool>(source["HasCustomDeviceName"]);
m_playlistItemId = Jellyfin::Support::fromJsonValue<QString>(source["PlaylistItemId"]);
m_serverId = Jellyfin::Support::fromJsonValue<QString>(source["ServerId"]);
@ -139,7 +139,7 @@ void SessionInfo::setFromJson(QJsonObject source) {
QJsonObject SessionInfo::toJson() {
QJsonObject result;
result["PlayState"] = Jellyfin::Support::toJsonValue<QSharedPointer<PlayerStateInfo>>(m_playState);
result["AdditionalUsers"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<SessionUserInfo>>>(m_additionalUsers);
result["AdditionalUsers"] = Jellyfin::Support::toJsonValue<QList<SessionUserInfo>>(m_additionalUsers);
result["Capabilities"] = Jellyfin::Support::toJsonValue<QSharedPointer<ClientCapabilities>>(m_capabilities);
result["RemoteEndPoint"] = Jellyfin::Support::toJsonValue<QString>(m_remoteEndPoint);
result["PlayableMediaTypes"] = Jellyfin::Support::toJsonValue<QStringList>(m_playableMediaTypes);
@ -160,7 +160,7 @@ QJsonObject SessionInfo::toJson() {
result["IsActive"] = Jellyfin::Support::toJsonValue<bool>(m_isActive);
result["SupportsMediaControl"] = Jellyfin::Support::toJsonValue<bool>(m_supportsMediaControl);
result["SupportsRemoteControl"] = Jellyfin::Support::toJsonValue<bool>(m_supportsRemoteControl);
result["NowPlayingQueue"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<QueueItem>>>(m_nowPlayingQueue);
result["NowPlayingQueue"] = Jellyfin::Support::toJsonValue<QList<QueueItem>>(m_nowPlayingQueue);
result["HasCustomDeviceName"] = Jellyfin::Support::toJsonValue<bool>(m_hasCustomDeviceName);
result["PlaylistItemId"] = Jellyfin::Support::toJsonValue<QString>(m_playlistItemId);
result["ServerId"] = Jellyfin::Support::toJsonValue<QString>(m_serverId);
@ -176,9 +176,9 @@ void SessionInfo::setPlayState(QSharedPointer<PlayerStateInfo> newPlayState) {
m_playState = newPlayState;
}
QList<QSharedPointer<SessionUserInfo>> SessionInfo::additionalUsers() const { return m_additionalUsers; }
QList<SessionUserInfo> SessionInfo::additionalUsers() const { return m_additionalUsers; }
void SessionInfo::setAdditionalUsers(QList<QSharedPointer<SessionUserInfo>> newAdditionalUsers) {
void SessionInfo::setAdditionalUsers(QList<SessionUserInfo> newAdditionalUsers) {
m_additionalUsers = newAdditionalUsers;
}
bool SessionInfo::additionalUsersNull() const {
@ -372,9 +372,9 @@ void SessionInfo::setSupportsRemoteControl(bool newSupportsRemoteControl) {
m_supportsRemoteControl = newSupportsRemoteControl;
}
QList<QSharedPointer<QueueItem>> SessionInfo::nowPlayingQueue() const { return m_nowPlayingQueue; }
QList<QueueItem> SessionInfo::nowPlayingQueue() const { return m_nowPlayingQueue; }
void SessionInfo::setNowPlayingQueue(QList<QSharedPointer<QueueItem>> newNowPlayingQueue) {
void SessionInfo::setNowPlayingQueue(QList<QueueItem> newNowPlayingQueue) {
m_nowPlayingQueue = newNowPlayingQueue;
}
bool SessionInfo::nowPlayingQueueNull() const {

8
core/src/dto/systeminfo.cpp
View file

@ -114,7 +114,7 @@ void SystemInfo::setFromJson(QJsonObject source) {
m_isShuttingDown = Jellyfin::Support::fromJsonValue<bool>(source["IsShuttingDown"]);
m_supportsLibraryMonitor = Jellyfin::Support::fromJsonValue<bool>(source["SupportsLibraryMonitor"]);
m_webSocketPortNumber = Jellyfin::Support::fromJsonValue<qint32>(source["WebSocketPortNumber"]);
m_completedInstallations = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<InstallationInfo>>>(source["CompletedInstallations"]);
m_completedInstallations = Jellyfin::Support::fromJsonValue<QList<InstallationInfo>>(source["CompletedInstallations"]);
m_canSelfRestart = Jellyfin::Support::fromJsonValue<bool>(source["CanSelfRestart"]);
m_canLaunchWebBrowser = Jellyfin::Support::fromJsonValue<bool>(source["CanLaunchWebBrowser"]);
m_programDataPath = Jellyfin::Support::fromJsonValue<QString>(source["ProgramDataPath"]);
@ -145,7 +145,7 @@ QJsonObject SystemInfo::toJson() {
result["IsShuttingDown"] = Jellyfin::Support::toJsonValue<bool>(m_isShuttingDown);
result["SupportsLibraryMonitor"] = Jellyfin::Support::toJsonValue<bool>(m_supportsLibraryMonitor);
result["WebSocketPortNumber"] = Jellyfin::Support::toJsonValue<qint32>(m_webSocketPortNumber);
result["CompletedInstallations"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<InstallationInfo>>>(m_completedInstallations);
result["CompletedInstallations"] = Jellyfin::Support::toJsonValue<QList<InstallationInfo>>(m_completedInstallations);
result["CanSelfRestart"] = Jellyfin::Support::toJsonValue<bool>(m_canSelfRestart);
result["CanLaunchWebBrowser"] = Jellyfin::Support::toJsonValue<bool>(m_canLaunchWebBrowser);
result["ProgramDataPath"] = Jellyfin::Support::toJsonValue<QString>(m_programDataPath);
@ -303,9 +303,9 @@ void SystemInfo::setWebSocketPortNumber(qint32 newWebSocketPortNumber) {
m_webSocketPortNumber = newWebSocketPortNumber;
}
QList<QSharedPointer<InstallationInfo>> SystemInfo::completedInstallations() const { return m_completedInstallations; }
QList<InstallationInfo> SystemInfo::completedInstallations() const { return m_completedInstallations; }
void SystemInfo::setCompletedInstallations(QList<QSharedPointer<InstallationInfo>> newCompletedInstallations) {
void SystemInfo::setCompletedInstallations(QList<InstallationInfo> newCompletedInstallations) {
m_completedInstallations = newCompletedInstallations;
}
bool SystemInfo::completedInstallationsNull() const {

8
core/src/dto/taskinfo.cpp
View file

@ -74,7 +74,7 @@ void TaskInfo::setFromJson(QJsonObject source) {
m_currentProgressPercentage = Jellyfin::Support::fromJsonValue<std::optional<double>>(source["CurrentProgressPercentage"]);
m_jellyfinId = Jellyfin::Support::fromJsonValue<QString>(source["Id"]);
m_lastExecutionResult = Jellyfin::Support::fromJsonValue<QSharedPointer<TaskResult>>(source["LastExecutionResult"]);
m_triggers = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<TaskTriggerInfo>>>(source["Triggers"]);
m_triggers = Jellyfin::Support::fromJsonValue<QList<TaskTriggerInfo>>(source["Triggers"]);
m_description = Jellyfin::Support::fromJsonValue<QString>(source["Description"]);
m_category = Jellyfin::Support::fromJsonValue<QString>(source["Category"]);
m_isHidden = Jellyfin::Support::fromJsonValue<bool>(source["IsHidden"]);
@ -89,7 +89,7 @@ QJsonObject TaskInfo::toJson() {
result["CurrentProgressPercentage"] = Jellyfin::Support::toJsonValue<std::optional<double>>(m_currentProgressPercentage);
result["Id"] = Jellyfin::Support::toJsonValue<QString>(m_jellyfinId);
result["LastExecutionResult"] = Jellyfin::Support::toJsonValue<QSharedPointer<TaskResult>>(m_lastExecutionResult);
result["Triggers"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<TaskTriggerInfo>>>(m_triggers);
result["Triggers"] = Jellyfin::Support::toJsonValue<QList<TaskTriggerInfo>>(m_triggers);
result["Description"] = Jellyfin::Support::toJsonValue<QString>(m_description);
result["Category"] = Jellyfin::Support::toJsonValue<QString>(m_category);
result["IsHidden"] = Jellyfin::Support::toJsonValue<bool>(m_isHidden);
@ -149,9 +149,9 @@ void TaskInfo::setLastExecutionResult(QSharedPointer<TaskResult> newLastExecutio
m_lastExecutionResult = newLastExecutionResult;
}
QList<QSharedPointer<TaskTriggerInfo>> TaskInfo::triggers() const { return m_triggers; }
QList<TaskTriggerInfo> TaskInfo::triggers() const { return m_triggers; }
void TaskInfo::setTriggers(QList<QSharedPointer<TaskTriggerInfo>> newTriggers) {
void TaskInfo::setTriggers(QList<TaskTriggerInfo> newTriggers) {
m_triggers = newTriggers;
}
bool TaskInfo::triggersNull() const {

8
core/src/dto/thememediaresult.cpp
View file

@ -57,7 +57,7 @@ ThemeMediaResult ThemeMediaResult::fromJson(QJsonObject source) {
void ThemeMediaResult::setFromJson(QJsonObject source) {
m_items = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<BaseItemDto>>>(source["Items"]);
m_items = Jellyfin::Support::fromJsonValue<QList<BaseItemDto>>(source["Items"]);
m_totalRecordCount = Jellyfin::Support::fromJsonValue<qint32>(source["TotalRecordCount"]);
m_startIndex = Jellyfin::Support::fromJsonValue<qint32>(source["StartIndex"]);
m_ownerId = Jellyfin::Support::fromJsonValue<QString>(source["OwnerId"]);
@ -66,7 +66,7 @@ void ThemeMediaResult::setFromJson(QJsonObject source) {
QJsonObject ThemeMediaResult::toJson() {
QJsonObject result;
result["Items"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<BaseItemDto>>>(m_items);
result["Items"] = Jellyfin::Support::toJsonValue<QList<BaseItemDto>>(m_items);
result["TotalRecordCount"] = Jellyfin::Support::toJsonValue<qint32>(m_totalRecordCount);
result["StartIndex"] = Jellyfin::Support::toJsonValue<qint32>(m_startIndex);
result["OwnerId"] = Jellyfin::Support::toJsonValue<QString>(m_ownerId);
@ -74,9 +74,9 @@ QJsonObject ThemeMediaResult::toJson() {
return result;
}
QList<QSharedPointer<BaseItemDto>> ThemeMediaResult::items() const { return m_items; }
QList<BaseItemDto> ThemeMediaResult::items() const { return m_items; }
void ThemeMediaResult::setItems(QList<QSharedPointer<BaseItemDto>> newItems) {
void ThemeMediaResult::setItems(QList<BaseItemDto> newItems) {
m_items = newItems;
}
bool ThemeMediaResult::itemsNull() const {

8
core/src/dto/timerinfodtoqueryresult.cpp
View file

@ -55,7 +55,7 @@ TimerInfoDtoQueryResult TimerInfoDtoQueryResult::fromJson(QJsonObject source) {
void TimerInfoDtoQueryResult::setFromJson(QJsonObject source) {
m_items = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<TimerInfoDto>>>(source["Items"]);
m_items = Jellyfin::Support::fromJsonValue<QList<TimerInfoDto>>(source["Items"]);
m_totalRecordCount = Jellyfin::Support::fromJsonValue<qint32>(source["TotalRecordCount"]);
m_startIndex = Jellyfin::Support::fromJsonValue<qint32>(source["StartIndex"]);
@ -63,16 +63,16 @@ void TimerInfoDtoQueryResult::setFromJson(QJsonObject source) {
QJsonObject TimerInfoDtoQueryResult::toJson() {
QJsonObject result;
result["Items"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<TimerInfoDto>>>(m_items);
result["Items"] = Jellyfin::Support::toJsonValue<QList<TimerInfoDto>>(m_items);
result["TotalRecordCount"] = Jellyfin::Support::toJsonValue<qint32>(m_totalRecordCount);
result["StartIndex"] = Jellyfin::Support::toJsonValue<qint32>(m_startIndex);
return result;
}
QList<QSharedPointer<TimerInfoDto>> TimerInfoDtoQueryResult::items() const { return m_items; }
QList<TimerInfoDto> TimerInfoDtoQueryResult::items() const { return m_items; }
void TimerInfoDtoQueryResult::setItems(QList<QSharedPointer<TimerInfoDto>> newItems) {
void TimerInfoDtoQueryResult::setItems(QList<TimerInfoDto> newItems) {
m_items = newItems;
}
bool TimerInfoDtoQueryResult::itemsNull() const {

8
core/src/dto/typeoptions.cpp
View file

@ -66,7 +66,7 @@ void TypeOptions::setFromJson(QJsonObject source) {
m_metadataFetcherOrder = Jellyfin::Support::fromJsonValue<QStringList>(source["MetadataFetcherOrder"]);
m_imageFetchers = Jellyfin::Support::fromJsonValue<QStringList>(source["ImageFetchers"]);
m_imageFetcherOrder = Jellyfin::Support::fromJsonValue<QStringList>(source["ImageFetcherOrder"]);
m_imageOptions = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<ImageOption>>>(source["ImageOptions"]);
m_imageOptions = Jellyfin::Support::fromJsonValue<QList<ImageOption>>(source["ImageOptions"]);
}
@ -77,7 +77,7 @@ QJsonObject TypeOptions::toJson() {
result["MetadataFetcherOrder"] = Jellyfin::Support::toJsonValue<QStringList>(m_metadataFetcherOrder);
result["ImageFetchers"] = Jellyfin::Support::toJsonValue<QStringList>(m_imageFetchers);
result["ImageFetcherOrder"] = Jellyfin::Support::toJsonValue<QStringList>(m_imageFetcherOrder);
result["ImageOptions"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<ImageOption>>>(m_imageOptions);
result["ImageOptions"] = Jellyfin::Support::toJsonValue<QList<ImageOption>>(m_imageOptions);
return result;
}
@ -147,9 +147,9 @@ void TypeOptions::setImageFetcherOrderNull() {
m_imageFetcherOrder.clear();
}
QList<QSharedPointer<ImageOption>> TypeOptions::imageOptions() const { return m_imageOptions; }
QList<ImageOption> TypeOptions::imageOptions() const { return m_imageOptions; }
void TypeOptions::setImageOptions(QList<QSharedPointer<ImageOption>> newImageOptions) {
void TypeOptions::setImageOptions(QList<ImageOption> newImageOptions) {
m_imageOptions = newImageOptions;
}
bool TypeOptions::imageOptionsNull() const {

8
core/src/dto/userpolicy.cpp
View file

@ -133,7 +133,7 @@ void UserPolicy::setFromJson(QJsonObject source) {
m_maxParentalRating = Jellyfin::Support::fromJsonValue<std::optional<qint32>>(source["MaxParentalRating"]);
m_blockedTags = Jellyfin::Support::fromJsonValue<QStringList>(source["BlockedTags"]);
m_enableUserPreferenceAccess = Jellyfin::Support::fromJsonValue<bool>(source["EnableUserPreferenceAccess"]);
m_accessSchedules = Jellyfin::Support::fromJsonValue<QList<QSharedPointer<AccessSchedule>>>(source["AccessSchedules"]);
m_accessSchedules = Jellyfin::Support::fromJsonValue<QList<AccessSchedule>>(source["AccessSchedules"]);
m_blockUnratedItems = Jellyfin::Support::fromJsonValue<QList<UnratedItem>>(source["BlockUnratedItems"]);
m_enableRemoteControlOfOtherUsers = Jellyfin::Support::fromJsonValue<bool>(source["EnableRemoteControlOfOtherUsers"]);
m_enableSharedDeviceControl = Jellyfin::Support::fromJsonValue<bool>(source["EnableSharedDeviceControl"]);
@ -177,7 +177,7 @@ QJsonObject UserPolicy::toJson() {
result["MaxParentalRating"] = Jellyfin::Support::toJsonValue<std::optional<qint32>>(m_maxParentalRating);
result["BlockedTags"] = Jellyfin::Support::toJsonValue<QStringList>(m_blockedTags);
result["EnableUserPreferenceAccess"] = Jellyfin::Support::toJsonValue<bool>(m_enableUserPreferenceAccess);
result["AccessSchedules"] = Jellyfin::Support::toJsonValue<QList<QSharedPointer<AccessSchedule>>>(m_accessSchedules);
result["AccessSchedules"] = Jellyfin::Support::toJsonValue<QList<AccessSchedule>>(m_accessSchedules);
result["BlockUnratedItems"] = Jellyfin::Support::toJsonValue<QList<UnratedItem>>(m_blockUnratedItems);
result["EnableRemoteControlOfOtherUsers"] = Jellyfin::Support::toJsonValue<bool>(m_enableRemoteControlOfOtherUsers);
result["EnableSharedDeviceControl"] = Jellyfin::Support::toJsonValue<bool>(m_enableSharedDeviceControl);
@ -264,9 +264,9 @@ void UserPolicy::setEnableUserPreferenceAccess(bool newEnableUserPreferenceAcces
m_enableUserPreferenceAccess = newEnableUserPreferenceAccess;
}
QList<QSharedPointer<AccessSchedule>> UserPolicy::accessSchedules() const { return m_accessSchedules; }
QList<AccessSchedule> UserPolicy::accessSchedules() const { return m_accessSchedules; }
void UserPolicy::setAccessSchedules(QList<QSharedPointer<AccessSchedule>> newAccessSchedules) {
void UserPolicy::setAccessSchedules(QList<AccessSchedule> newAccessSchedules) {
m_accessSchedules = newAccessSchedules;
}
bool UserPolicy::accessSchedulesNull() const {