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

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

9
core/src/apiclient.cpp
View file

@ -233,7 +233,14 @@ void ApiClient::deleteSession() {
void ApiClient::postCapabilities() {
QJsonObject capabilities;
capabilities["SupportedCommands"] = Support::toJsonValue(m_supportedCommands);
QList<DTO::GeneralCommandType> supportedCommands;
supportedCommands.reserve(m_supportedCommands.size());
for (int i = 0; i < m_supportedCommands.size(); i++) {
if (m_supportedCommands[i].canConvert<DTO::GeneralCommandType>()) {
supportedCommands.append(m_supportedCommands[i].value<DTO::GeneralCommandType>());
}
}
capabilities["SupportedCommands"] = Support::toJsonValue(supportedCommands);
capabilities["SupportsPersistentIdentifier"] = true;
capabilities["SupportsMediaControl"] = false;
capabilities["SupportsSync"] = false;

444
core/src/apimodel.cpp
View file

@ -32,424 +32,74 @@ namespace DTO {
}
using User = DTO::UserDto;
BaseApiModel::BaseApiModel(QString path, bool hasRecordResponse, bool addUserId, QObject *parent)
: QAbstractListModel(parent),
m_path(path),
m_hasRecordResponse(hasRecordResponse),
m_addUserId(addUserId) {
BaseModelLoader::BaseModelLoader(QObject *parent)
: QObject(parent) { }
void BaseModelLoader::classBegin() {
m_isBeingParsed = true;
}
void BaseApiModel::setApiClient(ApiClient *apiClient) {
m_apiClient = apiClient;
emit apiClientChanged(m_apiClient);
void BaseModelLoader::componentComplete() {
m_isBeingParsed = false;
autoReloadIfNeeded();
}
void BaseApiModel::setLimit(int newLimit) {
void BaseModelLoader::autoReloadIfNeeded() {
if (m_autoReload && m_apiClient != nullptr) {
emit reloadWanted();
}
}
void BaseModelLoader::setApiClient(ApiClient *newApiClient) {
bool changed = this->m_apiClient != newApiClient;
m_apiClient = newApiClient;
if (changed) {
emit apiClientChanged(newApiClient);
}
}
void BaseModelLoader::setLimit(int newLimit) {
int oldLimit = this->m_limit;
m_limit = newLimit;
emit limitChanged(newLimit);
if (m_apiClient != nullptr && !m_isBeingParsed) {
load(LOAD_MORE);
if (oldLimit != this->m_limit) {
emit limitChanged(this->m_limit);
}
}
void BaseModelLoader::setAutoReload(bool newAutoReload) {
if (m_autoReload != newAutoReload) {
m_autoReload = newAutoReload;
emit autoReloadChanged(newAutoReload);
}
}
void BaseApiModel::reload() {
this->setStatus(Loading);
m_startIndex = 0;
load(RELOAD);
qWarning() << " BaseApiModel slot called instead of overloaded method";
}
void BaseApiModel::load(LoadType type) {
qDebug() << (type == RELOAD ? "RELOAD" : "LOAD_MORE");
if (m_apiClient == nullptr) {
qWarning() << "Please set the apiClient property before (re)loading";
return;
}
QString path(m_path);
replacePathPlaceholders(path);
QUrlQuery query;
addQueryParameters(query);
QNetworkReply *rep = m_apiClient->get(path, query);
connect(rep, &QNetworkReply::finished, this, [this, type, rep]() {
qDebug() << rep->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() << ": " << rep->request().url();
QJsonDocument doc = QJsonDocument::fromJson(rep->readAll());
if (doc.isNull()) {
qWarning() << "JSON parse error";
this->setStatus(Error);
}
if (!m_hasRecordResponse) {
if (!doc.isArray()) {
qWarning() << "Object is not an array!";
this->setStatus(Error);
return;
}
QJsonArray items = doc.array();
setModelData(items);
} else {
if (!doc.isObject()) {
qWarning() << "Object is not an object!";
this->setStatus(Error);
return;
}
QJsonObject obj = doc.object();
if (!obj.contains("Items")) {
qWarning() << "Object doesn't contain items!";
this->setStatus(Error);
return;
}
if (m_limit < 0) {
// Javascript is beautiful
if (obj.contains("TotalRecordCount") && obj["TotalRecordCount"].isDouble()) {
m_totalRecordCount = obj["TotalRecordCount"].toInt();
m_startIndex += DEFAULT_LIMIT;
} else {
qWarning() << "Record-response does not have a total record count";
this->setStatus(Error);
return;
}
}
if (!obj["Items"].isArray()) {
qWarning() << "Items is not an array!";
this->setStatus(Error);
return;
}
QJsonArray items = obj["Items"].toArray();
switch(type) {
case RELOAD:
setModelData(items);
break;
case LOAD_MORE:
appendModelData(items);
break;
}
}
this->setStatus(Ready);
rep->deleteLater();
});
void setStartIndex(Loader::GetUserViewsParams &params, int startIndex) {
// Not supported
Q_UNUSED(params)
Q_UNUSED(startIndex)
}
void BaseApiModel::addQueryParameters(QUrlQuery &query) {
if (m_limit >= 0) {
query.addQueryItem("Limit", QString::number(m_limit));
} else {
query.addQueryItem("Limit", QString::number(DEFAULT_LIMIT));
}
if (m_startIndex > 0) {
query.addQueryItem("StartIndex", QString::number(m_startIndex));
}
if (!m_sortBy.empty()) {
query.addQueryItem("SortBy", m_sortBy.join(","));
}
if (m_sortOrder != Unspecified) {
query.addQueryItem("SortOrder", m_sortOrder == Ascending ? "Ascending" : "Descending");
}
if (!m_fields.empty()) {
query.addQueryItem("Fields", m_fields.join(","));
}
if (m_addUserId) {
query.addQueryItem("userId", m_apiClient->userId());
}
void setLimit(Loader::GetUserViewsParams &params, int limit) {
Q_UNUSED(params)
Q_UNUSED(limit)
}
void BaseApiModel::replacePathPlaceholders(QString &path) {
if (path.contains("{{user}}")) {
path = path.replace("{{user}}", m_apiClient->userId());
}
QList<DTO::BaseItemDto> extractRecords(const DTO::BaseItemDtoQueryResult &result) {
return result.items();
}
void BaseApiModel::classBegin() {
m_isBeingParsed = true;
int extractTotalRecordCount(const DTO::BaseItemDtoQueryResult &result) {
return result.totalRecordCount();
}
void BaseApiModel::componentComplete() {
m_isBeingParsed = false;
}
// ApiModel
template <class T>
ApiModel<T>::ApiModel(QString path, bool hasRecordResponse, bool addUserId, QObject *parent)
: BaseApiModel(path, hasRecordResponse, addUserId, parent) {
// If based on QObject, we know our role names before the first request
generateFields();
}
template <>
ApiModel<QJsonValue>::ApiModel(QString path, bool hasRecordResponse, bool addUserId, QObject *parent)
: BaseApiModel(path, hasRecordResponse, addUserId, parent) {
// But we only know our role names after our first request.
}
template <class T>
T *ApiModel<T>::deserializeResult(QJsonValueRef source) {
T *result = T::fromJSON(source.toObject(), this);
return result;
}
template <>
QJsonValue *ApiModel<QJsonValue>::deserializeResult(QJsonValueRef source) {
QJsonValue *result = new QJsonValue(source);
JsonHelper::convertToCamelCase(*result);
return result;
}
template <class T>
void ApiModel<T>::generateFields() {
const QMetaObject *obj = &T::staticMetaObject;
m_roles[Qt::UserRole + 1] = "qtObject";
for (int i = 0; i < obj->propertyCount(); i++) {
QMetaProperty property = obj->property(i);
m_roles.insert(Qt::UserRole + 2 + i, property.name());
}
}
template <>
void ApiModel<QJsonValue>::generateFields() {
// We can only generate field names if there is a first item. Redefining role names later leads to
// unexpected results, so prevent it as well.
if (m_array.size() == 0 || m_roles.size() > 0) return;
int i = Qt::UserRole + 1;
if (!m_array[0]->isObject()) {
qWarning() << "Iterator is not an object?";
return;
}
// Walks over the keys in the first record and adds them to the rolenames.
// This assumes the back-end has the same keys for every record. I could technically
// go over all records to be really sure, but no-one got time for a O(n) algorithm, so
// this heuristic hopefully suffices.
QJsonObject ob = m_array[0]->toObject();
for (auto jt = ob.begin(); jt != ob.end(); jt++) {
QString keyName = jt.key();
keyName[0] = keyName[0].toLower();
QByteArray keyArr = keyName.toUtf8();
if (!m_roles.values().contains(keyArr)) {
m_roles.insert(i++, keyArr);
}
}
}
template <class T>
void ApiModel<T>::setModelData(QJsonArray &data) {
this->beginResetModel();
for (T* value : m_array) {
value->deleteLater();
}
m_array.clear();
for(QJsonValueRef value : data) {
m_array.append(deserializeResult(value));
}
this->endResetModel();
}
template <>
void ApiModel<QJsonValue>::setModelData(QJsonArray &data) {
generateFields();
this->beginResetModel();
for (QJsonValue* value : m_array) {
delete value;
}
m_array.clear();
for(QJsonValueRef value : data) {
m_array.append(deserializeResult(value));
}
this->endResetModel();
}
template <class T>
void ApiModel<T>::appendModelData(QJsonArray &data) {
this->beginInsertRows(QModelIndex(), m_array.size(), m_array.size() + data.size() - 1);
// QJsonArray apparently doesn't allow concatenating lists like QList or std::vector
for (auto it = data.begin(); it != data.end(); it++) {
JsonHelper::convertToCamelCase(*it);
}
for(QJsonValueRef val : data) {
m_array.append(deserializeResult(val));
}
this->endInsertRows();
}
template <class T>
QVariant ApiModel<T>::data(const QModelIndex &index, int role) const {
// Ignore roles we don't know
if (role <= Qt::UserRole || role >= Qt::UserRole + m_roles.size()) return QVariant();
// Ignore invalid indices.
if (!index.isValid()) return QVariant();
T* obj = m_array.at(index.row());
// m_roleNames[role] == "qtObject"
if (role == Qt::UserRole + 1) {
return QVariant::fromValue(obj);
}
const QString &key = m_roles[role];
if (role - Qt::UserRole - 2 < obj->metaObject()->propertyCount() ) {
return obj->property(key.toLocal8Bit());
}
return QVariant();
}
template <>
QVariant ApiModel<QJsonValue>::data(const QModelIndex &index, int role) const {
// Ignore roles we don't know
if (role <= Qt::UserRole || role >= Qt::UserRole + m_roles.size()) return QVariant();
// Ignore invalid indices.
if (!index.isValid()) return QVariant();
QJsonObject obj = m_array.at(index.row())->toObject();
const QString &key = m_roles[role];
if (obj.contains(key)) {
return obj[key].toVariant();
}
return QVariant();
}
template <class T>
bool ApiModel<T>::canFetchMore(const QModelIndex &parent) const {
if (parent.isValid()) return false;
switch(m_status) {
case Uninitialised:
case Loading:
case LoadingMore:
return false;
default:
break;
}
if (m_limit < 0) {
return m_startIndex <= m_totalRecordCount;
} else {
return false;
}
}
template <class T>
void ApiModel<T>::fetchMore(const QModelIndex &parent) {
if (parent.isValid()) return;
this->setStatus(LoadingMore);
load(LOAD_MORE);
}
template <class T>
void ApiModel<T>::addQueryParameters(QUrlQuery &query) {
BaseApiModel::addQueryParameters(query);
}
template <class T>
void ApiModel<T>::replacePathPlaceholders(QString &path) {
BaseApiModel::replacePathPlaceholders(path);
}
template <class T>
void ApiModel<T>::insert(int index, T* object) {
Q_ASSERT(index >=0 && index <= size());
this->beginInsertRows(QModelIndex(), index, index);
m_array.insert(index, object);
this->endInsertRows();
}
template <class T>
void ApiModel<T>::removeAt(int index) {
this->beginRemoveRows(QModelIndex(), index, index);
m_array.removeAt(index);
this->endRemoveRows();
}
template <class T>
void ApiModel<T>::removeOne(T* object) {
int idx = m_array.indexOf(object);
if (idx >= 0) {
removeAt(idx);
}
}
// Itemmodel
ItemModel::ItemModel(QString path, bool hasRecordFields, bool replaceUser, QObject *parent)
: ApiModel (path, hasRecordFields, replaceUser, parent){
QObject::connect(this, &BaseApiModel::apiClientChanged, static_cast<BaseApiModel *>(this), [this](ApiClient *newApiClient) {
QObject::connect(newApiClient, &ApiClient::userDataChanged, this, &ItemModel::onUserDataChanged);
});
}
void ItemModel::onUserDataChanged(const QString &itemId, DTO::UserData *userData) {
int i = 0;
/*for (DTO::BaseItemDto *val: m_array) {
if (val->userData() != nullptr && val->jellyfinId() == itemId) {
QModelIndex cell = this->index(i);
// val->userData()->onUpdated(userData);
this->dataChanged(cell, cell);
}
i++;
}*/
}
void ItemModel::addQueryParameters(QUrlQuery &query) {
ApiModel<QJsonValue>::addQueryParameters(query);
if (!m_parentId.isEmpty()) {
query.addQueryItem("ParentId", m_parentId);
}
if (!m_imageTypes.empty()) {
query.addQueryItem("ImageTypes", m_imageTypes.join(","));
}
if (!m_includeItemTypes.empty()) {
query.addQueryItem("IncludeItemTypes", m_includeItemTypes.join(","));
}
if (!m_seasonId.isEmpty()) {
query.addQueryItem("seasonId", m_seasonId);
}
if (m_recursive) {
query.addQueryItem("Recursive", "true");
}
}
void ItemModel::replacePathPlaceholders(QString &path) {
ApiModel::replacePathPlaceholders(path);
if (path.contains("{{show}}") && !m_show.isEmpty()) {
path = m_path.replace("{{show}}", m_show);
}
}
PublicUserModel::PublicUserModel(QObject *parent)
: ApiModel ("/users/public", false, false, parent) { }
UserViewModel::UserViewModel(QObject *parent)
: ItemModel ("/Users/{{user}}/Views", true, false, parent) {}
UserItemModel::UserItemModel(QObject *parent)
: ItemModel ("/Users/{{user}}/Items", true, false, parent) {}
UserItemResumeModel::UserItemResumeModel(QObject *parent)
: ItemModel ("/Users/{{user}}/Items/Resume", true, false, parent) {}
UserItemLatestModel::UserItemLatestModel(QObject *parent)
: ItemModel ("/Users/{{user}}/Items/Latest", false, false, parent) {}
ShowNextUpModel::ShowNextUpModel(QObject *parent)
: ItemModel("/Shows/NextUp", true, true, parent) {}
ShowSeasonsModel::ShowSeasonsModel(QObject *parent)
: ItemModel ("/Shows/{{show}}/Seasons", true, true, parent) {}
ShowEpisodesModel::ShowEpisodesModel(QObject *parent)
: ItemModel ("/Shows/{{show}}/Episodes", true, true, parent) {}
void registerModels(const char *URI) {
qmlRegisterUncreatableType<BaseApiModel>(URI, 1, 0, "ApiModel", "Is enum and base class");
qmlRegisterUncreatableType<SortOptions>(URI, 1, 0, "SortOptions", "Is enum");
qmlRegisterType<PublicUserModel>(URI, 1, 0, "PublicUserModel");
qmlRegisterType<UserViewModel>(URI, 1, 0, "UserViewModel");
qmlRegisterType<UserItemModel>(URI, 1, 0, "UserItemModel");
qmlRegisterType<UserItemLatestModel>(URI, 1, 0, "UserItemLatestModel");
qmlRegisterType<UserItemResumeModel>(URI, 1, 0, "UserItemResumeModel");
qmlRegisterType<ShowNextUpModel>(URI, 1, 0, "ShowNextUpModel");
qmlRegisterType<ShowSeasonsModel>(URI, 1, 0, "ShowSeasonsModel");
qmlRegisterType<ShowEpisodesModel>(URI, 1, 0, "ShowEpisodesModel");
Q_UNUSED(URI)
//qmlRegisterUncreatableType<ApiModel>(URI, 1, 0, "ApiModel", "Is enum and base class");
//qmlRegisterType<PublicUserModel>(URI, 1, 0, "PublicUserModel");
}
}

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 {

5
core/src/jellyfin.cpp
View file

@ -24,7 +24,12 @@ void registerTypes(const char *uri) {
qmlRegisterType<ServerDiscoveryModel>(uri, 1, 0, "ServerDiscoveryModel");
qmlRegisterUncreatableType<ViewModel::Item>(uri, 1, 0, "Item", "Acquire one via ItemLoader or exposed properties");
qmlRegisterUncreatableType<BaseApiModel>(uri, 1, 0, "BaseApiModel", "Please use one of its subclasses");
qmlRegisterUncreatableType<BaseModelLoader>(uri, 1, 0, "BaseModelLoader", "Please use one of its subclasses");
qmlRegisterUncreatableType<ModelStatusClass>(uri, 1, 0, "ModelStatus", "Is an enum");
qmlRegisterType<ViewModel::ItemLoader>(uri, 1, 0, "ItemLoader");
qmlRegisterType<ViewModel::ItemModel>(uri, 1, 0, "ItemModel");
qmlRegisterType<ViewModel::UserViewsLoader>(uri, 1, 0, "UsersViewLoader");
qmlRegisterType<ViewModel::PlaybackManager>(uri, 1, 0, "PlaybackManager");
qmlRegisterUncreatableType<DTO::GeneralCommandTypeClass>(uri, 1, 0, "GeneralCommandType", "Is an enum");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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