chris/harbour-sailfin
chris/harbour-sailfin
1
0
Fork 0
mirror of https://github.com/HenkKalkwater/harbour-sailfin.git synced 2024-05-09 15:42:42 +00:00
Code Issues Releases Wiki Activity
harbour-sailfin/core/src/dto/timerinfodto.cpp
Chris Josten 90db983c30 Replace not-fully-initializing DTO constructors 
There were some constructors in the DTOs which allowed construction of
DTO which weren't fully initialized. These constructors have been made
private, as they are still used in the 'fromJson' methods. Additionally,
a constructor with all required parameters to fully initialize the
class has been added.

Additionally, the Loader class has been modified, since it no longer can
assume it is able to default construct the parameter type. The parameter
is now stored as an optional.

Closes #15
2021-09-25 17:07:12 +02:00

574 lines
18 KiB
C++
Raw Permalink Blame History

/*
* Sailfin: a Jellyfin client written using Qt
* Copyright (C) 2021 Chris Josten and the Sailfin Contributors.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
* WARNING: THIS IS AN AUTOMATICALLY GENERATED FILE! PLEASE DO NOT EDIT THIS, AS YOUR EDITS WILL GET
* OVERWRITTEN AT SOME POINT!
*
* If there is a bug in this file, please fix the code generator used to generate this file found in
* core/openapigenerator.d.
*
* This file is generated based on Jellyfin's OpenAPI description, "openapi.json". Please update that
* file with a newer file if needed instead of manually updating the files.
*/
#include <JellyfinQt/dto/timerinfodto.h>
namespace Jellyfin {
namespace DTO {
TimerInfoDto::TimerInfoDto() {}
TimerInfoDto::TimerInfoDto (
QString channelId,
QDateTime startDate,
QDateTime endDate,
qint32 priority,
qint32 prePaddingSeconds,
qint32 postPaddingSeconds,
bool isPrePaddingRequired,
bool isPostPaddingRequired,
KeepUntil keepUntil,
RecordingStatus status,
QSharedPointer<BaseItemDto> programInfo
) :
m_channelId(channelId),
m_startDate(startDate),
m_endDate(endDate),
m_priority(priority),
m_prePaddingSeconds(prePaddingSeconds),
m_postPaddingSeconds(postPaddingSeconds),
m_isPrePaddingRequired(isPrePaddingRequired),
m_isPostPaddingRequired(isPostPaddingRequired),
m_keepUntil(keepUntil),
m_status(status),
m_programInfo(programInfo) { }
TimerInfoDto::TimerInfoDto(const TimerInfoDto &other) :
m_jellyfinId(other.m_jellyfinId),
m_type(other.m_type),
m_serverId(other.m_serverId),
m_externalId(other.m_externalId),
m_channelId(other.m_channelId),
m_externalChannelId(other.m_externalChannelId),
m_channelName(other.m_channelName),
m_channelPrimaryImageTag(other.m_channelPrimaryImageTag),
m_programId(other.m_programId),
m_externalProgramId(other.m_externalProgramId),
m_name(other.m_name),
m_overview(other.m_overview),
m_startDate(other.m_startDate),
m_endDate(other.m_endDate),
m_serviceName(other.m_serviceName),
m_priority(other.m_priority),
m_prePaddingSeconds(other.m_prePaddingSeconds),
m_postPaddingSeconds(other.m_postPaddingSeconds),
m_isPrePaddingRequired(other.m_isPrePaddingRequired),
m_parentBackdropItemId(other.m_parentBackdropItemId),
m_parentBackdropImageTags(other.m_parentBackdropImageTags),
m_isPostPaddingRequired(other.m_isPostPaddingRequired),
m_keepUntil(other.m_keepUntil),
m_status(other.m_status),
m_seriesTimerId(other.m_seriesTimerId),
m_externalSeriesTimerId(other.m_externalSeriesTimerId),
m_runTimeTicks(other.m_runTimeTicks),
m_programInfo(other.m_programInfo){}
void TimerInfoDto::replaceData(TimerInfoDto &other) {
m_jellyfinId = other.m_jellyfinId;
m_type = other.m_type;
m_serverId = other.m_serverId;
m_externalId = other.m_externalId;
m_channelId = other.m_channelId;
m_externalChannelId = other.m_externalChannelId;
m_channelName = other.m_channelName;
m_channelPrimaryImageTag = other.m_channelPrimaryImageTag;
m_programId = other.m_programId;
m_externalProgramId = other.m_externalProgramId;
m_name = other.m_name;
m_overview = other.m_overview;
m_startDate = other.m_startDate;
m_endDate = other.m_endDate;
m_serviceName = other.m_serviceName;
m_priority = other.m_priority;
m_prePaddingSeconds = other.m_prePaddingSeconds;
m_postPaddingSeconds = other.m_postPaddingSeconds;
m_isPrePaddingRequired = other.m_isPrePaddingRequired;
m_parentBackdropItemId = other.m_parentBackdropItemId;
m_parentBackdropImageTags = other.m_parentBackdropImageTags;
m_isPostPaddingRequired = other.m_isPostPaddingRequired;
m_keepUntil = other.m_keepUntil;
m_status = other.m_status;
m_seriesTimerId = other.m_seriesTimerId;
m_externalSeriesTimerId = other.m_externalSeriesTimerId;
m_runTimeTicks = other.m_runTimeTicks;
m_programInfo = other.m_programInfo;
}
TimerInfoDto TimerInfoDto::fromJson(QJsonObject source) {
TimerInfoDto instance;
instance.setFromJson(source);
return instance;
}
void TimerInfoDto::setFromJson(QJsonObject source) {
m_jellyfinId = Jellyfin::Support::fromJsonValue<QString>(source["Id"]);
m_type = Jellyfin::Support::fromJsonValue<QString>(source["Type"]);
m_serverId = Jellyfin::Support::fromJsonValue<QString>(source["ServerId"]);
m_externalId = Jellyfin::Support::fromJsonValue<QString>(source["ExternalId"]);
m_channelId = Jellyfin::Support::fromJsonValue<QString>(source["ChannelId"]);
m_externalChannelId = Jellyfin::Support::fromJsonValue<QString>(source["ExternalChannelId"]);
m_channelName = Jellyfin::Support::fromJsonValue<QString>(source["ChannelName"]);
m_channelPrimaryImageTag = Jellyfin::Support::fromJsonValue<QString>(source["ChannelPrimaryImageTag"]);
m_programId = Jellyfin::Support::fromJsonValue<QString>(source["ProgramId"]);
m_externalProgramId = Jellyfin::Support::fromJsonValue<QString>(source["ExternalProgramId"]);
m_name = Jellyfin::Support::fromJsonValue<QString>(source["Name"]);
m_overview = Jellyfin::Support::fromJsonValue<QString>(source["Overview"]);
m_startDate = Jellyfin::Support::fromJsonValue<QDateTime>(source["StartDate"]);
m_endDate = Jellyfin::Support::fromJsonValue<QDateTime>(source["EndDate"]);
m_serviceName = Jellyfin::Support::fromJsonValue<QString>(source["ServiceName"]);
m_priority = Jellyfin::Support::fromJsonValue<qint32>(source["Priority"]);
m_prePaddingSeconds = Jellyfin::Support::fromJsonValue<qint32>(source["PrePaddingSeconds"]);
m_postPaddingSeconds = Jellyfin::Support::fromJsonValue<qint32>(source["PostPaddingSeconds"]);
m_isPrePaddingRequired = Jellyfin::Support::fromJsonValue<bool>(source["IsPrePaddingRequired"]);
m_parentBackdropItemId = Jellyfin::Support::fromJsonValue<QString>(source["ParentBackdropItemId"]);
m_parentBackdropImageTags = Jellyfin::Support::fromJsonValue<QStringList>(source["ParentBackdropImageTags"]);
m_isPostPaddingRequired = Jellyfin::Support::fromJsonValue<bool>(source["IsPostPaddingRequired"]);
m_keepUntil = Jellyfin::Support::fromJsonValue<KeepUntil>(source["KeepUntil"]);
m_status = Jellyfin::Support::fromJsonValue<RecordingStatus>(source["Status"]);
m_seriesTimerId = Jellyfin::Support::fromJsonValue<QString>(source["SeriesTimerId"]);
m_externalSeriesTimerId = Jellyfin::Support::fromJsonValue<QString>(source["ExternalSeriesTimerId"]);
m_runTimeTicks = Jellyfin::Support::fromJsonValue<std::optional<qint64>>(source["RunTimeTicks"]);
m_programInfo = Jellyfin::Support::fromJsonValue<QSharedPointer<BaseItemDto>>(source["ProgramInfo"]);
}
QJsonObject TimerInfoDto::toJson() const {
QJsonObject result;
if (!(m_jellyfinId.isNull())) {
result["Id"] = Jellyfin::Support::toJsonValue<QString>(m_jellyfinId);
}
if (!(m_type.isNull())) {
result["Type"] = Jellyfin::Support::toJsonValue<QString>(m_type);
}
if (!(m_serverId.isNull())) {
result["ServerId"] = Jellyfin::Support::toJsonValue<QString>(m_serverId);
}
if (!(m_externalId.isNull())) {
result["ExternalId"] = Jellyfin::Support::toJsonValue<QString>(m_externalId);
}
result["ChannelId"] = Jellyfin::Support::toJsonValue<QString>(m_channelId);
if (!(m_externalChannelId.isNull())) {
result["ExternalChannelId"] = Jellyfin::Support::toJsonValue<QString>(m_externalChannelId);
}
if (!(m_channelName.isNull())) {
result["ChannelName"] = Jellyfin::Support::toJsonValue<QString>(m_channelName);
}
if (!(m_channelPrimaryImageTag.isNull())) {
result["ChannelPrimaryImageTag"] = Jellyfin::Support::toJsonValue<QString>(m_channelPrimaryImageTag);
}
if (!(m_programId.isNull())) {
result["ProgramId"] = Jellyfin::Support::toJsonValue<QString>(m_programId);
}
if (!(m_externalProgramId.isNull())) {
result["ExternalProgramId"] = Jellyfin::Support::toJsonValue<QString>(m_externalProgramId);
}
if (!(m_name.isNull())) {
result["Name"] = Jellyfin::Support::toJsonValue<QString>(m_name);
}
if (!(m_overview.isNull())) {
result["Overview"] = Jellyfin::Support::toJsonValue<QString>(m_overview);
}
result["StartDate"] = Jellyfin::Support::toJsonValue<QDateTime>(m_startDate);
result["EndDate"] = Jellyfin::Support::toJsonValue<QDateTime>(m_endDate);
if (!(m_serviceName.isNull())) {
result["ServiceName"] = Jellyfin::Support::toJsonValue<QString>(m_serviceName);
}
result["Priority"] = Jellyfin::Support::toJsonValue<qint32>(m_priority);
result["PrePaddingSeconds"] = Jellyfin::Support::toJsonValue<qint32>(m_prePaddingSeconds);
result["PostPaddingSeconds"] = Jellyfin::Support::toJsonValue<qint32>(m_postPaddingSeconds);
result["IsPrePaddingRequired"] = Jellyfin::Support::toJsonValue<bool>(m_isPrePaddingRequired);
if (!(m_parentBackdropItemId.isNull())) {
result["ParentBackdropItemId"] = Jellyfin::Support::toJsonValue<QString>(m_parentBackdropItemId);
}
if (!(m_parentBackdropImageTags.size() == 0)) {
result["ParentBackdropImageTags"] = Jellyfin::Support::toJsonValue<QStringList>(m_parentBackdropImageTags);
}
result["IsPostPaddingRequired"] = Jellyfin::Support::toJsonValue<bool>(m_isPostPaddingRequired);
result["KeepUntil"] = Jellyfin::Support::toJsonValue<KeepUntil>(m_keepUntil);
result["Status"] = Jellyfin::Support::toJsonValue<RecordingStatus>(m_status);
if (!(m_seriesTimerId.isNull())) {
result["SeriesTimerId"] = Jellyfin::Support::toJsonValue<QString>(m_seriesTimerId);
}
if (!(m_externalSeriesTimerId.isNull())) {
result["ExternalSeriesTimerId"] = Jellyfin::Support::toJsonValue<QString>(m_externalSeriesTimerId);
}
if (!(!m_runTimeTicks.has_value())) {
result["RunTimeTicks"] = Jellyfin::Support::toJsonValue<std::optional<qint64>>(m_runTimeTicks);
}
result["ProgramInfo"] = Jellyfin::Support::toJsonValue<QSharedPointer<BaseItemDto>>(m_programInfo);
return result;
}
QString TimerInfoDto::jellyfinId() const { return m_jellyfinId; }
void TimerInfoDto::setJellyfinId(QString newJellyfinId) {
m_jellyfinId = newJellyfinId;
}
bool TimerInfoDto::jellyfinIdNull() const {
return m_jellyfinId.isNull();
}
void TimerInfoDto::setJellyfinIdNull() {
m_jellyfinId.clear();
}
QString TimerInfoDto::type() const { return m_type; }
void TimerInfoDto::setType(QString newType) {
m_type = newType;
}
bool TimerInfoDto::typeNull() const {
return m_type.isNull();
}
void TimerInfoDto::setTypeNull() {
m_type.clear();
}
QString TimerInfoDto::serverId() const { return m_serverId; }
void TimerInfoDto::setServerId(QString newServerId) {
m_serverId = newServerId;
}
bool TimerInfoDto::serverIdNull() const {
return m_serverId.isNull();
}
void TimerInfoDto::setServerIdNull() {
m_serverId.clear();
}
QString TimerInfoDto::externalId() const { return m_externalId; }
void TimerInfoDto::setExternalId(QString newExternalId) {
m_externalId = newExternalId;
}
bool TimerInfoDto::externalIdNull() const {
return m_externalId.isNull();
}
void TimerInfoDto::setExternalIdNull() {
m_externalId.clear();
}
QString TimerInfoDto::channelId() const { return m_channelId; }
void TimerInfoDto::setChannelId(QString newChannelId) {
m_channelId = newChannelId;
}
QString TimerInfoDto::externalChannelId() const { return m_externalChannelId; }
void TimerInfoDto::setExternalChannelId(QString newExternalChannelId) {
m_externalChannelId = newExternalChannelId;
}
bool TimerInfoDto::externalChannelIdNull() const {
return m_externalChannelId.isNull();
}
void TimerInfoDto::setExternalChannelIdNull() {
m_externalChannelId.clear();
}
QString TimerInfoDto::channelName() const { return m_channelName; }
void TimerInfoDto::setChannelName(QString newChannelName) {
m_channelName = newChannelName;
}
bool TimerInfoDto::channelNameNull() const {
return m_channelName.isNull();
}
void TimerInfoDto::setChannelNameNull() {
m_channelName.clear();
}
QString TimerInfoDto::channelPrimaryImageTag() const { return m_channelPrimaryImageTag; }
void TimerInfoDto::setChannelPrimaryImageTag(QString newChannelPrimaryImageTag) {
m_channelPrimaryImageTag = newChannelPrimaryImageTag;
}
bool TimerInfoDto::channelPrimaryImageTagNull() const {
return m_channelPrimaryImageTag.isNull();
}
void TimerInfoDto::setChannelPrimaryImageTagNull() {
m_channelPrimaryImageTag.clear();
}
QString TimerInfoDto::programId() const { return m_programId; }
void TimerInfoDto::setProgramId(QString newProgramId) {
m_programId = newProgramId;
}
bool TimerInfoDto::programIdNull() const {
return m_programId.isNull();
}
void TimerInfoDto::setProgramIdNull() {
m_programId.clear();
}
QString TimerInfoDto::externalProgramId() const { return m_externalProgramId; }
void TimerInfoDto::setExternalProgramId(QString newExternalProgramId) {
m_externalProgramId = newExternalProgramId;
}
bool TimerInfoDto::externalProgramIdNull() const {
return m_externalProgramId.isNull();
}
void TimerInfoDto::setExternalProgramIdNull() {
m_externalProgramId.clear();
}
QString TimerInfoDto::name() const { return m_name; }
void TimerInfoDto::setName(QString newName) {
m_name = newName;
}
bool TimerInfoDto::nameNull() const {
return m_name.isNull();
}
void TimerInfoDto::setNameNull() {
m_name.clear();
}
QString TimerInfoDto::overview() const { return m_overview; }
void TimerInfoDto::setOverview(QString newOverview) {
m_overview = newOverview;
}
bool TimerInfoDto::overviewNull() const {
return m_overview.isNull();
}
void TimerInfoDto::setOverviewNull() {
m_overview.clear();
}
QDateTime TimerInfoDto::startDate() const { return m_startDate; }
void TimerInfoDto::setStartDate(QDateTime newStartDate) {
m_startDate = newStartDate;
}
QDateTime TimerInfoDto::endDate() const { return m_endDate; }
void TimerInfoDto::setEndDate(QDateTime newEndDate) {
m_endDate = newEndDate;
}
QString TimerInfoDto::serviceName() const { return m_serviceName; }
void TimerInfoDto::setServiceName(QString newServiceName) {
m_serviceName = newServiceName;
}
bool TimerInfoDto::serviceNameNull() const {
return m_serviceName.isNull();
}
void TimerInfoDto::setServiceNameNull() {
m_serviceName.clear();
}
qint32 TimerInfoDto::priority() const { return m_priority; }
void TimerInfoDto::setPriority(qint32 newPriority) {
m_priority = newPriority;
}
qint32 TimerInfoDto::prePaddingSeconds() const { return m_prePaddingSeconds; }
void TimerInfoDto::setPrePaddingSeconds(qint32 newPrePaddingSeconds) {
m_prePaddingSeconds = newPrePaddingSeconds;
}
qint32 TimerInfoDto::postPaddingSeconds() const { return m_postPaddingSeconds; }
void TimerInfoDto::setPostPaddingSeconds(qint32 newPostPaddingSeconds) {
m_postPaddingSeconds = newPostPaddingSeconds;
}
bool TimerInfoDto::isPrePaddingRequired() const { return m_isPrePaddingRequired; }
void TimerInfoDto::setIsPrePaddingRequired(bool newIsPrePaddingRequired) {
m_isPrePaddingRequired = newIsPrePaddingRequired;
}
QString TimerInfoDto::parentBackdropItemId() const { return m_parentBackdropItemId; }
void TimerInfoDto::setParentBackdropItemId(QString newParentBackdropItemId) {
m_parentBackdropItemId = newParentBackdropItemId;
}
bool TimerInfoDto::parentBackdropItemIdNull() const {
return m_parentBackdropItemId.isNull();
}
void TimerInfoDto::setParentBackdropItemIdNull() {
m_parentBackdropItemId.clear();
}
QStringList TimerInfoDto::parentBackdropImageTags() const { return m_parentBackdropImageTags; }
void TimerInfoDto::setParentBackdropImageTags(QStringList newParentBackdropImageTags) {
m_parentBackdropImageTags = newParentBackdropImageTags;
}
bool TimerInfoDto::parentBackdropImageTagsNull() const {
return m_parentBackdropImageTags.size() == 0;
}
void TimerInfoDto::setParentBackdropImageTagsNull() {
m_parentBackdropImageTags.clear();
}
bool TimerInfoDto::isPostPaddingRequired() const { return m_isPostPaddingRequired; }
void TimerInfoDto::setIsPostPaddingRequired(bool newIsPostPaddingRequired) {
m_isPostPaddingRequired = newIsPostPaddingRequired;
}
KeepUntil TimerInfoDto::keepUntil() const { return m_keepUntil; }
void TimerInfoDto::setKeepUntil(KeepUntil newKeepUntil) {
m_keepUntil = newKeepUntil;
}
RecordingStatus TimerInfoDto::status() const { return m_status; }
void TimerInfoDto::setStatus(RecordingStatus newStatus) {
m_status = newStatus;
}
QString TimerInfoDto::seriesTimerId() const { return m_seriesTimerId; }
void TimerInfoDto::setSeriesTimerId(QString newSeriesTimerId) {
m_seriesTimerId = newSeriesTimerId;
}
bool TimerInfoDto::seriesTimerIdNull() const {
return m_seriesTimerId.isNull();
}
void TimerInfoDto::setSeriesTimerIdNull() {
m_seriesTimerId.clear();
}
QString TimerInfoDto::externalSeriesTimerId() const { return m_externalSeriesTimerId; }
void TimerInfoDto::setExternalSeriesTimerId(QString newExternalSeriesTimerId) {
m_externalSeriesTimerId = newExternalSeriesTimerId;
}
bool TimerInfoDto::externalSeriesTimerIdNull() const {
return m_externalSeriesTimerId.isNull();
}
void TimerInfoDto::setExternalSeriesTimerIdNull() {
m_externalSeriesTimerId.clear();
}
std::optional<qint64> TimerInfoDto::runTimeTicks() const { return m_runTimeTicks; }
void TimerInfoDto::setRunTimeTicks(std::optional<qint64> newRunTimeTicks) {
m_runTimeTicks = newRunTimeTicks;
}
bool TimerInfoDto::runTimeTicksNull() const {
return !m_runTimeTicks.has_value();
}
void TimerInfoDto::setRunTimeTicksNull() {
m_runTimeTicks = std::nullopt;
}
QSharedPointer<BaseItemDto> TimerInfoDto::programInfo() const { return m_programInfo; }
void TimerInfoDto::setProgramInfo(QSharedPointer<BaseItemDto> newProgramInfo) {
m_programInfo = newProgramInfo;
}
} // NS DTO
namespace Support {
using TimerInfoDto = Jellyfin::DTO::TimerInfoDto;
template <>
TimerInfoDto fromJsonValue(const QJsonValue &source, convertType<TimerInfoDto>) {
if (!source.isObject()) throw ParseException("Expected JSON Object");
return TimerInfoDto::fromJson(source.toObject());
}
template<>
QJsonValue toJsonValue(const TimerInfoDto &source, convertType<TimerInfoDto>) {
return source.toJson();
}
} // NS DTO
} // NS Jellyfin
View git blame Copy permalink