From eff00b0be82ef31d6589a9fd0bf817847e1b9872 Mon Sep 17 00:00:00 2001 From: Huaweicloud-SDK Date: Thu, 26 Sep 2024 16:17:41 +0800 Subject: [PATCH] release 3.1.104 source code --- CHANGELOG.md | 31 ++ CHANGELOG_CN.md | 31 ++ VERSION | 2 +- .../huaweicloud/dds/v3/model/BackupDatabase.h | 2 +- .../huaweicloud/dds/v3/model/Datastore.h | 2 +- .../dds/v3/model/DatastoreResult.h | 2 +- .../v3/model/ListDatastoreVersionsResponse.h | 2 +- .../dds/v3/model/RecycleDatastore.h | 2 +- .../dds/v3/model/ResizeInstanceOption.h | 4 +- live/include/huaweicloud/live/v1/LiveClient.h | 56 +++ live/include/huaweicloud/live/v1/LiveMeta.h | 5 + .../live/v1/model/CreateHarvestTaskInfoReq.h | 142 ++++++ .../live/v1/model/CreateHarvestTaskRequest.h | 94 ++++ .../live/v1/model/CreateHarvestTaskResponse.h | 189 +++++++ .../live/v1/model/DeleteHarvestTaskRequest.h | 93 ++++ .../live/v1/model/DeleteHarvestTaskResponse.h | 67 +++ .../live/v1/model/HarvestTaskCreateSucRsp.h | 186 +++++++ .../live/v1/model/ListHarvestTaskRequest.h | 181 +++++++ .../live/v1/model/ListHarvestTaskResponse.h | 79 +++ .../live/v1/model/ModifyHarvestTaskRequest.h | 94 ++++ .../v1/model/ModifyHarvestTaskRequestBody.h | 153 ++++++ .../live/v1/model/ModifyHarvestTaskResponse.h | 189 +++++++ .../v1/model/UpdateHarvestJobStatusRequest.h | 94 ++++ .../model/UpdateHarvestJobStatusRequestBody.h | 75 +++ .../v1/model/UpdateHarvestJobStatusResponse.h | 189 +++++++ .../live/v1/model/VodPackageInfo.h | 75 +++ live/src/v1/LiveClient.cpp | 241 +++++++++ live/src/v1/LiveMeta.cpp | 117 +++++ .../src/v1/model/CreateHarvestTaskInfoReq.cpp | 323 ++++++++++++ .../src/v1/model/CreateHarvestTaskRequest.cpp | 148 ++++++ .../v1/model/CreateHarvestTaskResponse.cpp | 463 ++++++++++++++++++ .../src/v1/model/DeleteHarvestTaskRequest.cpp | 149 ++++++ .../v1/model/DeleteHarvestTaskResponse.cpp | 79 +++ live/src/v1/model/HarvestTaskCreateSucRsp.cpp | 463 ++++++++++++++++++ live/src/v1/model/ListHarvestTaskRequest.cpp | 429 ++++++++++++++++ live/src/v1/model/ListHarvestTaskResponse.cpp | 113 +++++ .../src/v1/model/ModifyHarvestTaskRequest.cpp | 148 ++++++ .../v1/model/ModifyHarvestTaskRequestBody.cpp | 358 ++++++++++++++ .../v1/model/ModifyHarvestTaskResponse.cpp | 463 ++++++++++++++++++ .../model/UpdateHarvestJobStatusRequest.cpp | 148 ++++++ .../UpdateHarvestJobStatusRequestBody.cpp | 114 +++++ .../model/UpdateHarvestJobStatusResponse.cpp | 463 ++++++++++++++++++ live/src/v1/model/VodPackageInfo.cpp | 114 +++++ rds/include/huaweicloud/rds/v3/RdsRegion.h | 4 + .../rds/v3/model/SetAuditlogPolicyResponse.h | 12 + .../v3/model/SetAuditlogPolicyResponse.cpp | 35 ++ 46 files changed, 6415 insertions(+), 8 deletions(-) create mode 100644 live/include/huaweicloud/live/v1/model/CreateHarvestTaskInfoReq.h create mode 100644 live/include/huaweicloud/live/v1/model/CreateHarvestTaskRequest.h create mode 100644 live/include/huaweicloud/live/v1/model/CreateHarvestTaskResponse.h create mode 100644 live/include/huaweicloud/live/v1/model/DeleteHarvestTaskRequest.h create mode 100644 live/include/huaweicloud/live/v1/model/DeleteHarvestTaskResponse.h create mode 100644 live/include/huaweicloud/live/v1/model/HarvestTaskCreateSucRsp.h create mode 100644 live/include/huaweicloud/live/v1/model/ListHarvestTaskRequest.h create mode 100644 live/include/huaweicloud/live/v1/model/ListHarvestTaskResponse.h create mode 100644 live/include/huaweicloud/live/v1/model/ModifyHarvestTaskRequest.h create mode 100644 live/include/huaweicloud/live/v1/model/ModifyHarvestTaskRequestBody.h create mode 100644 live/include/huaweicloud/live/v1/model/ModifyHarvestTaskResponse.h create mode 100644 live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusRequest.h create mode 100644 live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusRequestBody.h create mode 100644 live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusResponse.h create mode 100644 live/include/huaweicloud/live/v1/model/VodPackageInfo.h create mode 100644 live/src/v1/model/CreateHarvestTaskInfoReq.cpp create mode 100644 live/src/v1/model/CreateHarvestTaskRequest.cpp create mode 100644 live/src/v1/model/CreateHarvestTaskResponse.cpp create mode 100644 live/src/v1/model/DeleteHarvestTaskRequest.cpp create mode 100644 live/src/v1/model/DeleteHarvestTaskResponse.cpp create mode 100644 live/src/v1/model/HarvestTaskCreateSucRsp.cpp create mode 100644 live/src/v1/model/ListHarvestTaskRequest.cpp create mode 100644 live/src/v1/model/ListHarvestTaskResponse.cpp create mode 100644 live/src/v1/model/ModifyHarvestTaskRequest.cpp create mode 100644 live/src/v1/model/ModifyHarvestTaskRequestBody.cpp create mode 100644 live/src/v1/model/ModifyHarvestTaskResponse.cpp create mode 100644 live/src/v1/model/UpdateHarvestJobStatusRequest.cpp create mode 100644 live/src/v1/model/UpdateHarvestJobStatusRequestBody.cpp create mode 100644 live/src/v1/model/UpdateHarvestJobStatusResponse.cpp create mode 100644 live/src/v1/model/VodPackageInfo.cpp diff --git a/CHANGELOG.md b/CHANGELOG.md index 0ada9696d..85df79637 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,34 @@ +# 3.1.104 2024-09-26 + +### HuaweiCloud SDK DDS + +- _API Version_ + - V3 +- _Features_ + - None +- _Bug Fix_ + - None +- _Change_ + - **ResizeInstance** + - changes of request param + - `+ resize.target_type: enum value [config,readonly]` + +### HuaweiCloud SDK Live + +- _API Version_ + - V1 +- _Features_ + - Support the following APIs: + - `ListHarvestTask` + - `ModifyHarvestTask` + - `CreateHarvestTask` + - `DeleteHarvestTask` + - `UpdateHarvestJobStatus` +- _Bug Fix_ + - None +- _Change_ + - None + # 3.1.103 2024-09-23 ### HuaweiCloud SDK CDN diff --git a/CHANGELOG_CN.md b/CHANGELOG_CN.md index 2a7b460db..aa6075a8f 100644 --- a/CHANGELOG_CN.md +++ b/CHANGELOG_CN.md @@ -1,3 +1,34 @@ +# 3.1.104 2024-09-26 + +### HuaweiCloud SDK DDS + +- _接口版本_ + - V3 +- _新增特性_ + - 无 +- _解决问题_ + - 无 +- _特性变更_ + - **ResizeInstance** + - 请求参数变更 + - `+ resize.target_type: enum value [config,readonly]` + +### HuaweiCloud SDK Live + +- _接口版本_ + - V1 +- _新增特性_ + - 支持以下接口： + - `ListHarvestTask` + - `ModifyHarvestTask` + - `CreateHarvestTask` + - `DeleteHarvestTask` + - `UpdateHarvestJobStatus` +- _解决问题_ + - 无 +- _特性变更_ + - 无 + # 3.1.103 2024-09-23 ### HuaweiCloud SDK CDN diff --git a/VERSION b/VERSION index 54ecca43b..8a79e85c0 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -3.1.103 +3.1.104 diff --git a/dds/include/huaweicloud/dds/v3/model/BackupDatabase.h b/dds/include/huaweicloud/dds/v3/model/BackupDatabase.h index 1ea9ddd2e..d0f885779 100644 --- a/dds/include/huaweicloud/dds/v3/model/BackupDatabase.h +++ b/dds/include/huaweicloud/dds/v3/model/BackupDatabase.h @@ -48,7 +48,7 @@ class HUAWEICLOUD_DDS_V3_EXPORT BackupDatabase void setType(const std::string& value); /// - /// 数据库版本。取值：“3.2”、“3.4”或“4.0”。 + /// 数据库版本。取值：“3.4”、“4.0”、“4.2”、“4.4”、“5.0”。 /// std::string getVersion() const; diff --git a/dds/include/huaweicloud/dds/v3/model/Datastore.h b/dds/include/huaweicloud/dds/v3/model/Datastore.h index 8e1e812b8..d6199fcd3 100644 --- a/dds/include/huaweicloud/dds/v3/model/Datastore.h +++ b/dds/include/huaweicloud/dds/v3/model/Datastore.h @@ -48,7 +48,7 @@ class HUAWEICLOUD_DDS_V3_EXPORT Datastore void setType(const std::string& value); /// - /// 数据库版本。支持3.4、3.2和4.0版本。取值为“3.4”、“3.2”或“4.0”。 + /// 数据库版本。支持3.4及以上版本。取值为“3.4”、“4.0”、“4.2”、“4.4”、“5.0”。 /// std::string getVersion() const; diff --git a/dds/include/huaweicloud/dds/v3/model/DatastoreResult.h b/dds/include/huaweicloud/dds/v3/model/DatastoreResult.h index c79b858e7..b0656035f 100644 --- a/dds/include/huaweicloud/dds/v3/model/DatastoreResult.h +++ b/dds/include/huaweicloud/dds/v3/model/DatastoreResult.h @@ -48,7 +48,7 @@ class HUAWEICLOUD_DDS_V3_EXPORT DatastoreResult void setNodeType(const std::string& value); /// - /// version数据库版本。DDS引擎取值为3.2, 3.4, 4.0。 + /// version数据库版本。 /// std::string getVersion() const; diff --git a/dds/include/huaweicloud/dds/v3/model/ListDatastoreVersionsResponse.h b/dds/include/huaweicloud/dds/v3/model/ListDatastoreVersionsResponse.h index c7ec8d7e2..543e3a687 100644 --- a/dds/include/huaweicloud/dds/v3/model/ListDatastoreVersionsResponse.h +++ b/dds/include/huaweicloud/dds/v3/model/ListDatastoreVersionsResponse.h @@ -40,7 +40,7 @@ class HUAWEICLOUD_DDS_V3_EXPORT ListDatastoreVersionsResponse /// ListDatastoreVersionsResponse members /// - /// 数据库版本。支持3.4、3.2和4.0版本。 + /// 数据库版本。支持3.4及以上版本。 /// std::vector& getVersions(); diff --git a/dds/include/huaweicloud/dds/v3/model/RecycleDatastore.h b/dds/include/huaweicloud/dds/v3/model/RecycleDatastore.h index 930fef977..8dc4b9867 100644 --- a/dds/include/huaweicloud/dds/v3/model/RecycleDatastore.h +++ b/dds/include/huaweicloud/dds/v3/model/RecycleDatastore.h @@ -48,7 +48,7 @@ class HUAWEICLOUD_DDS_V3_EXPORT RecycleDatastore void setType(const std::string& value); /// - /// 数据库版本。支持3.4、3.2和4.0版本。取值为“3.4”、“3.2”或“4.0”。 + /// 数据库版本。支持3.4及以上版本。取值为“3.4”、“4.0”、“4.2”、“4.4”或“5.0”。 /// std::string getVersion() const; diff --git a/dds/include/huaweicloud/dds/v3/model/ResizeInstanceOption.h b/dds/include/huaweicloud/dds/v3/model/ResizeInstanceOption.h index 5235cb803..990f3967e 100644 --- a/dds/include/huaweicloud/dds/v3/model/ResizeInstanceOption.h +++ b/dds/include/huaweicloud/dds/v3/model/ResizeInstanceOption.h @@ -39,7 +39,7 @@ class HUAWEICLOUD_DDS_V3_EXPORT ResizeInstanceOption /// ResizeInstanceOption members /// - /// 对象类型。 - 对于集群实例，该参数为必选。变更mongos节点规格时，取值为“mongos”；变更shard组规格时，取值为“shard”。 - 对于副本集和单节点实例，不传该参数。 + /// 对象类型。 - 对于集群实例，该参数为必选。变更mongos节点规格时，取值为“mongos”；变更单个shard组规格、或者批量变更多个shard组规格时，取值为“shard”，变更config组规格时，取值为\"config\"。 - 对于副本集实例，不传该参数。变更readonly节点规格时,取值为“readonly”。 - 对于单节点实例，不传该参数。 /// std::string getTargetType() const; @@ -48,7 +48,7 @@ class HUAWEICLOUD_DDS_V3_EXPORT ResizeInstanceOption void setTargetType(const std::string& value); /// - /// 待变更规格的节点ID或实例ID，可以调用“查询实例列表和详情”接口获取。如果未申请实例，可以调用“创建实例”接口创建。 - 对于集群实例，变更mongos节点规格时，取值为mongos节点ID；变更shard组规格时，取值为shard组ID。 - 对于副本集实例，取值为相应的实例ID。 - 对于单节点实例，取值为相应的实例ID。 + /// 待变更规格的节点ID或实例ID，可以调用“查询实例列表和详情”接口获取。如果未申请实例，可以调用“创建实例”接口创建。 - 对于集群实例，变更mongos节点规格时，取值为mongos节点ID；变更单个shard组规格时，取值为shard组ID；批量变更多个shard组规格时，不传该参数；变更config组规格时，取值为config组的ID。 - 对于副本集实例，取值为相应的实例ID。变更readonly节点规格时，取值为readonly节点ID。 - 对于单节点实例，取值为相应的实例ID。 /// std::string getTargetId() const; diff --git a/live/include/huaweicloud/live/v1/LiveClient.h b/live/include/huaweicloud/live/v1/LiveClient.h index 9ff893105..32b978df5 100644 --- a/live/include/huaweicloud/live/v1/LiveClient.h +++ b/live/include/huaweicloud/live/v1/LiveClient.h @@ -148,6 +148,21 @@ #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + #include #include #include @@ -675,6 +690,47 @@ class HUAWEICLOUD_LIVE_V1_EXPORT LiveClient : public Client UpdateDomainHttpsCertRequest &request ); + // 创建Live2VOD任务 + // + // 创建Live2VOD任务。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr createHarvestTask( + CreateHarvestTaskRequest &request + ); + // 删除Live2VOD任务 + // + // 删除Live2VOD任务。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr deleteHarvestTask( + DeleteHarvestTaskRequest &request + ); + // 查询Live2VOD任务 + // + // 查询Live2VOD任务，支持批量查询。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr listHarvestTask( + ListHarvestTaskRequest &request + ); + // 修改Live2VOD任务 + // + // 修改Live2VOD任务。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr modifyHarvestTask( + ModifyHarvestTaskRequest &request + ); + // 修改Live2VOD任务状态 + // + // 修改Live2VOD任务状态。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr updateHarvestJobStatus( + UpdateHarvestJobStatusRequest &request + ); + // OBS桶授权及取消授权 // // OBS桶授权及取消授权 diff --git a/live/include/huaweicloud/live/v1/LiveMeta.h b/live/include/huaweicloud/live/v1/LiveMeta.h index 0f2601805..fa42c7f92 100644 --- a/live/include/huaweicloud/live/v1/LiveMeta.h +++ b/live/include/huaweicloud/live/v1/LiveMeta.h @@ -71,6 +71,11 @@ class HUAWEICLOUD_LIVE_V1_EXPORT LiveMeta { static HttpRequestDef genRequestDefForDeleteDomainHttpsCert(); static HttpRequestDef genRequestDefForShowDomainHttpsCert(); static HttpRequestDef genRequestDefForUpdateDomainHttpsCert(); + static HttpRequestDef genRequestDefForCreateHarvestTask(); + static HttpRequestDef genRequestDefForDeleteHarvestTask(); + static HttpRequestDef genRequestDefForListHarvestTask(); + static HttpRequestDef genRequestDefForModifyHarvestTask(); + static HttpRequestDef genRequestDefForUpdateHarvestJobStatus(); static HttpRequestDef genRequestDefForUpdateObsBucketAuthorityPublic(); static HttpRequestDef genRequestDefForCreateOttChannelInfo(); static HttpRequestDef genRequestDefForDeleteOttChannelInfo(); diff --git a/live/include/huaweicloud/live/v1/model/CreateHarvestTaskInfoReq.h b/live/include/huaweicloud/live/v1/model/CreateHarvestTaskInfoReq.h new file mode 100644 index 000000000..aea202216 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/CreateHarvestTaskInfoReq.h @@ -0,0 +1,142 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_CreateHarvestTaskInfoReq_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_CreateHarvestTaskInfoReq_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// 创建Live2Vod任务 +/// +class HUAWEICLOUD_LIVE_V1_EXPORT CreateHarvestTaskInfoReq + : public ModelBase +{ +public: + CreateHarvestTaskInfoReq(); + virtual ~CreateHarvestTaskInfoReq(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// CreateHarvestTaskInfoReq members + + /// + /// 频道推流域名 + /// + + std::string getDomain() const; + bool domainIsSet() const; + void unsetdomain(); + void setDomain(const std::string& value); + + /// + /// 组名或应用名 + /// + + std::string getAppName() const; + bool appNameIsSet() const; + void unsetappName(); + void setAppName(const std::string& value); + + /// + /// 频道ID。频道唯一标识，为必填项。频道ID不建议输入下划线“_”，否则会影响转码和截图任务 + /// + + std::string getId() const; + bool idIsSet() const; + void unsetid(); + void setId(const std::string& value); + + /// + /// 开始时间。Unix时间戳：单位是秒 + /// + + int32_t getStartTime() const; + bool startTimeIsSet() const; + void unsetstartTime(); + void setStartTime(int32_t value); + + /// + /// 结束时间。Unix时间戳：单位是秒 + /// + + int32_t getEndTime() const; + bool endTimeIsSet() const; + void unsetendTime(); + void setEndTime(int32_t value); + + /// + /// 事件名称。必选配置 + /// + + std::string getEventName() const; + bool eventNameIsSet() const; + void unseteventName(); + void setEventName(const std::string& value); + + /// + /// 任务描述，可选配置 + /// + + std::string getTaskDesc() const; + bool taskDescIsSet() const; + void unsettaskDesc(); + void setTaskDesc(const std::string& value); + + /// + /// + /// + + VodPackageInfo getPackageInfo() const; + bool packageInfoIsSet() const; + void unsetpackageInfo(); + void setPackageInfo(const VodPackageInfo& value); + + +protected: + std::string domain_; + bool domainIsSet_; + std::string appName_; + bool appNameIsSet_; + std::string id_; + bool idIsSet_; + int32_t startTime_; + bool startTimeIsSet_; + int32_t endTime_; + bool endTimeIsSet_; + std::string eventName_; + bool eventNameIsSet_; + std::string taskDesc_; + bool taskDescIsSet_; + VodPackageInfo packageInfo_; + bool packageInfoIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_CreateHarvestTaskInfoReq_H_ diff --git a/live/include/huaweicloud/live/v1/model/CreateHarvestTaskRequest.h b/live/include/huaweicloud/live/v1/model/CreateHarvestTaskRequest.h new file mode 100644 index 000000000..f831c8b86 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/CreateHarvestTaskRequest.h @@ -0,0 +1,94 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_CreateHarvestTaskRequest_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_CreateHarvestTaskRequest_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_LIVE_V1_EXPORT CreateHarvestTaskRequest + : public ModelBase +{ +public: + CreateHarvestTaskRequest(); + virtual ~CreateHarvestTaskRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// CreateHarvestTaskRequest members + + /// + /// 服务鉴权Token，服务开启鉴权，必须携带Access-Control-Allow-Internal访问服务。 + /// + + std::string getAccessControlAllowInternal() const; + bool accessControlAllowInternalIsSet() const; + void unsetaccessControlAllowInternal(); + void setAccessControlAllowInternal(const std::string& value); + + /// + /// 服务鉴权Token，服务开启鉴权，必须携带Access-Control-Allow-External访问服务。 + /// + + std::string getAccessControlAllowExternal() const; + bool accessControlAllowExternalIsSet() const; + void unsetaccessControlAllowExternal(); + void setAccessControlAllowExternal(const std::string& value); + + /// + /// + /// + + CreateHarvestTaskInfoReq getBody() const; + bool bodyIsSet() const; + void unsetbody(); + void setBody(const CreateHarvestTaskInfoReq& value); + + +protected: + std::string accessControlAllowInternal_; + bool accessControlAllowInternalIsSet_; + std::string accessControlAllowExternal_; + bool accessControlAllowExternalIsSet_; + CreateHarvestTaskInfoReq body_; + bool bodyIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + CreateHarvestTaskRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_CreateHarvestTaskRequest_H_ diff --git a/live/include/huaweicloud/live/v1/model/CreateHarvestTaskResponse.h b/live/include/huaweicloud/live/v1/model/CreateHarvestTaskResponse.h new file mode 100644 index 000000000..3522f5f48 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/CreateHarvestTaskResponse.h @@ -0,0 +1,189 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_CreateHarvestTaskResponse_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_CreateHarvestTaskResponse_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_LIVE_V1_EXPORT CreateHarvestTaskResponse + : public ModelBase, public HttpResponse +{ +public: + CreateHarvestTaskResponse(); + virtual ~CreateHarvestTaskResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// CreateHarvestTaskResponse members + + /// + /// 任务ID + /// + + std::string getJobId() const; + bool jobIdIsSet() const; + void unsetjobId(); + void setJobId(const std::string& value); + + /// + /// 频道推流域名 + /// + + std::string getDomain() const; + bool domainIsSet() const; + void unsetdomain(); + void setDomain(const std::string& value); + + /// + /// 组名或应用名 + /// + + std::string getAppName() const; + bool appNameIsSet() const; + void unsetappName(); + void setAppName(const std::string& value); + + /// + /// 频道ID。频道唯一标识，为必填项。频道ID不建议输入下划线“_”，否则会影响转码和截图任务 + /// + + std::string getId() const; + bool idIsSet() const; + void unsetid(); + void setId(const std::string& value); + + /// + /// 开始时间。Unix时间错，单位为秒 + /// + + int32_t getStartTime() const; + bool startTimeIsSet() const; + void unsetstartTime(); + void setStartTime(int32_t value); + + /// + /// 结束时间。Unix时间错，单位为秒 + /// + + int32_t getEndTime() const; + bool endTimeIsSet() const; + void unsetendTime(); + void setEndTime(int32_t value); + + /// + /// 任务创建时间。Unix时间错，单位为秒 + /// + + int32_t getCreateTime() const; + bool createTimeIsSet() const; + void unsetcreateTime(); + void setCreateTime(int32_t value); + + /// + /// 事件名称 + /// + + std::string getEventName() const; + bool eventNameIsSet() const; + void unseteventName(); + void setEventName(const std::string& value); + + /// + /// 任务描述 + /// + + std::string getTaskDesc() const; + bool taskDescIsSet() const; + void unsettaskDesc(); + void setTaskDesc(const std::string& value); + + /// + /// 任务状态，取值为 [ UNSTART、IN_PROGRESS、SUCCEEDED、FAILED ] + /// + + std::string getStatus() const; + bool statusIsSet() const; + void unsetstatus(); + void setStatus(const std::string& value); + + /// + /// 任务状态为FAILED时，最大允许重试的次数 + /// + + int32_t getMaxRetryCnt() const; + bool maxRetryCntIsSet() const; + void unsetmaxRetryCnt(); + void setMaxRetryCnt(int32_t value); + + /// + /// + /// + + VodPackageInfo getPackageInfo() const; + bool packageInfoIsSet() const; + void unsetpackageInfo(); + void setPackageInfo(const VodPackageInfo& value); + + +protected: + std::string jobId_; + bool jobIdIsSet_; + std::string domain_; + bool domainIsSet_; + std::string appName_; + bool appNameIsSet_; + std::string id_; + bool idIsSet_; + int32_t startTime_; + bool startTimeIsSet_; + int32_t endTime_; + bool endTimeIsSet_; + int32_t createTime_; + bool createTimeIsSet_; + std::string eventName_; + bool eventNameIsSet_; + std::string taskDesc_; + bool taskDescIsSet_; + std::string status_; + bool statusIsSet_; + int32_t maxRetryCnt_; + bool maxRetryCntIsSet_; + VodPackageInfo packageInfo_; + bool packageInfoIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_CreateHarvestTaskResponse_H_ diff --git a/live/include/huaweicloud/live/v1/model/DeleteHarvestTaskRequest.h b/live/include/huaweicloud/live/v1/model/DeleteHarvestTaskRequest.h new file mode 100644 index 000000000..888c25926 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/DeleteHarvestTaskRequest.h @@ -0,0 +1,93 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_DeleteHarvestTaskRequest_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_DeleteHarvestTaskRequest_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_LIVE_V1_EXPORT DeleteHarvestTaskRequest + : public ModelBase +{ +public: + DeleteHarvestTaskRequest(); + virtual ~DeleteHarvestTaskRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// DeleteHarvestTaskRequest members + + /// + /// 服务鉴权Token，服务开启鉴权，必须携带Access-Control-Allow-Internal访问服务。 + /// + + std::string getAccessControlAllowInternal() const; + bool accessControlAllowInternalIsSet() const; + void unsetaccessControlAllowInternal(); + void setAccessControlAllowInternal(const std::string& value); + + /// + /// 服务鉴权Token，服务开启鉴权，必须携带Access-Control-Allow-External访问服务。 + /// + + std::string getAccessControlAllowExternal() const; + bool accessControlAllowExternalIsSet() const; + void unsetaccessControlAllowExternal(); + void setAccessControlAllowExternal(const std::string& value); + + /// + /// 任务ID + /// + + std::string getJobId() const; + bool jobIdIsSet() const; + void unsetjobId(); + void setJobId(const std::string& value); + + +protected: + std::string accessControlAllowInternal_; + bool accessControlAllowInternalIsSet_; + std::string accessControlAllowExternal_; + bool accessControlAllowExternalIsSet_; + std::string jobId_; + bool jobIdIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + DeleteHarvestTaskRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_DeleteHarvestTaskRequest_H_ diff --git a/live/include/huaweicloud/live/v1/model/DeleteHarvestTaskResponse.h b/live/include/huaweicloud/live/v1/model/DeleteHarvestTaskResponse.h new file mode 100644 index 000000000..74083393f --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/DeleteHarvestTaskResponse.h @@ -0,0 +1,67 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_DeleteHarvestTaskResponse_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_DeleteHarvestTaskResponse_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_LIVE_V1_EXPORT DeleteHarvestTaskResponse + : public ModelBase, public HttpResponse +{ +public: + DeleteHarvestTaskResponse(); + virtual ~DeleteHarvestTaskResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// DeleteHarvestTaskResponse members + + /// + /// 任务ID + /// + + std::string getJobId() const; + bool jobIdIsSet() const; + void unsetjobId(); + void setJobId(const std::string& value); + + +protected: + std::string jobId_; + bool jobIdIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_DeleteHarvestTaskResponse_H_ diff --git a/live/include/huaweicloud/live/v1/model/HarvestTaskCreateSucRsp.h b/live/include/huaweicloud/live/v1/model/HarvestTaskCreateSucRsp.h new file mode 100644 index 000000000..62fcab5cc --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/HarvestTaskCreateSucRsp.h @@ -0,0 +1,186 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_HarvestTaskCreateSucRsp_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_HarvestTaskCreateSucRsp_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// 创建成功响应 +/// +class HUAWEICLOUD_LIVE_V1_EXPORT HarvestTaskCreateSucRsp + : public ModelBase +{ +public: + HarvestTaskCreateSucRsp(); + virtual ~HarvestTaskCreateSucRsp(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// HarvestTaskCreateSucRsp members + + /// + /// 任务ID + /// + + std::string getJobId() const; + bool jobIdIsSet() const; + void unsetjobId(); + void setJobId(const std::string& value); + + /// + /// 频道推流域名 + /// + + std::string getDomain() const; + bool domainIsSet() const; + void unsetdomain(); + void setDomain(const std::string& value); + + /// + /// 组名或应用名 + /// + + std::string getAppName() const; + bool appNameIsSet() const; + void unsetappName(); + void setAppName(const std::string& value); + + /// + /// 频道ID。频道唯一标识，为必填项。频道ID不建议输入下划线“_”，否则会影响转码和截图任务 + /// + + std::string getId() const; + bool idIsSet() const; + void unsetid(); + void setId(const std::string& value); + + /// + /// 开始时间。Unix时间错，单位为秒 + /// + + int32_t getStartTime() const; + bool startTimeIsSet() const; + void unsetstartTime(); + void setStartTime(int32_t value); + + /// + /// 结束时间。Unix时间错，单位为秒 + /// + + int32_t getEndTime() const; + bool endTimeIsSet() const; + void unsetendTime(); + void setEndTime(int32_t value); + + /// + /// 任务创建时间。Unix时间错，单位为秒 + /// + + int32_t getCreateTime() const; + bool createTimeIsSet() const; + void unsetcreateTime(); + void setCreateTime(int32_t value); + + /// + /// 事件名称 + /// + + std::string getEventName() const; + bool eventNameIsSet() const; + void unseteventName(); + void setEventName(const std::string& value); + + /// + /// 任务描述 + /// + + std::string getTaskDesc() const; + bool taskDescIsSet() const; + void unsettaskDesc(); + void setTaskDesc(const std::string& value); + + /// + /// 任务状态，取值为 [ UNSTART、IN_PROGRESS、SUCCEEDED、FAILED ] + /// + + std::string getStatus() const; + bool statusIsSet() const; + void unsetstatus(); + void setStatus(const std::string& value); + + /// + /// 任务状态为FAILED时，最大允许重试的次数 + /// + + int32_t getMaxRetryCnt() const; + bool maxRetryCntIsSet() const; + void unsetmaxRetryCnt(); + void setMaxRetryCnt(int32_t value); + + /// + /// + /// + + VodPackageInfo getPackageInfo() const; + bool packageInfoIsSet() const; + void unsetpackageInfo(); + void setPackageInfo(const VodPackageInfo& value); + + +protected: + std::string jobId_; + bool jobIdIsSet_; + std::string domain_; + bool domainIsSet_; + std::string appName_; + bool appNameIsSet_; + std::string id_; + bool idIsSet_; + int32_t startTime_; + bool startTimeIsSet_; + int32_t endTime_; + bool endTimeIsSet_; + int32_t createTime_; + bool createTimeIsSet_; + std::string eventName_; + bool eventNameIsSet_; + std::string taskDesc_; + bool taskDescIsSet_; + std::string status_; + bool statusIsSet_; + int32_t maxRetryCnt_; + bool maxRetryCntIsSet_; + VodPackageInfo packageInfo_; + bool packageInfoIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_HarvestTaskCreateSucRsp_H_ diff --git a/live/include/huaweicloud/live/v1/model/ListHarvestTaskRequest.h b/live/include/huaweicloud/live/v1/model/ListHarvestTaskRequest.h new file mode 100644 index 000000000..139a435ad --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/ListHarvestTaskRequest.h @@ -0,0 +1,181 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_ListHarvestTaskRequest_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_ListHarvestTaskRequest_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_LIVE_V1_EXPORT ListHarvestTaskRequest + : public ModelBase +{ +public: + ListHarvestTaskRequest(); + virtual ~ListHarvestTaskRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// ListHarvestTaskRequest members + + /// + /// 服务鉴权Token，服务开启鉴权，必须携带Access-Control-Allow-Internal访问服务。 + /// + + std::string getAccessControlAllowInternal() const; + bool accessControlAllowInternalIsSet() const; + void unsetaccessControlAllowInternal(); + void setAccessControlAllowInternal(const std::string& value); + + /// + /// 服务鉴权Token，服务开启鉴权，必须携带Access-Control-Allow-External访问服务。 + /// + + std::string getAccessControlAllowExternal() const; + bool accessControlAllowExternalIsSet() const; + void unsetaccessControlAllowExternal(); + void setAccessControlAllowExternal(const std::string& value); + + /// + /// 推流域名 + /// + + std::string getDomain() const; + bool domainIsSet() const; + void unsetdomain(); + void setDomain(const std::string& value); + + /// + /// 组名或应用名 + /// + + std::string getAppName() const; + bool appNameIsSet() const; + void unsetappName(); + void setAppName(const std::string& value); + + /// + /// 频道ID + /// + + std::string getId() const; + bool idIsSet() const; + void unsetid(); + void setId(const std::string& value); + + /// + /// 任务ID + /// + + std::string getJobId() const; + bool jobIdIsSet() const; + void unsetjobId(); + void setJobId(const std::string& value); + + /// + /// 开始时间，Unix时间戳：单位是秒 + /// + + int32_t getStartTime() const; + bool startTimeIsSet() const; + void unsetstartTime(); + void setStartTime(int32_t value); + + /// + /// 结束，Unix时间戳：单位是秒 + /// + + int32_t getEndTime() const; + bool endTimeIsSet() const; + void unsetendTime(); + void setEndTime(int32_t value); + + /// + /// 事件名称 + /// + + std::string getEventName() const; + bool eventNameIsSet() const; + void unseteventName(); + void setEventName(const std::string& value); + + /// + /// 每页记录数，取值范围[1,100]，默认值10 + /// + + int32_t getLimit() const; + bool limitIsSet() const; + void unsetlimit(); + void setLimit(int32_t value); + + /// + /// 偏移量。表示从此偏移量开始查询，offset大于等于0 + /// + + int32_t getOffset() const; + bool offsetIsSet() const; + void unsetoffset(); + void setOffset(int32_t value); + + +protected: + std::string accessControlAllowInternal_; + bool accessControlAllowInternalIsSet_; + std::string accessControlAllowExternal_; + bool accessControlAllowExternalIsSet_; + std::string domain_; + bool domainIsSet_; + std::string appName_; + bool appNameIsSet_; + std::string id_; + bool idIsSet_; + std::string jobId_; + bool jobIdIsSet_; + int32_t startTime_; + bool startTimeIsSet_; + int32_t endTime_; + bool endTimeIsSet_; + std::string eventName_; + bool eventNameIsSet_; + int32_t limit_; + bool limitIsSet_; + int32_t offset_; + bool offsetIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + ListHarvestTaskRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_ListHarvestTaskRequest_H_ diff --git a/live/include/huaweicloud/live/v1/model/ListHarvestTaskResponse.h b/live/include/huaweicloud/live/v1/model/ListHarvestTaskResponse.h new file mode 100644 index 000000000..00a1564f9 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/ListHarvestTaskResponse.h @@ -0,0 +1,79 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_ListHarvestTaskResponse_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_ListHarvestTaskResponse_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_LIVE_V1_EXPORT ListHarvestTaskResponse + : public ModelBase, public HttpResponse +{ +public: + ListHarvestTaskResponse(); + virtual ~ListHarvestTaskResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// ListHarvestTaskResponse members + + /// + /// 总任务数 + /// + + int32_t getTotal() const; + bool totalIsSet() const; + void unsettotal(); + void setTotal(int32_t value); + + /// + /// 任务信息 + /// + + std::vector& getHarvestTasks(); + bool harvestTasksIsSet() const; + void unsetharvestTasks(); + void setHarvestTasks(const std::vector& value); + + +protected: + int32_t total_; + bool totalIsSet_; + std::vector harvestTasks_; + bool harvestTasksIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_ListHarvestTaskResponse_H_ diff --git a/live/include/huaweicloud/live/v1/model/ModifyHarvestTaskRequest.h b/live/include/huaweicloud/live/v1/model/ModifyHarvestTaskRequest.h new file mode 100644 index 000000000..6b0f9b82d --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/ModifyHarvestTaskRequest.h @@ -0,0 +1,94 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_ModifyHarvestTaskRequest_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_ModifyHarvestTaskRequest_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_LIVE_V1_EXPORT ModifyHarvestTaskRequest + : public ModelBase +{ +public: + ModifyHarvestTaskRequest(); + virtual ~ModifyHarvestTaskRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// ModifyHarvestTaskRequest members + + /// + /// 服务鉴权Token，服务开启鉴权，必须携带Access-Control-Allow-Internal访问服务。 + /// + + std::string getAccessControlAllowInternal() const; + bool accessControlAllowInternalIsSet() const; + void unsetaccessControlAllowInternal(); + void setAccessControlAllowInternal(const std::string& value); + + /// + /// 服务鉴权Token，服务开启鉴权，必须携带Access-Control-Allow-External访问服务。 + /// + + std::string getAccessControlAllowExternal() const; + bool accessControlAllowExternalIsSet() const; + void unsetaccessControlAllowExternal(); + void setAccessControlAllowExternal(const std::string& value); + + /// + /// + /// + + ModifyHarvestTaskRequestBody getBody() const; + bool bodyIsSet() const; + void unsetbody(); + void setBody(const ModifyHarvestTaskRequestBody& value); + + +protected: + std::string accessControlAllowInternal_; + bool accessControlAllowInternalIsSet_; + std::string accessControlAllowExternal_; + bool accessControlAllowExternalIsSet_; + ModifyHarvestTaskRequestBody body_; + bool bodyIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + ModifyHarvestTaskRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_ModifyHarvestTaskRequest_H_ diff --git a/live/include/huaweicloud/live/v1/model/ModifyHarvestTaskRequestBody.h b/live/include/huaweicloud/live/v1/model/ModifyHarvestTaskRequestBody.h new file mode 100644 index 000000000..b95537412 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/ModifyHarvestTaskRequestBody.h @@ -0,0 +1,153 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_ModifyHarvestTaskRequestBody_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_ModifyHarvestTaskRequestBody_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// 修改Live2Vod任务 +/// +class HUAWEICLOUD_LIVE_V1_EXPORT ModifyHarvestTaskRequestBody + : public ModelBase +{ +public: + ModifyHarvestTaskRequestBody(); + virtual ~ModifyHarvestTaskRequestBody(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// ModifyHarvestTaskRequestBody members + + /// + /// 频道推流域名 + /// + + std::string getDomain() const; + bool domainIsSet() const; + void unsetdomain(); + void setDomain(const std::string& value); + + /// + /// 组名或应用名 + /// + + std::string getAppName() const; + bool appNameIsSet() const; + void unsetappName(); + void setAppName(const std::string& value); + + /// + /// 频道ID。频道唯一标识，为必填项。频道ID不建议输入下划线“_”，否则会影响转码和截图任务 + /// + + std::string getId() const; + bool idIsSet() const; + void unsetid(); + void setId(const std::string& value); + + /// + /// 开始时间。Unix时间戳，单位为秒 + /// + + int32_t getStartTime() const; + bool startTimeIsSet() const; + void unsetstartTime(); + void setStartTime(int32_t value); + + /// + /// 结束时间。Unix时间戳，单位为秒 + /// + + int32_t getEndTime() const; + bool endTimeIsSet() const; + void unsetendTime(); + void setEndTime(int32_t value); + + /// + /// 事件名称。必选配置 + /// + + std::string getEventName() const; + bool eventNameIsSet() const; + void unseteventName(); + void setEventName(const std::string& value); + + /// + /// 任务Id。必选配置 + /// + + std::string getJobId() const; + bool jobIdIsSet() const; + void unsetjobId(); + void setJobId(const std::string& value); + + /// + /// 任务描述，可选配置 + /// + + std::string getTaskDesc() const; + bool taskDescIsSet() const; + void unsettaskDesc(); + void setTaskDesc(const std::string& value); + + /// + /// + /// + + VodPackageInfo getPackageInfo() const; + bool packageInfoIsSet() const; + void unsetpackageInfo(); + void setPackageInfo(const VodPackageInfo& value); + + +protected: + std::string domain_; + bool domainIsSet_; + std::string appName_; + bool appNameIsSet_; + std::string id_; + bool idIsSet_; + int32_t startTime_; + bool startTimeIsSet_; + int32_t endTime_; + bool endTimeIsSet_; + std::string eventName_; + bool eventNameIsSet_; + std::string jobId_; + bool jobIdIsSet_; + std::string taskDesc_; + bool taskDescIsSet_; + VodPackageInfo packageInfo_; + bool packageInfoIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_ModifyHarvestTaskRequestBody_H_ diff --git a/live/include/huaweicloud/live/v1/model/ModifyHarvestTaskResponse.h b/live/include/huaweicloud/live/v1/model/ModifyHarvestTaskResponse.h new file mode 100644 index 000000000..a08b85e84 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/ModifyHarvestTaskResponse.h @@ -0,0 +1,189 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_ModifyHarvestTaskResponse_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_ModifyHarvestTaskResponse_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_LIVE_V1_EXPORT ModifyHarvestTaskResponse + : public ModelBase, public HttpResponse +{ +public: + ModifyHarvestTaskResponse(); + virtual ~ModifyHarvestTaskResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// ModifyHarvestTaskResponse members + + /// + /// 任务ID + /// + + std::string getJobId() const; + bool jobIdIsSet() const; + void unsetjobId(); + void setJobId(const std::string& value); + + /// + /// 频道推流域名 + /// + + std::string getDomain() const; + bool domainIsSet() const; + void unsetdomain(); + void setDomain(const std::string& value); + + /// + /// 组名或应用名 + /// + + std::string getAppName() const; + bool appNameIsSet() const; + void unsetappName(); + void setAppName(const std::string& value); + + /// + /// 频道ID。频道唯一标识，为必填项。频道ID不建议输入下划线“_”，否则会影响转码和截图任务 + /// + + std::string getId() const; + bool idIsSet() const; + void unsetid(); + void setId(const std::string& value); + + /// + /// 开始时间。Unix时间错，单位为秒 + /// + + int32_t getStartTime() const; + bool startTimeIsSet() const; + void unsetstartTime(); + void setStartTime(int32_t value); + + /// + /// 结束时间。Unix时间错，单位为秒 + /// + + int32_t getEndTime() const; + bool endTimeIsSet() const; + void unsetendTime(); + void setEndTime(int32_t value); + + /// + /// 任务创建时间。Unix时间错，单位为秒 + /// + + int32_t getCreateTime() const; + bool createTimeIsSet() const; + void unsetcreateTime(); + void setCreateTime(int32_t value); + + /// + /// 事件名称 + /// + + std::string getEventName() const; + bool eventNameIsSet() const; + void unseteventName(); + void setEventName(const std::string& value); + + /// + /// 任务描述 + /// + + std::string getTaskDesc() const; + bool taskDescIsSet() const; + void unsettaskDesc(); + void setTaskDesc(const std::string& value); + + /// + /// 任务状态，取值为 [ UNSTART、IN_PROGRESS、SUCCEEDED、FAILED ] + /// + + std::string getStatus() const; + bool statusIsSet() const; + void unsetstatus(); + void setStatus(const std::string& value); + + /// + /// 任务状态为FAILED时，最大允许重试的次数 + /// + + int32_t getMaxRetryCnt() const; + bool maxRetryCntIsSet() const; + void unsetmaxRetryCnt(); + void setMaxRetryCnt(int32_t value); + + /// + /// + /// + + VodPackageInfo getPackageInfo() const; + bool packageInfoIsSet() const; + void unsetpackageInfo(); + void setPackageInfo(const VodPackageInfo& value); + + +protected: + std::string jobId_; + bool jobIdIsSet_; + std::string domain_; + bool domainIsSet_; + std::string appName_; + bool appNameIsSet_; + std::string id_; + bool idIsSet_; + int32_t startTime_; + bool startTimeIsSet_; + int32_t endTime_; + bool endTimeIsSet_; + int32_t createTime_; + bool createTimeIsSet_; + std::string eventName_; + bool eventNameIsSet_; + std::string taskDesc_; + bool taskDescIsSet_; + std::string status_; + bool statusIsSet_; + int32_t maxRetryCnt_; + bool maxRetryCntIsSet_; + VodPackageInfo packageInfo_; + bool packageInfoIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_ModifyHarvestTaskResponse_H_ diff --git a/live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusRequest.h b/live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusRequest.h new file mode 100644 index 000000000..919628298 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusRequest.h @@ -0,0 +1,94 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_UpdateHarvestJobStatusRequest_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_UpdateHarvestJobStatusRequest_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_LIVE_V1_EXPORT UpdateHarvestJobStatusRequest + : public ModelBase +{ +public: + UpdateHarvestJobStatusRequest(); + virtual ~UpdateHarvestJobStatusRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// UpdateHarvestJobStatusRequest members + + /// + /// 服务鉴权Token，服务开启鉴权，必须携带Access-Control-Allow-Internal访问服务。 + /// + + std::string getAccessControlAllowInternal() const; + bool accessControlAllowInternalIsSet() const; + void unsetaccessControlAllowInternal(); + void setAccessControlAllowInternal(const std::string& value); + + /// + /// 服务鉴权Token，服务开启鉴权，必须携带Access-Control-Allow-External访问服务。 + /// + + std::string getAccessControlAllowExternal() const; + bool accessControlAllowExternalIsSet() const; + void unsetaccessControlAllowExternal(); + void setAccessControlAllowExternal(const std::string& value); + + /// + /// + /// + + UpdateHarvestJobStatusRequestBody getBody() const; + bool bodyIsSet() const; + void unsetbody(); + void setBody(const UpdateHarvestJobStatusRequestBody& value); + + +protected: + std::string accessControlAllowInternal_; + bool accessControlAllowInternalIsSet_; + std::string accessControlAllowExternal_; + bool accessControlAllowExternalIsSet_; + UpdateHarvestJobStatusRequestBody body_; + bool bodyIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + UpdateHarvestJobStatusRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_UpdateHarvestJobStatusRequest_H_ diff --git a/live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusRequestBody.h b/live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusRequestBody.h new file mode 100644 index 000000000..2bd69d5a1 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusRequestBody.h @@ -0,0 +1,75 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_UpdateHarvestJobStatusRequestBody_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_UpdateHarvestJobStatusRequestBody_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// 修改状态请求体 +/// +class HUAWEICLOUD_LIVE_V1_EXPORT UpdateHarvestJobStatusRequestBody + : public ModelBase +{ +public: + UpdateHarvestJobStatusRequestBody(); + virtual ~UpdateHarvestJobStatusRequestBody(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// UpdateHarvestJobStatusRequestBody members + + /// + /// 任务ID + /// + + std::string getJobId() const; + bool jobIdIsSet() const; + void unsetjobId(); + void setJobId(const std::string& value); + + /// + /// 任务状态 + /// + + std::string getStatus() const; + bool statusIsSet() const; + void unsetstatus(); + void setStatus(const std::string& value); + + +protected: + std::string jobId_; + bool jobIdIsSet_; + std::string status_; + bool statusIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_UpdateHarvestJobStatusRequestBody_H_ diff --git a/live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusResponse.h b/live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusResponse.h new file mode 100644 index 000000000..51b2b4498 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/UpdateHarvestJobStatusResponse.h @@ -0,0 +1,189 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_UpdateHarvestJobStatusResponse_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_UpdateHarvestJobStatusResponse_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_LIVE_V1_EXPORT UpdateHarvestJobStatusResponse + : public ModelBase, public HttpResponse +{ +public: + UpdateHarvestJobStatusResponse(); + virtual ~UpdateHarvestJobStatusResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// UpdateHarvestJobStatusResponse members + + /// + /// 任务ID + /// + + std::string getJobId() const; + bool jobIdIsSet() const; + void unsetjobId(); + void setJobId(const std::string& value); + + /// + /// 频道推流域名 + /// + + std::string getDomain() const; + bool domainIsSet() const; + void unsetdomain(); + void setDomain(const std::string& value); + + /// + /// 组名或应用名 + /// + + std::string getAppName() const; + bool appNameIsSet() const; + void unsetappName(); + void setAppName(const std::string& value); + + /// + /// 频道ID。频道唯一标识，为必填项。频道ID不建议输入下划线“_”，否则会影响转码和截图任务 + /// + + std::string getId() const; + bool idIsSet() const; + void unsetid(); + void setId(const std::string& value); + + /// + /// 开始时间。Unix时间错，单位为秒 + /// + + int32_t getStartTime() const; + bool startTimeIsSet() const; + void unsetstartTime(); + void setStartTime(int32_t value); + + /// + /// 结束时间。Unix时间错，单位为秒 + /// + + int32_t getEndTime() const; + bool endTimeIsSet() const; + void unsetendTime(); + void setEndTime(int32_t value); + + /// + /// 任务创建时间。Unix时间错，单位为秒 + /// + + int32_t getCreateTime() const; + bool createTimeIsSet() const; + void unsetcreateTime(); + void setCreateTime(int32_t value); + + /// + /// 事件名称 + /// + + std::string getEventName() const; + bool eventNameIsSet() const; + void unseteventName(); + void setEventName(const std::string& value); + + /// + /// 任务描述 + /// + + std::string getTaskDesc() const; + bool taskDescIsSet() const; + void unsettaskDesc(); + void setTaskDesc(const std::string& value); + + /// + /// 任务状态，取值为 [ UNSTART、IN_PROGRESS、SUCCEEDED、FAILED ] + /// + + std::string getStatus() const; + bool statusIsSet() const; + void unsetstatus(); + void setStatus(const std::string& value); + + /// + /// 任务状态为FAILED时，最大允许重试的次数 + /// + + int32_t getMaxRetryCnt() const; + bool maxRetryCntIsSet() const; + void unsetmaxRetryCnt(); + void setMaxRetryCnt(int32_t value); + + /// + /// + /// + + VodPackageInfo getPackageInfo() const; + bool packageInfoIsSet() const; + void unsetpackageInfo(); + void setPackageInfo(const VodPackageInfo& value); + + +protected: + std::string jobId_; + bool jobIdIsSet_; + std::string domain_; + bool domainIsSet_; + std::string appName_; + bool appNameIsSet_; + std::string id_; + bool idIsSet_; + int32_t startTime_; + bool startTimeIsSet_; + int32_t endTime_; + bool endTimeIsSet_; + int32_t createTime_; + bool createTimeIsSet_; + std::string eventName_; + bool eventNameIsSet_; + std::string taskDesc_; + bool taskDescIsSet_; + std::string status_; + bool statusIsSet_; + int32_t maxRetryCnt_; + bool maxRetryCntIsSet_; + VodPackageInfo packageInfo_; + bool packageInfoIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_UpdateHarvestJobStatusResponse_H_ diff --git a/live/include/huaweicloud/live/v1/model/VodPackageInfo.h b/live/include/huaweicloud/live/v1/model/VodPackageInfo.h new file mode 100644 index 000000000..77f94d279 --- /dev/null +++ b/live/include/huaweicloud/live/v1/model/VodPackageInfo.h @@ -0,0 +1,75 @@ + +#ifndef HUAWEICLOUD_SDK_LIVE_V1_MODEL_VodPackageInfo_H_ +#define HUAWEICLOUD_SDK_LIVE_V1_MODEL_VodPackageInfo_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// VOD 打包信息，包括DRM resourceID和转封装模板ID，模板ID通过VOD查询 +/// +class HUAWEICLOUD_LIVE_V1_EXPORT VodPackageInfo + : public ModelBase +{ +public: + VodPackageInfo(); + virtual ~VodPackageInfo(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// VodPackageInfo members + + /// + /// VOD 打包信息，转封装模板ID，模板ID通过VOD查询 + /// + + std::string getPackagingGroupId() const; + bool packagingGroupIdIsSet() const; + void unsetpackagingGroupId(); + void setPackagingGroupId(const std::string& value); + + /// + /// DRM resourceID + /// + + std::string getResourceId() const; + bool resourceIdIsSet() const; + void unsetresourceId(); + void setResourceId(const std::string& value); + + +protected: + std::string packagingGroupId_; + bool packagingGroupIdIsSet_; + std::string resourceId_; + bool resourceIdIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_LIVE_V1_MODEL_VodPackageInfo_H_ diff --git a/live/src/v1/LiveClient.cpp b/live/src/v1/LiveClient.cpp index b40139c1d..844bcb427 100644 --- a/live/src/v1/LiveClient.cpp +++ b/live/src/v1/LiveClient.cpp @@ -2242,6 +2242,247 @@ std::shared_ptr LiveClient::updateDomainHttpsCert return localVarResult; } +std::shared_ptr LiveClient::createHarvestTask(CreateHarvestTaskRequest &request) +{ + std::string localVarPath = "/v1/{project_id}/ott/harvest/task"; + + std::map localVarQueryParams; + std::map localVarHeaderParams; + std::map localVarFormParams; + std::map localVarPathParams; + + + bool isJson = false; + bool isMultiPart = false; + bool isBson = false; + std::string contentType = getContentType("application/json; charset=UTF-8", isJson, isMultiPart, isBson); + localVarHeaderParams["Content-Type"] = contentType; + + if (request.accessControlAllowInternalIsSet()) { + localVarHeaderParams["Access-Control-Allow-Internal"] = parameterToString(request.getAccessControlAllowInternal()); + } + if (request.accessControlAllowExternalIsSet()) { + localVarHeaderParams["Access-Control-Allow-External"] = parameterToString(request.getAccessControlAllowExternal()); + } + + std::string localVarHttpBody; + if (isJson) { + // handle json input + web::json::value localVarJson; + localVarJson = ModelBase::toJson(request.getBody()); + localVarHttpBody = utility::conversions::to_utf8string(localVarJson.serialize()); + } + + std::unique_ptr res = callApi("POST", localVarPath, localVarPathParams, localVarQueryParams, + localVarHeaderParams, localVarHttpBody, LiveMeta::genRequestDefForCreateHarvestTask()); + + std::shared_ptr localVarResult = std::make_shared(); + localVarResult->setStatusCode(res->getStatusCode()); + localVarResult->setHeaderParams(res->getHeaderParams()); + localVarResult->setHttpBody(res->getHttpBody()); + if (!res->getHttpBody().empty()) { + spdlog::info("parse json format response"); + utility::string_t localVarResponse = utility::conversions::to_string_t(res->getHttpBody()); + web::json::value localVarJson = web::json::value::parse(localVarResponse); + localVarResult->fromJson(localVarJson); + } + + return localVarResult; +} +std::shared_ptr LiveClient::deleteHarvestTask(DeleteHarvestTaskRequest &request) +{ + std::string localVarPath = "/v1/{project_id}/ott/harvest/task"; + + std::map localVarQueryParams; + std::map localVarHeaderParams; + std::map localVarFormParams; + std::map localVarPathParams; + + + bool isJson = false; + bool isMultiPart = false; + bool isBson = false; + std::string contentType = getContentType("application/json", isJson, isMultiPart, isBson); + localVarHeaderParams["Content-Type"] = contentType; + + if (request.jobIdIsSet()) { + localVarQueryParams["job_id"] = parameterToString(request.getJobId()); + } + if (request.accessControlAllowInternalIsSet()) { + localVarHeaderParams["Access-Control-Allow-Internal"] = parameterToString(request.getAccessControlAllowInternal()); + } + if (request.accessControlAllowExternalIsSet()) { + localVarHeaderParams["Access-Control-Allow-External"] = parameterToString(request.getAccessControlAllowExternal()); + } + + std::string localVarHttpBody; + + std::unique_ptr res = callApi("DELETE", localVarPath, localVarPathParams, localVarQueryParams, + localVarHeaderParams, localVarHttpBody, LiveMeta::genRequestDefForDeleteHarvestTask()); + + std::shared_ptr localVarResult = std::make_shared(); + localVarResult->setStatusCode(res->getStatusCode()); + localVarResult->setHeaderParams(res->getHeaderParams()); + localVarResult->setHttpBody(res->getHttpBody()); + + return localVarResult; +} +std::shared_ptr LiveClient::listHarvestTask(ListHarvestTaskRequest &request) +{ + std::string localVarPath = "/v1/{project_id}/ott/harvest/task"; + + std::map localVarQueryParams; + std::map localVarHeaderParams; + std::map localVarFormParams; + std::map localVarPathParams; + + + bool isJson = false; + bool isMultiPart = false; + bool isBson = false; + std::string contentType = getContentType("application/json", isJson, isMultiPart, isBson); + localVarHeaderParams["Content-Type"] = contentType; + + if (request.domainIsSet()) { + localVarQueryParams["domain"] = parameterToString(request.getDomain()); + } + if (request.appNameIsSet()) { + localVarQueryParams["app_name"] = parameterToString(request.getAppName()); + } + if (request.idIsSet()) { + localVarQueryParams["id"] = parameterToString(request.getId()); + } + if (request.jobIdIsSet()) { + localVarQueryParams["job_id"] = parameterToString(request.getJobId()); + } + if (request.startTimeIsSet()) { + localVarQueryParams["start_time"] = parameterToString(request.getStartTime()); + } + if (request.endTimeIsSet()) { + localVarQueryParams["end_time"] = parameterToString(request.getEndTime()); + } + if (request.eventNameIsSet()) { + localVarQueryParams["event_name"] = parameterToString(request.getEventName()); + } + if (request.limitIsSet()) { + localVarQueryParams["limit"] = parameterToString(request.getLimit()); + } + if (request.offsetIsSet()) { + localVarQueryParams["offset"] = parameterToString(request.getOffset()); + } + if (request.accessControlAllowInternalIsSet()) { + localVarHeaderParams["Access-Control-Allow-Internal"] = parameterToString(request.getAccessControlAllowInternal()); + } + if (request.accessControlAllowExternalIsSet()) { + localVarHeaderParams["Access-Control-Allow-External"] = parameterToString(request.getAccessControlAllowExternal()); + } + + std::string localVarHttpBody; + + std::unique_ptr res = callApi("GET", localVarPath, localVarPathParams, localVarQueryParams, + localVarHeaderParams, localVarHttpBody, LiveMeta::genRequestDefForListHarvestTask()); + + std::shared_ptr localVarResult = std::make_shared(); + localVarResult->setStatusCode(res->getStatusCode()); + localVarResult->setHeaderParams(res->getHeaderParams()); + localVarResult->setHttpBody(res->getHttpBody()); + + return localVarResult; +} +std::shared_ptr LiveClient::modifyHarvestTask(ModifyHarvestTaskRequest &request) +{ + std::string localVarPath = "/v1/{project_id}/ott/harvest/task"; + + std::map localVarQueryParams; + std::map localVarHeaderParams; + std::map localVarFormParams; + std::map localVarPathParams; + + + bool isJson = false; + bool isMultiPart = false; + bool isBson = false; + std::string contentType = getContentType("application/json; charset=UTF-8", isJson, isMultiPart, isBson); + localVarHeaderParams["Content-Type"] = contentType; + + if (request.accessControlAllowInternalIsSet()) { + localVarHeaderParams["Access-Control-Allow-Internal"] = parameterToString(request.getAccessControlAllowInternal()); + } + if (request.accessControlAllowExternalIsSet()) { + localVarHeaderParams["Access-Control-Allow-External"] = parameterToString(request.getAccessControlAllowExternal()); + } + + std::string localVarHttpBody; + if (isJson) { + // handle json input + web::json::value localVarJson; + localVarJson = ModelBase::toJson(request.getBody()); + localVarHttpBody = utility::conversions::to_utf8string(localVarJson.serialize()); + } + + std::unique_ptr res = callApi("PUT", localVarPath, localVarPathParams, localVarQueryParams, + localVarHeaderParams, localVarHttpBody, LiveMeta::genRequestDefForModifyHarvestTask()); + + std::shared_ptr localVarResult = std::make_shared(); + localVarResult->setStatusCode(res->getStatusCode()); + localVarResult->setHeaderParams(res->getHeaderParams()); + localVarResult->setHttpBody(res->getHttpBody()); + if (!res->getHttpBody().empty()) { + spdlog::info("parse json format response"); + utility::string_t localVarResponse = utility::conversions::to_string_t(res->getHttpBody()); + web::json::value localVarJson = web::json::value::parse(localVarResponse); + localVarResult->fromJson(localVarJson); + } + + return localVarResult; +} +std::shared_ptr LiveClient::updateHarvestJobStatus(UpdateHarvestJobStatusRequest &request) +{ + std::string localVarPath = "/v1/{project_id}/ott/harvest/task/status"; + + std::map localVarQueryParams; + std::map localVarHeaderParams; + std::map localVarFormParams; + std::map localVarPathParams; + + + bool isJson = false; + bool isMultiPart = false; + bool isBson = false; + std::string contentType = getContentType("application/json; charset=UTF-8", isJson, isMultiPart, isBson); + localVarHeaderParams["Content-Type"] = contentType; + + if (request.accessControlAllowInternalIsSet()) { + localVarHeaderParams["Access-Control-Allow-Internal"] = parameterToString(request.getAccessControlAllowInternal()); + } + if (request.accessControlAllowExternalIsSet()) { + localVarHeaderParams["Access-Control-Allow-External"] = parameterToString(request.getAccessControlAllowExternal()); + } + + std::string localVarHttpBody; + if (isJson) { + // handle json input + web::json::value localVarJson; + localVarJson = ModelBase::toJson(request.getBody()); + localVarHttpBody = utility::conversions::to_utf8string(localVarJson.serialize()); + } + + std::unique_ptr res = callApi("PUT", localVarPath, localVarPathParams, localVarQueryParams, + localVarHeaderParams, localVarHttpBody, LiveMeta::genRequestDefForUpdateHarvestJobStatus()); + + std::shared_ptr localVarResult = std::make_shared(); + localVarResult->setStatusCode(res->getStatusCode()); + localVarResult->setHeaderParams(res->getHeaderParams()); + localVarResult->setHttpBody(res->getHttpBody()); + if (!res->getHttpBody().empty()) { + spdlog::info("parse json format response"); + utility::string_t localVarResponse = utility::conversions::to_string_t(res->getHttpBody()); + web::json::value localVarJson = web::json::value::parse(localVarResponse); + localVarResult->fromJson(localVarJson); + } + + return localVarResult; +} std::shared_ptr LiveClient::updateObsBucketAuthorityPublic(UpdateObsBucketAuthorityPublicRequest &request) { std::string localVarPath = "/v1/{project_id}/obs/authority"; diff --git a/live/src/v1/LiveMeta.cpp b/live/src/v1/LiveMeta.cpp index 1ddd8c3ef..33d6363ca 100644 --- a/live/src/v1/LiveMeta.cpp +++ b/live/src/v1/LiveMeta.cpp @@ -647,6 +647,123 @@ HttpRequestDef LiveMeta::genRequestDefForUpdateDomainHttpsCert() { return reqDefBuilder; } +HttpRequestDef LiveMeta::genRequestDefForCreateHarvestTask() { + HttpRequestDef reqDefBuilder; + FieldDef headerParamAccessControlAllowInternal; + reqDefBuilder.withRequestField(headerParamAccessControlAllowInternal + .withName("AccessControlAllowInternal") + .withJsonTag("Access-Control-Allow-Internal") + .withLocationType(Header_)); + FieldDef headerParamAccessControlAllowExternal; + reqDefBuilder.withRequestField(headerParamAccessControlAllowExternal + .withName("AccessControlAllowExternal") + .withJsonTag("Access-Control-Allow-External") + .withLocationType(Header_)); + FieldDef bodyParam; + reqDefBuilder.withRequestField(bodyParam. + withName("Body"). + withLocationType(Body_)); + return reqDefBuilder; +} + +HttpRequestDef LiveMeta::genRequestDefForDeleteHarvestTask() { + HttpRequestDef reqDefBuilder; + reqDefBuilder.withRequestField(FieldDef().withName("JobId") + .withJsonTag("job_id") + .withLocationType(Query_)); + FieldDef headerParamAccessControlAllowInternal; + reqDefBuilder.withRequestField(headerParamAccessControlAllowInternal + .withName("AccessControlAllowInternal") + .withJsonTag("Access-Control-Allow-Internal") + .withLocationType(Header_)); + FieldDef headerParamAccessControlAllowExternal; + reqDefBuilder.withRequestField(headerParamAccessControlAllowExternal + .withName("AccessControlAllowExternal") + .withJsonTag("Access-Control-Allow-External") + .withLocationType(Header_)); + return reqDefBuilder; +} + +HttpRequestDef LiveMeta::genRequestDefForListHarvestTask() { + HttpRequestDef reqDefBuilder; + reqDefBuilder.withRequestField(FieldDef().withName("Domain") + .withJsonTag("domain") + .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("AppName") + .withJsonTag("app_name") + .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("Id") + .withJsonTag("id") + .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("JobId") + .withJsonTag("job_id") + .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("StartTime") + .withJsonTag("start_time") + .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("EndTime") + .withJsonTag("end_time") + .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("EventName") + .withJsonTag("event_name") + .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("Limit") + .withJsonTag("limit") + .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("Offset") + .withJsonTag("offset") + .withLocationType(Query_)); + FieldDef headerParamAccessControlAllowInternal; + reqDefBuilder.withRequestField(headerParamAccessControlAllowInternal + .withName("AccessControlAllowInternal") + .withJsonTag("Access-Control-Allow-Internal") + .withLocationType(Header_)); + FieldDef headerParamAccessControlAllowExternal; + reqDefBuilder.withRequestField(headerParamAccessControlAllowExternal + .withName("AccessControlAllowExternal") + .withJsonTag("Access-Control-Allow-External") + .withLocationType(Header_)); + return reqDefBuilder; +} + +HttpRequestDef LiveMeta::genRequestDefForModifyHarvestTask() { + HttpRequestDef reqDefBuilder; + FieldDef headerParamAccessControlAllowInternal; + reqDefBuilder.withRequestField(headerParamAccessControlAllowInternal + .withName("AccessControlAllowInternal") + .withJsonTag("Access-Control-Allow-Internal") + .withLocationType(Header_)); + FieldDef headerParamAccessControlAllowExternal; + reqDefBuilder.withRequestField(headerParamAccessControlAllowExternal + .withName("AccessControlAllowExternal") + .withJsonTag("Access-Control-Allow-External") + .withLocationType(Header_)); + FieldDef bodyParam; + reqDefBuilder.withRequestField(bodyParam. + withName("Body"). + withLocationType(Body_)); + return reqDefBuilder; +} + +HttpRequestDef LiveMeta::genRequestDefForUpdateHarvestJobStatus() { + HttpRequestDef reqDefBuilder; + FieldDef headerParamAccessControlAllowInternal; + reqDefBuilder.withRequestField(headerParamAccessControlAllowInternal + .withName("AccessControlAllowInternal") + .withJsonTag("Access-Control-Allow-Internal") + .withLocationType(Header_)); + FieldDef headerParamAccessControlAllowExternal; + reqDefBuilder.withRequestField(headerParamAccessControlAllowExternal + .withName("AccessControlAllowExternal") + .withJsonTag("Access-Control-Allow-External") + .withLocationType(Header_)); + FieldDef bodyParam; + reqDefBuilder.withRequestField(bodyParam. + withName("Body"). + withLocationType(Body_)); + return reqDefBuilder; +} + HttpRequestDef LiveMeta::genRequestDefForUpdateObsBucketAuthorityPublic() { HttpRequestDef reqDefBuilder; FieldDef bodyParam; diff --git a/live/src/v1/model/CreateHarvestTaskInfoReq.cpp b/live/src/v1/model/CreateHarvestTaskInfoReq.cpp new file mode 100644 index 000000000..040832e00 --- /dev/null +++ b/live/src/v1/model/CreateHarvestTaskInfoReq.cpp @@ -0,0 +1,323 @@ + + +#include "huaweicloud/live/v1/model/CreateHarvestTaskInfoReq.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +CreateHarvestTaskInfoReq::CreateHarvestTaskInfoReq() +{ + domain_ = ""; + domainIsSet_ = false; + appName_ = ""; + appNameIsSet_ = false; + id_ = ""; + idIsSet_ = false; + startTime_ = 0; + startTimeIsSet_ = false; + endTime_ = 0; + endTimeIsSet_ = false; + eventName_ = ""; + eventNameIsSet_ = false; + taskDesc_ = ""; + taskDescIsSet_ = false; + packageInfoIsSet_ = false; +} + +CreateHarvestTaskInfoReq::~CreateHarvestTaskInfoReq() = default; + +void CreateHarvestTaskInfoReq::validate() +{ +} + +web::json::value CreateHarvestTaskInfoReq::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(domainIsSet_) { + val[utility::conversions::to_string_t("domain")] = ModelBase::toJson(domain_); + } + if(appNameIsSet_) { + val[utility::conversions::to_string_t("app_name")] = ModelBase::toJson(appName_); + } + if(idIsSet_) { + val[utility::conversions::to_string_t("id")] = ModelBase::toJson(id_); + } + if(startTimeIsSet_) { + val[utility::conversions::to_string_t("start_time")] = ModelBase::toJson(startTime_); + } + if(endTimeIsSet_) { + val[utility::conversions::to_string_t("end_time")] = ModelBase::toJson(endTime_); + } + if(eventNameIsSet_) { + val[utility::conversions::to_string_t("event_name")] = ModelBase::toJson(eventName_); + } + if(taskDescIsSet_) { + val[utility::conversions::to_string_t("task_desc")] = ModelBase::toJson(taskDesc_); + } + if(packageInfoIsSet_) { + val[utility::conversions::to_string_t("package_info")] = ModelBase::toJson(packageInfo_); + } + + return val; +} +bool CreateHarvestTaskInfoReq::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("domain"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("domain")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setDomain(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("app_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("app_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAppName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("start_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("start_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStartTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("end_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("end_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEndTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("event_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("event_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEventName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("task_desc"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("task_desc")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTaskDesc(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("package_info"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("package_info")); + if(!fieldValue.is_null()) + { + VodPackageInfo refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setPackageInfo(refVal); + } + } + return ok; +} + + +std::string CreateHarvestTaskInfoReq::getDomain() const +{ + return domain_; +} + +void CreateHarvestTaskInfoReq::setDomain(const std::string& value) +{ + domain_ = value; + domainIsSet_ = true; +} + +bool CreateHarvestTaskInfoReq::domainIsSet() const +{ + return domainIsSet_; +} + +void CreateHarvestTaskInfoReq::unsetdomain() +{ + domainIsSet_ = false; +} + +std::string CreateHarvestTaskInfoReq::getAppName() const +{ + return appName_; +} + +void CreateHarvestTaskInfoReq::setAppName(const std::string& value) +{ + appName_ = value; + appNameIsSet_ = true; +} + +bool CreateHarvestTaskInfoReq::appNameIsSet() const +{ + return appNameIsSet_; +} + +void CreateHarvestTaskInfoReq::unsetappName() +{ + appNameIsSet_ = false; +} + +std::string CreateHarvestTaskInfoReq::getId() const +{ + return id_; +} + +void CreateHarvestTaskInfoReq::setId(const std::string& value) +{ + id_ = value; + idIsSet_ = true; +} + +bool CreateHarvestTaskInfoReq::idIsSet() const +{ + return idIsSet_; +} + +void CreateHarvestTaskInfoReq::unsetid() +{ + idIsSet_ = false; +} + +int32_t CreateHarvestTaskInfoReq::getStartTime() const +{ + return startTime_; +} + +void CreateHarvestTaskInfoReq::setStartTime(int32_t value) +{ + startTime_ = value; + startTimeIsSet_ = true; +} + +bool CreateHarvestTaskInfoReq::startTimeIsSet() const +{ + return startTimeIsSet_; +} + +void CreateHarvestTaskInfoReq::unsetstartTime() +{ + startTimeIsSet_ = false; +} + +int32_t CreateHarvestTaskInfoReq::getEndTime() const +{ + return endTime_; +} + +void CreateHarvestTaskInfoReq::setEndTime(int32_t value) +{ + endTime_ = value; + endTimeIsSet_ = true; +} + +bool CreateHarvestTaskInfoReq::endTimeIsSet() const +{ + return endTimeIsSet_; +} + +void CreateHarvestTaskInfoReq::unsetendTime() +{ + endTimeIsSet_ = false; +} + +std::string CreateHarvestTaskInfoReq::getEventName() const +{ + return eventName_; +} + +void CreateHarvestTaskInfoReq::setEventName(const std::string& value) +{ + eventName_ = value; + eventNameIsSet_ = true; +} + +bool CreateHarvestTaskInfoReq::eventNameIsSet() const +{ + return eventNameIsSet_; +} + +void CreateHarvestTaskInfoReq::unseteventName() +{ + eventNameIsSet_ = false; +} + +std::string CreateHarvestTaskInfoReq::getTaskDesc() const +{ + return taskDesc_; +} + +void CreateHarvestTaskInfoReq::setTaskDesc(const std::string& value) +{ + taskDesc_ = value; + taskDescIsSet_ = true; +} + +bool CreateHarvestTaskInfoReq::taskDescIsSet() const +{ + return taskDescIsSet_; +} + +void CreateHarvestTaskInfoReq::unsettaskDesc() +{ + taskDescIsSet_ = false; +} + +VodPackageInfo CreateHarvestTaskInfoReq::getPackageInfo() const +{ + return packageInfo_; +} + +void CreateHarvestTaskInfoReq::setPackageInfo(const VodPackageInfo& value) +{ + packageInfo_ = value; + packageInfoIsSet_ = true; +} + +bool CreateHarvestTaskInfoReq::packageInfoIsSet() const +{ + return packageInfoIsSet_; +} + +void CreateHarvestTaskInfoReq::unsetpackageInfo() +{ + packageInfoIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/CreateHarvestTaskRequest.cpp b/live/src/v1/model/CreateHarvestTaskRequest.cpp new file mode 100644 index 000000000..59e9e87eb --- /dev/null +++ b/live/src/v1/model/CreateHarvestTaskRequest.cpp @@ -0,0 +1,148 @@ + + +#include "huaweicloud/live/v1/model/CreateHarvestTaskRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +CreateHarvestTaskRequest::CreateHarvestTaskRequest() +{ + accessControlAllowInternal_ = ""; + accessControlAllowInternalIsSet_ = false; + accessControlAllowExternal_ = ""; + accessControlAllowExternalIsSet_ = false; + bodyIsSet_ = false; +} + +CreateHarvestTaskRequest::~CreateHarvestTaskRequest() = default; + +void CreateHarvestTaskRequest::validate() +{ +} + +web::json::value CreateHarvestTaskRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(accessControlAllowInternalIsSet_) { + val[utility::conversions::to_string_t("Access-Control-Allow-Internal")] = ModelBase::toJson(accessControlAllowInternal_); + } + if(accessControlAllowExternalIsSet_) { + val[utility::conversions::to_string_t("Access-Control-Allow-External")] = ModelBase::toJson(accessControlAllowExternal_); + } + if(bodyIsSet_) { + val[utility::conversions::to_string_t("body")] = ModelBase::toJson(body_); + } + + return val; +} +bool CreateHarvestTaskRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("Access-Control-Allow-Internal"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("Access-Control-Allow-Internal")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAccessControlAllowInternal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("Access-Control-Allow-External"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("Access-Control-Allow-External")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAccessControlAllowExternal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("body"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("body")); + if(!fieldValue.is_null()) + { + CreateHarvestTaskInfoReq refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBody(refVal); + } + } + return ok; +} + + +std::string CreateHarvestTaskRequest::getAccessControlAllowInternal() const +{ + return accessControlAllowInternal_; +} + +void CreateHarvestTaskRequest::setAccessControlAllowInternal(const std::string& value) +{ + accessControlAllowInternal_ = value; + accessControlAllowInternalIsSet_ = true; +} + +bool CreateHarvestTaskRequest::accessControlAllowInternalIsSet() const +{ + return accessControlAllowInternalIsSet_; +} + +void CreateHarvestTaskRequest::unsetaccessControlAllowInternal() +{ + accessControlAllowInternalIsSet_ = false; +} + +std::string CreateHarvestTaskRequest::getAccessControlAllowExternal() const +{ + return accessControlAllowExternal_; +} + +void CreateHarvestTaskRequest::setAccessControlAllowExternal(const std::string& value) +{ + accessControlAllowExternal_ = value; + accessControlAllowExternalIsSet_ = true; +} + +bool CreateHarvestTaskRequest::accessControlAllowExternalIsSet() const +{ + return accessControlAllowExternalIsSet_; +} + +void CreateHarvestTaskRequest::unsetaccessControlAllowExternal() +{ + accessControlAllowExternalIsSet_ = false; +} + +CreateHarvestTaskInfoReq CreateHarvestTaskRequest::getBody() const +{ + return body_; +} + +void CreateHarvestTaskRequest::setBody(const CreateHarvestTaskInfoReq& value) +{ + body_ = value; + bodyIsSet_ = true; +} + +bool CreateHarvestTaskRequest::bodyIsSet() const +{ + return bodyIsSet_; +} + +void CreateHarvestTaskRequest::unsetbody() +{ + bodyIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/CreateHarvestTaskResponse.cpp b/live/src/v1/model/CreateHarvestTaskResponse.cpp new file mode 100644 index 000000000..69d138c57 --- /dev/null +++ b/live/src/v1/model/CreateHarvestTaskResponse.cpp @@ -0,0 +1,463 @@ + + +#include "huaweicloud/live/v1/model/CreateHarvestTaskResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +CreateHarvestTaskResponse::CreateHarvestTaskResponse() +{ + jobId_ = ""; + jobIdIsSet_ = false; + domain_ = ""; + domainIsSet_ = false; + appName_ = ""; + appNameIsSet_ = false; + id_ = ""; + idIsSet_ = false; + startTime_ = 0; + startTimeIsSet_ = false; + endTime_ = 0; + endTimeIsSet_ = false; + createTime_ = 0; + createTimeIsSet_ = false; + eventName_ = ""; + eventNameIsSet_ = false; + taskDesc_ = ""; + taskDescIsSet_ = false; + status_ = ""; + statusIsSet_ = false; + maxRetryCnt_ = 0; + maxRetryCntIsSet_ = false; + packageInfoIsSet_ = false; +} + +CreateHarvestTaskResponse::~CreateHarvestTaskResponse() = default; + +void CreateHarvestTaskResponse::validate() +{ +} + +web::json::value CreateHarvestTaskResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(jobIdIsSet_) { + val[utility::conversions::to_string_t("job_id")] = ModelBase::toJson(jobId_); + } + if(domainIsSet_) { + val[utility::conversions::to_string_t("domain")] = ModelBase::toJson(domain_); + } + if(appNameIsSet_) { + val[utility::conversions::to_string_t("app_name")] = ModelBase::toJson(appName_); + } + if(idIsSet_) { + val[utility::conversions::to_string_t("id")] = ModelBase::toJson(id_); + } + if(startTimeIsSet_) { + val[utility::conversions::to_string_t("start_time")] = ModelBase::toJson(startTime_); + } + if(endTimeIsSet_) { + val[utility::conversions::to_string_t("end_time")] = ModelBase::toJson(endTime_); + } + if(createTimeIsSet_) { + val[utility::conversions::to_string_t("create_time")] = ModelBase::toJson(createTime_); + } + if(eventNameIsSet_) { + val[utility::conversions::to_string_t("event_name")] = ModelBase::toJson(eventName_); + } + if(taskDescIsSet_) { + val[utility::conversions::to_string_t("task_desc")] = ModelBase::toJson(taskDesc_); + } + if(statusIsSet_) { + val[utility::conversions::to_string_t("status")] = ModelBase::toJson(status_); + } + if(maxRetryCntIsSet_) { + val[utility::conversions::to_string_t("max_retry_cnt")] = ModelBase::toJson(maxRetryCnt_); + } + if(packageInfoIsSet_) { + val[utility::conversions::to_string_t("package_info")] = ModelBase::toJson(packageInfo_); + } + + return val; +} +bool CreateHarvestTaskResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("job_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("job_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setJobId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("domain"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("domain")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setDomain(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("app_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("app_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAppName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("start_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("start_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStartTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("end_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("end_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEndTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("create_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("create_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setCreateTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("event_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("event_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEventName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("task_desc"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("task_desc")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTaskDesc(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("status"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("status")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStatus(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("max_retry_cnt"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("max_retry_cnt")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setMaxRetryCnt(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("package_info"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("package_info")); + if(!fieldValue.is_null()) + { + VodPackageInfo refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setPackageInfo(refVal); + } + } + return ok; +} + + +std::string CreateHarvestTaskResponse::getJobId() const +{ + return jobId_; +} + +void CreateHarvestTaskResponse::setJobId(const std::string& value) +{ + jobId_ = value; + jobIdIsSet_ = true; +} + +bool CreateHarvestTaskResponse::jobIdIsSet() const +{ + return jobIdIsSet_; +} + +void CreateHarvestTaskResponse::unsetjobId() +{ + jobIdIsSet_ = false; +} + +std::string CreateHarvestTaskResponse::getDomain() const +{ + return domain_; +} + +void CreateHarvestTaskResponse::setDomain(const std::string& value) +{ + domain_ = value; + domainIsSet_ = true; +} + +bool CreateHarvestTaskResponse::domainIsSet() const +{ + return domainIsSet_; +} + +void CreateHarvestTaskResponse::unsetdomain() +{ + domainIsSet_ = false; +} + +std::string CreateHarvestTaskResponse::getAppName() const +{ + return appName_; +} + +void CreateHarvestTaskResponse::setAppName(const std::string& value) +{ + appName_ = value; + appNameIsSet_ = true; +} + +bool CreateHarvestTaskResponse::appNameIsSet() const +{ + return appNameIsSet_; +} + +void CreateHarvestTaskResponse::unsetappName() +{ + appNameIsSet_ = false; +} + +std::string CreateHarvestTaskResponse::getId() const +{ + return id_; +} + +void CreateHarvestTaskResponse::setId(const std::string& value) +{ + id_ = value; + idIsSet_ = true; +} + +bool CreateHarvestTaskResponse::idIsSet() const +{ + return idIsSet_; +} + +void CreateHarvestTaskResponse::unsetid() +{ + idIsSet_ = false; +} + +int32_t CreateHarvestTaskResponse::getStartTime() const +{ + return startTime_; +} + +void CreateHarvestTaskResponse::setStartTime(int32_t value) +{ + startTime_ = value; + startTimeIsSet_ = true; +} + +bool CreateHarvestTaskResponse::startTimeIsSet() const +{ + return startTimeIsSet_; +} + +void CreateHarvestTaskResponse::unsetstartTime() +{ + startTimeIsSet_ = false; +} + +int32_t CreateHarvestTaskResponse::getEndTime() const +{ + return endTime_; +} + +void CreateHarvestTaskResponse::setEndTime(int32_t value) +{ + endTime_ = value; + endTimeIsSet_ = true; +} + +bool CreateHarvestTaskResponse::endTimeIsSet() const +{ + return endTimeIsSet_; +} + +void CreateHarvestTaskResponse::unsetendTime() +{ + endTimeIsSet_ = false; +} + +int32_t CreateHarvestTaskResponse::getCreateTime() const +{ + return createTime_; +} + +void CreateHarvestTaskResponse::setCreateTime(int32_t value) +{ + createTime_ = value; + createTimeIsSet_ = true; +} + +bool CreateHarvestTaskResponse::createTimeIsSet() const +{ + return createTimeIsSet_; +} + +void CreateHarvestTaskResponse::unsetcreateTime() +{ + createTimeIsSet_ = false; +} + +std::string CreateHarvestTaskResponse::getEventName() const +{ + return eventName_; +} + +void CreateHarvestTaskResponse::setEventName(const std::string& value) +{ + eventName_ = value; + eventNameIsSet_ = true; +} + +bool CreateHarvestTaskResponse::eventNameIsSet() const +{ + return eventNameIsSet_; +} + +void CreateHarvestTaskResponse::unseteventName() +{ + eventNameIsSet_ = false; +} + +std::string CreateHarvestTaskResponse::getTaskDesc() const +{ + return taskDesc_; +} + +void CreateHarvestTaskResponse::setTaskDesc(const std::string& value) +{ + taskDesc_ = value; + taskDescIsSet_ = true; +} + +bool CreateHarvestTaskResponse::taskDescIsSet() const +{ + return taskDescIsSet_; +} + +void CreateHarvestTaskResponse::unsettaskDesc() +{ + taskDescIsSet_ = false; +} + +std::string CreateHarvestTaskResponse::getStatus() const +{ + return status_; +} + +void CreateHarvestTaskResponse::setStatus(const std::string& value) +{ + status_ = value; + statusIsSet_ = true; +} + +bool CreateHarvestTaskResponse::statusIsSet() const +{ + return statusIsSet_; +} + +void CreateHarvestTaskResponse::unsetstatus() +{ + statusIsSet_ = false; +} + +int32_t CreateHarvestTaskResponse::getMaxRetryCnt() const +{ + return maxRetryCnt_; +} + +void CreateHarvestTaskResponse::setMaxRetryCnt(int32_t value) +{ + maxRetryCnt_ = value; + maxRetryCntIsSet_ = true; +} + +bool CreateHarvestTaskResponse::maxRetryCntIsSet() const +{ + return maxRetryCntIsSet_; +} + +void CreateHarvestTaskResponse::unsetmaxRetryCnt() +{ + maxRetryCntIsSet_ = false; +} + +VodPackageInfo CreateHarvestTaskResponse::getPackageInfo() const +{ + return packageInfo_; +} + +void CreateHarvestTaskResponse::setPackageInfo(const VodPackageInfo& value) +{ + packageInfo_ = value; + packageInfoIsSet_ = true; +} + +bool CreateHarvestTaskResponse::packageInfoIsSet() const +{ + return packageInfoIsSet_; +} + +void CreateHarvestTaskResponse::unsetpackageInfo() +{ + packageInfoIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/DeleteHarvestTaskRequest.cpp b/live/src/v1/model/DeleteHarvestTaskRequest.cpp new file mode 100644 index 000000000..75c2482a1 --- /dev/null +++ b/live/src/v1/model/DeleteHarvestTaskRequest.cpp @@ -0,0 +1,149 @@ + + +#include "huaweicloud/live/v1/model/DeleteHarvestTaskRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +DeleteHarvestTaskRequest::DeleteHarvestTaskRequest() +{ + accessControlAllowInternal_ = ""; + accessControlAllowInternalIsSet_ = false; + accessControlAllowExternal_ = ""; + accessControlAllowExternalIsSet_ = false; + jobId_ = ""; + jobIdIsSet_ = false; +} + +DeleteHarvestTaskRequest::~DeleteHarvestTaskRequest() = default; + +void DeleteHarvestTaskRequest::validate() +{ +} + +web::json::value DeleteHarvestTaskRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(accessControlAllowInternalIsSet_) { + val[utility::conversions::to_string_t("Access-Control-Allow-Internal")] = ModelBase::toJson(accessControlAllowInternal_); + } + if(accessControlAllowExternalIsSet_) { + val[utility::conversions::to_string_t("Access-Control-Allow-External")] = ModelBase::toJson(accessControlAllowExternal_); + } + if(jobIdIsSet_) { + val[utility::conversions::to_string_t("job_id")] = ModelBase::toJson(jobId_); + } + + return val; +} +bool DeleteHarvestTaskRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("Access-Control-Allow-Internal"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("Access-Control-Allow-Internal")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAccessControlAllowInternal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("Access-Control-Allow-External"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("Access-Control-Allow-External")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAccessControlAllowExternal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("job_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("job_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setJobId(refVal); + } + } + return ok; +} + + +std::string DeleteHarvestTaskRequest::getAccessControlAllowInternal() const +{ + return accessControlAllowInternal_; +} + +void DeleteHarvestTaskRequest::setAccessControlAllowInternal(const std::string& value) +{ + accessControlAllowInternal_ = value; + accessControlAllowInternalIsSet_ = true; +} + +bool DeleteHarvestTaskRequest::accessControlAllowInternalIsSet() const +{ + return accessControlAllowInternalIsSet_; +} + +void DeleteHarvestTaskRequest::unsetaccessControlAllowInternal() +{ + accessControlAllowInternalIsSet_ = false; +} + +std::string DeleteHarvestTaskRequest::getAccessControlAllowExternal() const +{ + return accessControlAllowExternal_; +} + +void DeleteHarvestTaskRequest::setAccessControlAllowExternal(const std::string& value) +{ + accessControlAllowExternal_ = value; + accessControlAllowExternalIsSet_ = true; +} + +bool DeleteHarvestTaskRequest::accessControlAllowExternalIsSet() const +{ + return accessControlAllowExternalIsSet_; +} + +void DeleteHarvestTaskRequest::unsetaccessControlAllowExternal() +{ + accessControlAllowExternalIsSet_ = false; +} + +std::string DeleteHarvestTaskRequest::getJobId() const +{ + return jobId_; +} + +void DeleteHarvestTaskRequest::setJobId(const std::string& value) +{ + jobId_ = value; + jobIdIsSet_ = true; +} + +bool DeleteHarvestTaskRequest::jobIdIsSet() const +{ + return jobIdIsSet_; +} + +void DeleteHarvestTaskRequest::unsetjobId() +{ + jobIdIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/DeleteHarvestTaskResponse.cpp b/live/src/v1/model/DeleteHarvestTaskResponse.cpp new file mode 100644 index 000000000..8eee37d9a --- /dev/null +++ b/live/src/v1/model/DeleteHarvestTaskResponse.cpp @@ -0,0 +1,79 @@ + + +#include "huaweicloud/live/v1/model/DeleteHarvestTaskResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +DeleteHarvestTaskResponse::DeleteHarvestTaskResponse() +{ + jobId_ = ""; + jobIdIsSet_ = false; +} + +DeleteHarvestTaskResponse::~DeleteHarvestTaskResponse() = default; + +void DeleteHarvestTaskResponse::validate() +{ +} + +web::json::value DeleteHarvestTaskResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(jobIdIsSet_) { + val[utility::conversions::to_string_t("job_id")] = ModelBase::toJson(jobId_); + } + + return val; +} +bool DeleteHarvestTaskResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("job_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("job_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setJobId(refVal); + } + } + return ok; +} + + +std::string DeleteHarvestTaskResponse::getJobId() const +{ + return jobId_; +} + +void DeleteHarvestTaskResponse::setJobId(const std::string& value) +{ + jobId_ = value; + jobIdIsSet_ = true; +} + +bool DeleteHarvestTaskResponse::jobIdIsSet() const +{ + return jobIdIsSet_; +} + +void DeleteHarvestTaskResponse::unsetjobId() +{ + jobIdIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/HarvestTaskCreateSucRsp.cpp b/live/src/v1/model/HarvestTaskCreateSucRsp.cpp new file mode 100644 index 000000000..e3e0dd5c4 --- /dev/null +++ b/live/src/v1/model/HarvestTaskCreateSucRsp.cpp @@ -0,0 +1,463 @@ + + +#include "huaweicloud/live/v1/model/HarvestTaskCreateSucRsp.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +HarvestTaskCreateSucRsp::HarvestTaskCreateSucRsp() +{ + jobId_ = ""; + jobIdIsSet_ = false; + domain_ = ""; + domainIsSet_ = false; + appName_ = ""; + appNameIsSet_ = false; + id_ = ""; + idIsSet_ = false; + startTime_ = 0; + startTimeIsSet_ = false; + endTime_ = 0; + endTimeIsSet_ = false; + createTime_ = 0; + createTimeIsSet_ = false; + eventName_ = ""; + eventNameIsSet_ = false; + taskDesc_ = ""; + taskDescIsSet_ = false; + status_ = ""; + statusIsSet_ = false; + maxRetryCnt_ = 0; + maxRetryCntIsSet_ = false; + packageInfoIsSet_ = false; +} + +HarvestTaskCreateSucRsp::~HarvestTaskCreateSucRsp() = default; + +void HarvestTaskCreateSucRsp::validate() +{ +} + +web::json::value HarvestTaskCreateSucRsp::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(jobIdIsSet_) { + val[utility::conversions::to_string_t("job_id")] = ModelBase::toJson(jobId_); + } + if(domainIsSet_) { + val[utility::conversions::to_string_t("domain")] = ModelBase::toJson(domain_); + } + if(appNameIsSet_) { + val[utility::conversions::to_string_t("app_name")] = ModelBase::toJson(appName_); + } + if(idIsSet_) { + val[utility::conversions::to_string_t("id")] = ModelBase::toJson(id_); + } + if(startTimeIsSet_) { + val[utility::conversions::to_string_t("start_time")] = ModelBase::toJson(startTime_); + } + if(endTimeIsSet_) { + val[utility::conversions::to_string_t("end_time")] = ModelBase::toJson(endTime_); + } + if(createTimeIsSet_) { + val[utility::conversions::to_string_t("create_time")] = ModelBase::toJson(createTime_); + } + if(eventNameIsSet_) { + val[utility::conversions::to_string_t("event_name")] = ModelBase::toJson(eventName_); + } + if(taskDescIsSet_) { + val[utility::conversions::to_string_t("task_desc")] = ModelBase::toJson(taskDesc_); + } + if(statusIsSet_) { + val[utility::conversions::to_string_t("status")] = ModelBase::toJson(status_); + } + if(maxRetryCntIsSet_) { + val[utility::conversions::to_string_t("max_retry_cnt")] = ModelBase::toJson(maxRetryCnt_); + } + if(packageInfoIsSet_) { + val[utility::conversions::to_string_t("package_info")] = ModelBase::toJson(packageInfo_); + } + + return val; +} +bool HarvestTaskCreateSucRsp::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("job_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("job_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setJobId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("domain"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("domain")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setDomain(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("app_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("app_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAppName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("start_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("start_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStartTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("end_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("end_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEndTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("create_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("create_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setCreateTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("event_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("event_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEventName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("task_desc"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("task_desc")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTaskDesc(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("status"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("status")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStatus(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("max_retry_cnt"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("max_retry_cnt")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setMaxRetryCnt(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("package_info"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("package_info")); + if(!fieldValue.is_null()) + { + VodPackageInfo refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setPackageInfo(refVal); + } + } + return ok; +} + + +std::string HarvestTaskCreateSucRsp::getJobId() const +{ + return jobId_; +} + +void HarvestTaskCreateSucRsp::setJobId(const std::string& value) +{ + jobId_ = value; + jobIdIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::jobIdIsSet() const +{ + return jobIdIsSet_; +} + +void HarvestTaskCreateSucRsp::unsetjobId() +{ + jobIdIsSet_ = false; +} + +std::string HarvestTaskCreateSucRsp::getDomain() const +{ + return domain_; +} + +void HarvestTaskCreateSucRsp::setDomain(const std::string& value) +{ + domain_ = value; + domainIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::domainIsSet() const +{ + return domainIsSet_; +} + +void HarvestTaskCreateSucRsp::unsetdomain() +{ + domainIsSet_ = false; +} + +std::string HarvestTaskCreateSucRsp::getAppName() const +{ + return appName_; +} + +void HarvestTaskCreateSucRsp::setAppName(const std::string& value) +{ + appName_ = value; + appNameIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::appNameIsSet() const +{ + return appNameIsSet_; +} + +void HarvestTaskCreateSucRsp::unsetappName() +{ + appNameIsSet_ = false; +} + +std::string HarvestTaskCreateSucRsp::getId() const +{ + return id_; +} + +void HarvestTaskCreateSucRsp::setId(const std::string& value) +{ + id_ = value; + idIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::idIsSet() const +{ + return idIsSet_; +} + +void HarvestTaskCreateSucRsp::unsetid() +{ + idIsSet_ = false; +} + +int32_t HarvestTaskCreateSucRsp::getStartTime() const +{ + return startTime_; +} + +void HarvestTaskCreateSucRsp::setStartTime(int32_t value) +{ + startTime_ = value; + startTimeIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::startTimeIsSet() const +{ + return startTimeIsSet_; +} + +void HarvestTaskCreateSucRsp::unsetstartTime() +{ + startTimeIsSet_ = false; +} + +int32_t HarvestTaskCreateSucRsp::getEndTime() const +{ + return endTime_; +} + +void HarvestTaskCreateSucRsp::setEndTime(int32_t value) +{ + endTime_ = value; + endTimeIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::endTimeIsSet() const +{ + return endTimeIsSet_; +} + +void HarvestTaskCreateSucRsp::unsetendTime() +{ + endTimeIsSet_ = false; +} + +int32_t HarvestTaskCreateSucRsp::getCreateTime() const +{ + return createTime_; +} + +void HarvestTaskCreateSucRsp::setCreateTime(int32_t value) +{ + createTime_ = value; + createTimeIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::createTimeIsSet() const +{ + return createTimeIsSet_; +} + +void HarvestTaskCreateSucRsp::unsetcreateTime() +{ + createTimeIsSet_ = false; +} + +std::string HarvestTaskCreateSucRsp::getEventName() const +{ + return eventName_; +} + +void HarvestTaskCreateSucRsp::setEventName(const std::string& value) +{ + eventName_ = value; + eventNameIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::eventNameIsSet() const +{ + return eventNameIsSet_; +} + +void HarvestTaskCreateSucRsp::unseteventName() +{ + eventNameIsSet_ = false; +} + +std::string HarvestTaskCreateSucRsp::getTaskDesc() const +{ + return taskDesc_; +} + +void HarvestTaskCreateSucRsp::setTaskDesc(const std::string& value) +{ + taskDesc_ = value; + taskDescIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::taskDescIsSet() const +{ + return taskDescIsSet_; +} + +void HarvestTaskCreateSucRsp::unsettaskDesc() +{ + taskDescIsSet_ = false; +} + +std::string HarvestTaskCreateSucRsp::getStatus() const +{ + return status_; +} + +void HarvestTaskCreateSucRsp::setStatus(const std::string& value) +{ + status_ = value; + statusIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::statusIsSet() const +{ + return statusIsSet_; +} + +void HarvestTaskCreateSucRsp::unsetstatus() +{ + statusIsSet_ = false; +} + +int32_t HarvestTaskCreateSucRsp::getMaxRetryCnt() const +{ + return maxRetryCnt_; +} + +void HarvestTaskCreateSucRsp::setMaxRetryCnt(int32_t value) +{ + maxRetryCnt_ = value; + maxRetryCntIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::maxRetryCntIsSet() const +{ + return maxRetryCntIsSet_; +} + +void HarvestTaskCreateSucRsp::unsetmaxRetryCnt() +{ + maxRetryCntIsSet_ = false; +} + +VodPackageInfo HarvestTaskCreateSucRsp::getPackageInfo() const +{ + return packageInfo_; +} + +void HarvestTaskCreateSucRsp::setPackageInfo(const VodPackageInfo& value) +{ + packageInfo_ = value; + packageInfoIsSet_ = true; +} + +bool HarvestTaskCreateSucRsp::packageInfoIsSet() const +{ + return packageInfoIsSet_; +} + +void HarvestTaskCreateSucRsp::unsetpackageInfo() +{ + packageInfoIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/ListHarvestTaskRequest.cpp b/live/src/v1/model/ListHarvestTaskRequest.cpp new file mode 100644 index 000000000..30ebfefa3 --- /dev/null +++ b/live/src/v1/model/ListHarvestTaskRequest.cpp @@ -0,0 +1,429 @@ + + +#include "huaweicloud/live/v1/model/ListHarvestTaskRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +ListHarvestTaskRequest::ListHarvestTaskRequest() +{ + accessControlAllowInternal_ = ""; + accessControlAllowInternalIsSet_ = false; + accessControlAllowExternal_ = ""; + accessControlAllowExternalIsSet_ = false; + domain_ = ""; + domainIsSet_ = false; + appName_ = ""; + appNameIsSet_ = false; + id_ = ""; + idIsSet_ = false; + jobId_ = ""; + jobIdIsSet_ = false; + startTime_ = 0; + startTimeIsSet_ = false; + endTime_ = 0; + endTimeIsSet_ = false; + eventName_ = ""; + eventNameIsSet_ = false; + limit_ = 0; + limitIsSet_ = false; + offset_ = 0; + offsetIsSet_ = false; +} + +ListHarvestTaskRequest::~ListHarvestTaskRequest() = default; + +void ListHarvestTaskRequest::validate() +{ +} + +web::json::value ListHarvestTaskRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(accessControlAllowInternalIsSet_) { + val[utility::conversions::to_string_t("Access-Control-Allow-Internal")] = ModelBase::toJson(accessControlAllowInternal_); + } + if(accessControlAllowExternalIsSet_) { + val[utility::conversions::to_string_t("Access-Control-Allow-External")] = ModelBase::toJson(accessControlAllowExternal_); + } + if(domainIsSet_) { + val[utility::conversions::to_string_t("domain")] = ModelBase::toJson(domain_); + } + if(appNameIsSet_) { + val[utility::conversions::to_string_t("app_name")] = ModelBase::toJson(appName_); + } + if(idIsSet_) { + val[utility::conversions::to_string_t("id")] = ModelBase::toJson(id_); + } + if(jobIdIsSet_) { + val[utility::conversions::to_string_t("job_id")] = ModelBase::toJson(jobId_); + } + if(startTimeIsSet_) { + val[utility::conversions::to_string_t("start_time")] = ModelBase::toJson(startTime_); + } + if(endTimeIsSet_) { + val[utility::conversions::to_string_t("end_time")] = ModelBase::toJson(endTime_); + } + if(eventNameIsSet_) { + val[utility::conversions::to_string_t("event_name")] = ModelBase::toJson(eventName_); + } + if(limitIsSet_) { + val[utility::conversions::to_string_t("limit")] = ModelBase::toJson(limit_); + } + if(offsetIsSet_) { + val[utility::conversions::to_string_t("offset")] = ModelBase::toJson(offset_); + } + + return val; +} +bool ListHarvestTaskRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("Access-Control-Allow-Internal"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("Access-Control-Allow-Internal")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAccessControlAllowInternal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("Access-Control-Allow-External"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("Access-Control-Allow-External")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAccessControlAllowExternal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("domain"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("domain")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setDomain(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("app_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("app_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAppName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("job_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("job_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setJobId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("start_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("start_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStartTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("end_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("end_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEndTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("event_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("event_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEventName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("limit"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("limit")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setLimit(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("offset"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("offset")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setOffset(refVal); + } + } + return ok; +} + + +std::string ListHarvestTaskRequest::getAccessControlAllowInternal() const +{ + return accessControlAllowInternal_; +} + +void ListHarvestTaskRequest::setAccessControlAllowInternal(const std::string& value) +{ + accessControlAllowInternal_ = value; + accessControlAllowInternalIsSet_ = true; +} + +bool ListHarvestTaskRequest::accessControlAllowInternalIsSet() const +{ + return accessControlAllowInternalIsSet_; +} + +void ListHarvestTaskRequest::unsetaccessControlAllowInternal() +{ + accessControlAllowInternalIsSet_ = false; +} + +std::string ListHarvestTaskRequest::getAccessControlAllowExternal() const +{ + return accessControlAllowExternal_; +} + +void ListHarvestTaskRequest::setAccessControlAllowExternal(const std::string& value) +{ + accessControlAllowExternal_ = value; + accessControlAllowExternalIsSet_ = true; +} + +bool ListHarvestTaskRequest::accessControlAllowExternalIsSet() const +{ + return accessControlAllowExternalIsSet_; +} + +void ListHarvestTaskRequest::unsetaccessControlAllowExternal() +{ + accessControlAllowExternalIsSet_ = false; +} + +std::string ListHarvestTaskRequest::getDomain() const +{ + return domain_; +} + +void ListHarvestTaskRequest::setDomain(const std::string& value) +{ + domain_ = value; + domainIsSet_ = true; +} + +bool ListHarvestTaskRequest::domainIsSet() const +{ + return domainIsSet_; +} + +void ListHarvestTaskRequest::unsetdomain() +{ + domainIsSet_ = false; +} + +std::string ListHarvestTaskRequest::getAppName() const +{ + return appName_; +} + +void ListHarvestTaskRequest::setAppName(const std::string& value) +{ + appName_ = value; + appNameIsSet_ = true; +} + +bool ListHarvestTaskRequest::appNameIsSet() const +{ + return appNameIsSet_; +} + +void ListHarvestTaskRequest::unsetappName() +{ + appNameIsSet_ = false; +} + +std::string ListHarvestTaskRequest::getId() const +{ + return id_; +} + +void ListHarvestTaskRequest::setId(const std::string& value) +{ + id_ = value; + idIsSet_ = true; +} + +bool ListHarvestTaskRequest::idIsSet() const +{ + return idIsSet_; +} + +void ListHarvestTaskRequest::unsetid() +{ + idIsSet_ = false; +} + +std::string ListHarvestTaskRequest::getJobId() const +{ + return jobId_; +} + +void ListHarvestTaskRequest::setJobId(const std::string& value) +{ + jobId_ = value; + jobIdIsSet_ = true; +} + +bool ListHarvestTaskRequest::jobIdIsSet() const +{ + return jobIdIsSet_; +} + +void ListHarvestTaskRequest::unsetjobId() +{ + jobIdIsSet_ = false; +} + +int32_t ListHarvestTaskRequest::getStartTime() const +{ + return startTime_; +} + +void ListHarvestTaskRequest::setStartTime(int32_t value) +{ + startTime_ = value; + startTimeIsSet_ = true; +} + +bool ListHarvestTaskRequest::startTimeIsSet() const +{ + return startTimeIsSet_; +} + +void ListHarvestTaskRequest::unsetstartTime() +{ + startTimeIsSet_ = false; +} + +int32_t ListHarvestTaskRequest::getEndTime() const +{ + return endTime_; +} + +void ListHarvestTaskRequest::setEndTime(int32_t value) +{ + endTime_ = value; + endTimeIsSet_ = true; +} + +bool ListHarvestTaskRequest::endTimeIsSet() const +{ + return endTimeIsSet_; +} + +void ListHarvestTaskRequest::unsetendTime() +{ + endTimeIsSet_ = false; +} + +std::string ListHarvestTaskRequest::getEventName() const +{ + return eventName_; +} + +void ListHarvestTaskRequest::setEventName(const std::string& value) +{ + eventName_ = value; + eventNameIsSet_ = true; +} + +bool ListHarvestTaskRequest::eventNameIsSet() const +{ + return eventNameIsSet_; +} + +void ListHarvestTaskRequest::unseteventName() +{ + eventNameIsSet_ = false; +} + +int32_t ListHarvestTaskRequest::getLimit() const +{ + return limit_; +} + +void ListHarvestTaskRequest::setLimit(int32_t value) +{ + limit_ = value; + limitIsSet_ = true; +} + +bool ListHarvestTaskRequest::limitIsSet() const +{ + return limitIsSet_; +} + +void ListHarvestTaskRequest::unsetlimit() +{ + limitIsSet_ = false; +} + +int32_t ListHarvestTaskRequest::getOffset() const +{ + return offset_; +} + +void ListHarvestTaskRequest::setOffset(int32_t value) +{ + offset_ = value; + offsetIsSet_ = true; +} + +bool ListHarvestTaskRequest::offsetIsSet() const +{ + return offsetIsSet_; +} + +void ListHarvestTaskRequest::unsetoffset() +{ + offsetIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/ListHarvestTaskResponse.cpp b/live/src/v1/model/ListHarvestTaskResponse.cpp new file mode 100644 index 000000000..74e372d0e --- /dev/null +++ b/live/src/v1/model/ListHarvestTaskResponse.cpp @@ -0,0 +1,113 @@ + + +#include "huaweicloud/live/v1/model/ListHarvestTaskResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +ListHarvestTaskResponse::ListHarvestTaskResponse() +{ + total_ = 0; + totalIsSet_ = false; + harvestTasksIsSet_ = false; +} + +ListHarvestTaskResponse::~ListHarvestTaskResponse() = default; + +void ListHarvestTaskResponse::validate() +{ +} + +web::json::value ListHarvestTaskResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(totalIsSet_) { + val[utility::conversions::to_string_t("total")] = ModelBase::toJson(total_); + } + if(harvestTasksIsSet_) { + val[utility::conversions::to_string_t("harvest_tasks")] = ModelBase::toJson(harvestTasks_); + } + + return val; +} +bool ListHarvestTaskResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("total"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("total")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTotal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("harvest_tasks"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("harvest_tasks")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setHarvestTasks(refVal); + } + } + return ok; +} + + +int32_t ListHarvestTaskResponse::getTotal() const +{ + return total_; +} + +void ListHarvestTaskResponse::setTotal(int32_t value) +{ + total_ = value; + totalIsSet_ = true; +} + +bool ListHarvestTaskResponse::totalIsSet() const +{ + return totalIsSet_; +} + +void ListHarvestTaskResponse::unsettotal() +{ + totalIsSet_ = false; +} + +std::vector& ListHarvestTaskResponse::getHarvestTasks() +{ + return harvestTasks_; +} + +void ListHarvestTaskResponse::setHarvestTasks(const std::vector& value) +{ + harvestTasks_ = value; + harvestTasksIsSet_ = true; +} + +bool ListHarvestTaskResponse::harvestTasksIsSet() const +{ + return harvestTasksIsSet_; +} + +void ListHarvestTaskResponse::unsetharvestTasks() +{ + harvestTasksIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/ModifyHarvestTaskRequest.cpp b/live/src/v1/model/ModifyHarvestTaskRequest.cpp new file mode 100644 index 000000000..8c0734130 --- /dev/null +++ b/live/src/v1/model/ModifyHarvestTaskRequest.cpp @@ -0,0 +1,148 @@ + + +#include "huaweicloud/live/v1/model/ModifyHarvestTaskRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +ModifyHarvestTaskRequest::ModifyHarvestTaskRequest() +{ + accessControlAllowInternal_ = ""; + accessControlAllowInternalIsSet_ = false; + accessControlAllowExternal_ = ""; + accessControlAllowExternalIsSet_ = false; + bodyIsSet_ = false; +} + +ModifyHarvestTaskRequest::~ModifyHarvestTaskRequest() = default; + +void ModifyHarvestTaskRequest::validate() +{ +} + +web::json::value ModifyHarvestTaskRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(accessControlAllowInternalIsSet_) { + val[utility::conversions::to_string_t("Access-Control-Allow-Internal")] = ModelBase::toJson(accessControlAllowInternal_); + } + if(accessControlAllowExternalIsSet_) { + val[utility::conversions::to_string_t("Access-Control-Allow-External")] = ModelBase::toJson(accessControlAllowExternal_); + } + if(bodyIsSet_) { + val[utility::conversions::to_string_t("body")] = ModelBase::toJson(body_); + } + + return val; +} +bool ModifyHarvestTaskRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("Access-Control-Allow-Internal"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("Access-Control-Allow-Internal")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAccessControlAllowInternal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("Access-Control-Allow-External"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("Access-Control-Allow-External")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAccessControlAllowExternal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("body"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("body")); + if(!fieldValue.is_null()) + { + ModifyHarvestTaskRequestBody refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBody(refVal); + } + } + return ok; +} + + +std::string ModifyHarvestTaskRequest::getAccessControlAllowInternal() const +{ + return accessControlAllowInternal_; +} + +void ModifyHarvestTaskRequest::setAccessControlAllowInternal(const std::string& value) +{ + accessControlAllowInternal_ = value; + accessControlAllowInternalIsSet_ = true; +} + +bool ModifyHarvestTaskRequest::accessControlAllowInternalIsSet() const +{ + return accessControlAllowInternalIsSet_; +} + +void ModifyHarvestTaskRequest::unsetaccessControlAllowInternal() +{ + accessControlAllowInternalIsSet_ = false; +} + +std::string ModifyHarvestTaskRequest::getAccessControlAllowExternal() const +{ + return accessControlAllowExternal_; +} + +void ModifyHarvestTaskRequest::setAccessControlAllowExternal(const std::string& value) +{ + accessControlAllowExternal_ = value; + accessControlAllowExternalIsSet_ = true; +} + +bool ModifyHarvestTaskRequest::accessControlAllowExternalIsSet() const +{ + return accessControlAllowExternalIsSet_; +} + +void ModifyHarvestTaskRequest::unsetaccessControlAllowExternal() +{ + accessControlAllowExternalIsSet_ = false; +} + +ModifyHarvestTaskRequestBody ModifyHarvestTaskRequest::getBody() const +{ + return body_; +} + +void ModifyHarvestTaskRequest::setBody(const ModifyHarvestTaskRequestBody& value) +{ + body_ = value; + bodyIsSet_ = true; +} + +bool ModifyHarvestTaskRequest::bodyIsSet() const +{ + return bodyIsSet_; +} + +void ModifyHarvestTaskRequest::unsetbody() +{ + bodyIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/ModifyHarvestTaskRequestBody.cpp b/live/src/v1/model/ModifyHarvestTaskRequestBody.cpp new file mode 100644 index 000000000..62041e71f --- /dev/null +++ b/live/src/v1/model/ModifyHarvestTaskRequestBody.cpp @@ -0,0 +1,358 @@ + + +#include "huaweicloud/live/v1/model/ModifyHarvestTaskRequestBody.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +ModifyHarvestTaskRequestBody::ModifyHarvestTaskRequestBody() +{ + domain_ = ""; + domainIsSet_ = false; + appName_ = ""; + appNameIsSet_ = false; + id_ = ""; + idIsSet_ = false; + startTime_ = 0; + startTimeIsSet_ = false; + endTime_ = 0; + endTimeIsSet_ = false; + eventName_ = ""; + eventNameIsSet_ = false; + jobId_ = ""; + jobIdIsSet_ = false; + taskDesc_ = ""; + taskDescIsSet_ = false; + packageInfoIsSet_ = false; +} + +ModifyHarvestTaskRequestBody::~ModifyHarvestTaskRequestBody() = default; + +void ModifyHarvestTaskRequestBody::validate() +{ +} + +web::json::value ModifyHarvestTaskRequestBody::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(domainIsSet_) { + val[utility::conversions::to_string_t("domain")] = ModelBase::toJson(domain_); + } + if(appNameIsSet_) { + val[utility::conversions::to_string_t("app_name")] = ModelBase::toJson(appName_); + } + if(idIsSet_) { + val[utility::conversions::to_string_t("id")] = ModelBase::toJson(id_); + } + if(startTimeIsSet_) { + val[utility::conversions::to_string_t("start_time")] = ModelBase::toJson(startTime_); + } + if(endTimeIsSet_) { + val[utility::conversions::to_string_t("end_time")] = ModelBase::toJson(endTime_); + } + if(eventNameIsSet_) { + val[utility::conversions::to_string_t("event_name")] = ModelBase::toJson(eventName_); + } + if(jobIdIsSet_) { + val[utility::conversions::to_string_t("job_id")] = ModelBase::toJson(jobId_); + } + if(taskDescIsSet_) { + val[utility::conversions::to_string_t("task_desc")] = ModelBase::toJson(taskDesc_); + } + if(packageInfoIsSet_) { + val[utility::conversions::to_string_t("package_info")] = ModelBase::toJson(packageInfo_); + } + + return val; +} +bool ModifyHarvestTaskRequestBody::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("domain"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("domain")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setDomain(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("app_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("app_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAppName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("start_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("start_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStartTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("end_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("end_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEndTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("event_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("event_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEventName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("job_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("job_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setJobId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("task_desc"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("task_desc")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTaskDesc(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("package_info"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("package_info")); + if(!fieldValue.is_null()) + { + VodPackageInfo refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setPackageInfo(refVal); + } + } + return ok; +} + + +std::string ModifyHarvestTaskRequestBody::getDomain() const +{ + return domain_; +} + +void ModifyHarvestTaskRequestBody::setDomain(const std::string& value) +{ + domain_ = value; + domainIsSet_ = true; +} + +bool ModifyHarvestTaskRequestBody::domainIsSet() const +{ + return domainIsSet_; +} + +void ModifyHarvestTaskRequestBody::unsetdomain() +{ + domainIsSet_ = false; +} + +std::string ModifyHarvestTaskRequestBody::getAppName() const +{ + return appName_; +} + +void ModifyHarvestTaskRequestBody::setAppName(const std::string& value) +{ + appName_ = value; + appNameIsSet_ = true; +} + +bool ModifyHarvestTaskRequestBody::appNameIsSet() const +{ + return appNameIsSet_; +} + +void ModifyHarvestTaskRequestBody::unsetappName() +{ + appNameIsSet_ = false; +} + +std::string ModifyHarvestTaskRequestBody::getId() const +{ + return id_; +} + +void ModifyHarvestTaskRequestBody::setId(const std::string& value) +{ + id_ = value; + idIsSet_ = true; +} + +bool ModifyHarvestTaskRequestBody::idIsSet() const +{ + return idIsSet_; +} + +void ModifyHarvestTaskRequestBody::unsetid() +{ + idIsSet_ = false; +} + +int32_t ModifyHarvestTaskRequestBody::getStartTime() const +{ + return startTime_; +} + +void ModifyHarvestTaskRequestBody::setStartTime(int32_t value) +{ + startTime_ = value; + startTimeIsSet_ = true; +} + +bool ModifyHarvestTaskRequestBody::startTimeIsSet() const +{ + return startTimeIsSet_; +} + +void ModifyHarvestTaskRequestBody::unsetstartTime() +{ + startTimeIsSet_ = false; +} + +int32_t ModifyHarvestTaskRequestBody::getEndTime() const +{ + return endTime_; +} + +void ModifyHarvestTaskRequestBody::setEndTime(int32_t value) +{ + endTime_ = value; + endTimeIsSet_ = true; +} + +bool ModifyHarvestTaskRequestBody::endTimeIsSet() const +{ + return endTimeIsSet_; +} + +void ModifyHarvestTaskRequestBody::unsetendTime() +{ + endTimeIsSet_ = false; +} + +std::string ModifyHarvestTaskRequestBody::getEventName() const +{ + return eventName_; +} + +void ModifyHarvestTaskRequestBody::setEventName(const std::string& value) +{ + eventName_ = value; + eventNameIsSet_ = true; +} + +bool ModifyHarvestTaskRequestBody::eventNameIsSet() const +{ + return eventNameIsSet_; +} + +void ModifyHarvestTaskRequestBody::unseteventName() +{ + eventNameIsSet_ = false; +} + +std::string ModifyHarvestTaskRequestBody::getJobId() const +{ + return jobId_; +} + +void ModifyHarvestTaskRequestBody::setJobId(const std::string& value) +{ + jobId_ = value; + jobIdIsSet_ = true; +} + +bool ModifyHarvestTaskRequestBody::jobIdIsSet() const +{ + return jobIdIsSet_; +} + +void ModifyHarvestTaskRequestBody::unsetjobId() +{ + jobIdIsSet_ = false; +} + +std::string ModifyHarvestTaskRequestBody::getTaskDesc() const +{ + return taskDesc_; +} + +void ModifyHarvestTaskRequestBody::setTaskDesc(const std::string& value) +{ + taskDesc_ = value; + taskDescIsSet_ = true; +} + +bool ModifyHarvestTaskRequestBody::taskDescIsSet() const +{ + return taskDescIsSet_; +} + +void ModifyHarvestTaskRequestBody::unsettaskDesc() +{ + taskDescIsSet_ = false; +} + +VodPackageInfo ModifyHarvestTaskRequestBody::getPackageInfo() const +{ + return packageInfo_; +} + +void ModifyHarvestTaskRequestBody::setPackageInfo(const VodPackageInfo& value) +{ + packageInfo_ = value; + packageInfoIsSet_ = true; +} + +bool ModifyHarvestTaskRequestBody::packageInfoIsSet() const +{ + return packageInfoIsSet_; +} + +void ModifyHarvestTaskRequestBody::unsetpackageInfo() +{ + packageInfoIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/ModifyHarvestTaskResponse.cpp b/live/src/v1/model/ModifyHarvestTaskResponse.cpp new file mode 100644 index 000000000..a9fa6d794 --- /dev/null +++ b/live/src/v1/model/ModifyHarvestTaskResponse.cpp @@ -0,0 +1,463 @@ + + +#include "huaweicloud/live/v1/model/ModifyHarvestTaskResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +ModifyHarvestTaskResponse::ModifyHarvestTaskResponse() +{ + jobId_ = ""; + jobIdIsSet_ = false; + domain_ = ""; + domainIsSet_ = false; + appName_ = ""; + appNameIsSet_ = false; + id_ = ""; + idIsSet_ = false; + startTime_ = 0; + startTimeIsSet_ = false; + endTime_ = 0; + endTimeIsSet_ = false; + createTime_ = 0; + createTimeIsSet_ = false; + eventName_ = ""; + eventNameIsSet_ = false; + taskDesc_ = ""; + taskDescIsSet_ = false; + status_ = ""; + statusIsSet_ = false; + maxRetryCnt_ = 0; + maxRetryCntIsSet_ = false; + packageInfoIsSet_ = false; +} + +ModifyHarvestTaskResponse::~ModifyHarvestTaskResponse() = default; + +void ModifyHarvestTaskResponse::validate() +{ +} + +web::json::value ModifyHarvestTaskResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(jobIdIsSet_) { + val[utility::conversions::to_string_t("job_id")] = ModelBase::toJson(jobId_); + } + if(domainIsSet_) { + val[utility::conversions::to_string_t("domain")] = ModelBase::toJson(domain_); + } + if(appNameIsSet_) { + val[utility::conversions::to_string_t("app_name")] = ModelBase::toJson(appName_); + } + if(idIsSet_) { + val[utility::conversions::to_string_t("id")] = ModelBase::toJson(id_); + } + if(startTimeIsSet_) { + val[utility::conversions::to_string_t("start_time")] = ModelBase::toJson(startTime_); + } + if(endTimeIsSet_) { + val[utility::conversions::to_string_t("end_time")] = ModelBase::toJson(endTime_); + } + if(createTimeIsSet_) { + val[utility::conversions::to_string_t("create_time")] = ModelBase::toJson(createTime_); + } + if(eventNameIsSet_) { + val[utility::conversions::to_string_t("event_name")] = ModelBase::toJson(eventName_); + } + if(taskDescIsSet_) { + val[utility::conversions::to_string_t("task_desc")] = ModelBase::toJson(taskDesc_); + } + if(statusIsSet_) { + val[utility::conversions::to_string_t("status")] = ModelBase::toJson(status_); + } + if(maxRetryCntIsSet_) { + val[utility::conversions::to_string_t("max_retry_cnt")] = ModelBase::toJson(maxRetryCnt_); + } + if(packageInfoIsSet_) { + val[utility::conversions::to_string_t("package_info")] = ModelBase::toJson(packageInfo_); + } + + return val; +} +bool ModifyHarvestTaskResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("job_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("job_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setJobId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("domain"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("domain")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setDomain(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("app_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("app_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAppName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("start_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("start_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStartTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("end_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("end_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEndTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("create_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("create_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setCreateTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("event_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("event_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEventName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("task_desc"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("task_desc")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTaskDesc(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("status"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("status")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStatus(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("max_retry_cnt"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("max_retry_cnt")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setMaxRetryCnt(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("package_info"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("package_info")); + if(!fieldValue.is_null()) + { + VodPackageInfo refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setPackageInfo(refVal); + } + } + return ok; +} + + +std::string ModifyHarvestTaskResponse::getJobId() const +{ + return jobId_; +} + +void ModifyHarvestTaskResponse::setJobId(const std::string& value) +{ + jobId_ = value; + jobIdIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::jobIdIsSet() const +{ + return jobIdIsSet_; +} + +void ModifyHarvestTaskResponse::unsetjobId() +{ + jobIdIsSet_ = false; +} + +std::string ModifyHarvestTaskResponse::getDomain() const +{ + return domain_; +} + +void ModifyHarvestTaskResponse::setDomain(const std::string& value) +{ + domain_ = value; + domainIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::domainIsSet() const +{ + return domainIsSet_; +} + +void ModifyHarvestTaskResponse::unsetdomain() +{ + domainIsSet_ = false; +} + +std::string ModifyHarvestTaskResponse::getAppName() const +{ + return appName_; +} + +void ModifyHarvestTaskResponse::setAppName(const std::string& value) +{ + appName_ = value; + appNameIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::appNameIsSet() const +{ + return appNameIsSet_; +} + +void ModifyHarvestTaskResponse::unsetappName() +{ + appNameIsSet_ = false; +} + +std::string ModifyHarvestTaskResponse::getId() const +{ + return id_; +} + +void ModifyHarvestTaskResponse::setId(const std::string& value) +{ + id_ = value; + idIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::idIsSet() const +{ + return idIsSet_; +} + +void ModifyHarvestTaskResponse::unsetid() +{ + idIsSet_ = false; +} + +int32_t ModifyHarvestTaskResponse::getStartTime() const +{ + return startTime_; +} + +void ModifyHarvestTaskResponse::setStartTime(int32_t value) +{ + startTime_ = value; + startTimeIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::startTimeIsSet() const +{ + return startTimeIsSet_; +} + +void ModifyHarvestTaskResponse::unsetstartTime() +{ + startTimeIsSet_ = false; +} + +int32_t ModifyHarvestTaskResponse::getEndTime() const +{ + return endTime_; +} + +void ModifyHarvestTaskResponse::setEndTime(int32_t value) +{ + endTime_ = value; + endTimeIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::endTimeIsSet() const +{ + return endTimeIsSet_; +} + +void ModifyHarvestTaskResponse::unsetendTime() +{ + endTimeIsSet_ = false; +} + +int32_t ModifyHarvestTaskResponse::getCreateTime() const +{ + return createTime_; +} + +void ModifyHarvestTaskResponse::setCreateTime(int32_t value) +{ + createTime_ = value; + createTimeIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::createTimeIsSet() const +{ + return createTimeIsSet_; +} + +void ModifyHarvestTaskResponse::unsetcreateTime() +{ + createTimeIsSet_ = false; +} + +std::string ModifyHarvestTaskResponse::getEventName() const +{ + return eventName_; +} + +void ModifyHarvestTaskResponse::setEventName(const std::string& value) +{ + eventName_ = value; + eventNameIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::eventNameIsSet() const +{ + return eventNameIsSet_; +} + +void ModifyHarvestTaskResponse::unseteventName() +{ + eventNameIsSet_ = false; +} + +std::string ModifyHarvestTaskResponse::getTaskDesc() const +{ + return taskDesc_; +} + +void ModifyHarvestTaskResponse::setTaskDesc(const std::string& value) +{ + taskDesc_ = value; + taskDescIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::taskDescIsSet() const +{ + return taskDescIsSet_; +} + +void ModifyHarvestTaskResponse::unsettaskDesc() +{ + taskDescIsSet_ = false; +} + +std::string ModifyHarvestTaskResponse::getStatus() const +{ + return status_; +} + +void ModifyHarvestTaskResponse::setStatus(const std::string& value) +{ + status_ = value; + statusIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::statusIsSet() const +{ + return statusIsSet_; +} + +void ModifyHarvestTaskResponse::unsetstatus() +{ + statusIsSet_ = false; +} + +int32_t ModifyHarvestTaskResponse::getMaxRetryCnt() const +{ + return maxRetryCnt_; +} + +void ModifyHarvestTaskResponse::setMaxRetryCnt(int32_t value) +{ + maxRetryCnt_ = value; + maxRetryCntIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::maxRetryCntIsSet() const +{ + return maxRetryCntIsSet_; +} + +void ModifyHarvestTaskResponse::unsetmaxRetryCnt() +{ + maxRetryCntIsSet_ = false; +} + +VodPackageInfo ModifyHarvestTaskResponse::getPackageInfo() const +{ + return packageInfo_; +} + +void ModifyHarvestTaskResponse::setPackageInfo(const VodPackageInfo& value) +{ + packageInfo_ = value; + packageInfoIsSet_ = true; +} + +bool ModifyHarvestTaskResponse::packageInfoIsSet() const +{ + return packageInfoIsSet_; +} + +void ModifyHarvestTaskResponse::unsetpackageInfo() +{ + packageInfoIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/UpdateHarvestJobStatusRequest.cpp b/live/src/v1/model/UpdateHarvestJobStatusRequest.cpp new file mode 100644 index 000000000..e9ec2bee5 --- /dev/null +++ b/live/src/v1/model/UpdateHarvestJobStatusRequest.cpp @@ -0,0 +1,148 @@ + + +#include "huaweicloud/live/v1/model/UpdateHarvestJobStatusRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +UpdateHarvestJobStatusRequest::UpdateHarvestJobStatusRequest() +{ + accessControlAllowInternal_ = ""; + accessControlAllowInternalIsSet_ = false; + accessControlAllowExternal_ = ""; + accessControlAllowExternalIsSet_ = false; + bodyIsSet_ = false; +} + +UpdateHarvestJobStatusRequest::~UpdateHarvestJobStatusRequest() = default; + +void UpdateHarvestJobStatusRequest::validate() +{ +} + +web::json::value UpdateHarvestJobStatusRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(accessControlAllowInternalIsSet_) { + val[utility::conversions::to_string_t("Access-Control-Allow-Internal")] = ModelBase::toJson(accessControlAllowInternal_); + } + if(accessControlAllowExternalIsSet_) { + val[utility::conversions::to_string_t("Access-Control-Allow-External")] = ModelBase::toJson(accessControlAllowExternal_); + } + if(bodyIsSet_) { + val[utility::conversions::to_string_t("body")] = ModelBase::toJson(body_); + } + + return val; +} +bool UpdateHarvestJobStatusRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("Access-Control-Allow-Internal"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("Access-Control-Allow-Internal")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAccessControlAllowInternal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("Access-Control-Allow-External"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("Access-Control-Allow-External")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAccessControlAllowExternal(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("body"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("body")); + if(!fieldValue.is_null()) + { + UpdateHarvestJobStatusRequestBody refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBody(refVal); + } + } + return ok; +} + + +std::string UpdateHarvestJobStatusRequest::getAccessControlAllowInternal() const +{ + return accessControlAllowInternal_; +} + +void UpdateHarvestJobStatusRequest::setAccessControlAllowInternal(const std::string& value) +{ + accessControlAllowInternal_ = value; + accessControlAllowInternalIsSet_ = true; +} + +bool UpdateHarvestJobStatusRequest::accessControlAllowInternalIsSet() const +{ + return accessControlAllowInternalIsSet_; +} + +void UpdateHarvestJobStatusRequest::unsetaccessControlAllowInternal() +{ + accessControlAllowInternalIsSet_ = false; +} + +std::string UpdateHarvestJobStatusRequest::getAccessControlAllowExternal() const +{ + return accessControlAllowExternal_; +} + +void UpdateHarvestJobStatusRequest::setAccessControlAllowExternal(const std::string& value) +{ + accessControlAllowExternal_ = value; + accessControlAllowExternalIsSet_ = true; +} + +bool UpdateHarvestJobStatusRequest::accessControlAllowExternalIsSet() const +{ + return accessControlAllowExternalIsSet_; +} + +void UpdateHarvestJobStatusRequest::unsetaccessControlAllowExternal() +{ + accessControlAllowExternalIsSet_ = false; +} + +UpdateHarvestJobStatusRequestBody UpdateHarvestJobStatusRequest::getBody() const +{ + return body_; +} + +void UpdateHarvestJobStatusRequest::setBody(const UpdateHarvestJobStatusRequestBody& value) +{ + body_ = value; + bodyIsSet_ = true; +} + +bool UpdateHarvestJobStatusRequest::bodyIsSet() const +{ + return bodyIsSet_; +} + +void UpdateHarvestJobStatusRequest::unsetbody() +{ + bodyIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/UpdateHarvestJobStatusRequestBody.cpp b/live/src/v1/model/UpdateHarvestJobStatusRequestBody.cpp new file mode 100644 index 000000000..7d6b93328 --- /dev/null +++ b/live/src/v1/model/UpdateHarvestJobStatusRequestBody.cpp @@ -0,0 +1,114 @@ + + +#include "huaweicloud/live/v1/model/UpdateHarvestJobStatusRequestBody.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +UpdateHarvestJobStatusRequestBody::UpdateHarvestJobStatusRequestBody() +{ + jobId_ = ""; + jobIdIsSet_ = false; + status_ = ""; + statusIsSet_ = false; +} + +UpdateHarvestJobStatusRequestBody::~UpdateHarvestJobStatusRequestBody() = default; + +void UpdateHarvestJobStatusRequestBody::validate() +{ +} + +web::json::value UpdateHarvestJobStatusRequestBody::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(jobIdIsSet_) { + val[utility::conversions::to_string_t("job_id")] = ModelBase::toJson(jobId_); + } + if(statusIsSet_) { + val[utility::conversions::to_string_t("status")] = ModelBase::toJson(status_); + } + + return val; +} +bool UpdateHarvestJobStatusRequestBody::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("job_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("job_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setJobId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("status"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("status")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStatus(refVal); + } + } + return ok; +} + + +std::string UpdateHarvestJobStatusRequestBody::getJobId() const +{ + return jobId_; +} + +void UpdateHarvestJobStatusRequestBody::setJobId(const std::string& value) +{ + jobId_ = value; + jobIdIsSet_ = true; +} + +bool UpdateHarvestJobStatusRequestBody::jobIdIsSet() const +{ + return jobIdIsSet_; +} + +void UpdateHarvestJobStatusRequestBody::unsetjobId() +{ + jobIdIsSet_ = false; +} + +std::string UpdateHarvestJobStatusRequestBody::getStatus() const +{ + return status_; +} + +void UpdateHarvestJobStatusRequestBody::setStatus(const std::string& value) +{ + status_ = value; + statusIsSet_ = true; +} + +bool UpdateHarvestJobStatusRequestBody::statusIsSet() const +{ + return statusIsSet_; +} + +void UpdateHarvestJobStatusRequestBody::unsetstatus() +{ + statusIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/UpdateHarvestJobStatusResponse.cpp b/live/src/v1/model/UpdateHarvestJobStatusResponse.cpp new file mode 100644 index 000000000..2ec9574fb --- /dev/null +++ b/live/src/v1/model/UpdateHarvestJobStatusResponse.cpp @@ -0,0 +1,463 @@ + + +#include "huaweicloud/live/v1/model/UpdateHarvestJobStatusResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +UpdateHarvestJobStatusResponse::UpdateHarvestJobStatusResponse() +{ + jobId_ = ""; + jobIdIsSet_ = false; + domain_ = ""; + domainIsSet_ = false; + appName_ = ""; + appNameIsSet_ = false; + id_ = ""; + idIsSet_ = false; + startTime_ = 0; + startTimeIsSet_ = false; + endTime_ = 0; + endTimeIsSet_ = false; + createTime_ = 0; + createTimeIsSet_ = false; + eventName_ = ""; + eventNameIsSet_ = false; + taskDesc_ = ""; + taskDescIsSet_ = false; + status_ = ""; + statusIsSet_ = false; + maxRetryCnt_ = 0; + maxRetryCntIsSet_ = false; + packageInfoIsSet_ = false; +} + +UpdateHarvestJobStatusResponse::~UpdateHarvestJobStatusResponse() = default; + +void UpdateHarvestJobStatusResponse::validate() +{ +} + +web::json::value UpdateHarvestJobStatusResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(jobIdIsSet_) { + val[utility::conversions::to_string_t("job_id")] = ModelBase::toJson(jobId_); + } + if(domainIsSet_) { + val[utility::conversions::to_string_t("domain")] = ModelBase::toJson(domain_); + } + if(appNameIsSet_) { + val[utility::conversions::to_string_t("app_name")] = ModelBase::toJson(appName_); + } + if(idIsSet_) { + val[utility::conversions::to_string_t("id")] = ModelBase::toJson(id_); + } + if(startTimeIsSet_) { + val[utility::conversions::to_string_t("start_time")] = ModelBase::toJson(startTime_); + } + if(endTimeIsSet_) { + val[utility::conversions::to_string_t("end_time")] = ModelBase::toJson(endTime_); + } + if(createTimeIsSet_) { + val[utility::conversions::to_string_t("create_time")] = ModelBase::toJson(createTime_); + } + if(eventNameIsSet_) { + val[utility::conversions::to_string_t("event_name")] = ModelBase::toJson(eventName_); + } + if(taskDescIsSet_) { + val[utility::conversions::to_string_t("task_desc")] = ModelBase::toJson(taskDesc_); + } + if(statusIsSet_) { + val[utility::conversions::to_string_t("status")] = ModelBase::toJson(status_); + } + if(maxRetryCntIsSet_) { + val[utility::conversions::to_string_t("max_retry_cnt")] = ModelBase::toJson(maxRetryCnt_); + } + if(packageInfoIsSet_) { + val[utility::conversions::to_string_t("package_info")] = ModelBase::toJson(packageInfo_); + } + + return val; +} +bool UpdateHarvestJobStatusResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("job_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("job_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setJobId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("domain"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("domain")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setDomain(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("app_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("app_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAppName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("start_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("start_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStartTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("end_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("end_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEndTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("create_time"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("create_time")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setCreateTime(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("event_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("event_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEventName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("task_desc"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("task_desc")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTaskDesc(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("status"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("status")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStatus(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("max_retry_cnt"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("max_retry_cnt")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setMaxRetryCnt(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("package_info"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("package_info")); + if(!fieldValue.is_null()) + { + VodPackageInfo refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setPackageInfo(refVal); + } + } + return ok; +} + + +std::string UpdateHarvestJobStatusResponse::getJobId() const +{ + return jobId_; +} + +void UpdateHarvestJobStatusResponse::setJobId(const std::string& value) +{ + jobId_ = value; + jobIdIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::jobIdIsSet() const +{ + return jobIdIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsetjobId() +{ + jobIdIsSet_ = false; +} + +std::string UpdateHarvestJobStatusResponse::getDomain() const +{ + return domain_; +} + +void UpdateHarvestJobStatusResponse::setDomain(const std::string& value) +{ + domain_ = value; + domainIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::domainIsSet() const +{ + return domainIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsetdomain() +{ + domainIsSet_ = false; +} + +std::string UpdateHarvestJobStatusResponse::getAppName() const +{ + return appName_; +} + +void UpdateHarvestJobStatusResponse::setAppName(const std::string& value) +{ + appName_ = value; + appNameIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::appNameIsSet() const +{ + return appNameIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsetappName() +{ + appNameIsSet_ = false; +} + +std::string UpdateHarvestJobStatusResponse::getId() const +{ + return id_; +} + +void UpdateHarvestJobStatusResponse::setId(const std::string& value) +{ + id_ = value; + idIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::idIsSet() const +{ + return idIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsetid() +{ + idIsSet_ = false; +} + +int32_t UpdateHarvestJobStatusResponse::getStartTime() const +{ + return startTime_; +} + +void UpdateHarvestJobStatusResponse::setStartTime(int32_t value) +{ + startTime_ = value; + startTimeIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::startTimeIsSet() const +{ + return startTimeIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsetstartTime() +{ + startTimeIsSet_ = false; +} + +int32_t UpdateHarvestJobStatusResponse::getEndTime() const +{ + return endTime_; +} + +void UpdateHarvestJobStatusResponse::setEndTime(int32_t value) +{ + endTime_ = value; + endTimeIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::endTimeIsSet() const +{ + return endTimeIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsetendTime() +{ + endTimeIsSet_ = false; +} + +int32_t UpdateHarvestJobStatusResponse::getCreateTime() const +{ + return createTime_; +} + +void UpdateHarvestJobStatusResponse::setCreateTime(int32_t value) +{ + createTime_ = value; + createTimeIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::createTimeIsSet() const +{ + return createTimeIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsetcreateTime() +{ + createTimeIsSet_ = false; +} + +std::string UpdateHarvestJobStatusResponse::getEventName() const +{ + return eventName_; +} + +void UpdateHarvestJobStatusResponse::setEventName(const std::string& value) +{ + eventName_ = value; + eventNameIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::eventNameIsSet() const +{ + return eventNameIsSet_; +} + +void UpdateHarvestJobStatusResponse::unseteventName() +{ + eventNameIsSet_ = false; +} + +std::string UpdateHarvestJobStatusResponse::getTaskDesc() const +{ + return taskDesc_; +} + +void UpdateHarvestJobStatusResponse::setTaskDesc(const std::string& value) +{ + taskDesc_ = value; + taskDescIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::taskDescIsSet() const +{ + return taskDescIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsettaskDesc() +{ + taskDescIsSet_ = false; +} + +std::string UpdateHarvestJobStatusResponse::getStatus() const +{ + return status_; +} + +void UpdateHarvestJobStatusResponse::setStatus(const std::string& value) +{ + status_ = value; + statusIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::statusIsSet() const +{ + return statusIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsetstatus() +{ + statusIsSet_ = false; +} + +int32_t UpdateHarvestJobStatusResponse::getMaxRetryCnt() const +{ + return maxRetryCnt_; +} + +void UpdateHarvestJobStatusResponse::setMaxRetryCnt(int32_t value) +{ + maxRetryCnt_ = value; + maxRetryCntIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::maxRetryCntIsSet() const +{ + return maxRetryCntIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsetmaxRetryCnt() +{ + maxRetryCntIsSet_ = false; +} + +VodPackageInfo UpdateHarvestJobStatusResponse::getPackageInfo() const +{ + return packageInfo_; +} + +void UpdateHarvestJobStatusResponse::setPackageInfo(const VodPackageInfo& value) +{ + packageInfo_ = value; + packageInfoIsSet_ = true; +} + +bool UpdateHarvestJobStatusResponse::packageInfoIsSet() const +{ + return packageInfoIsSet_; +} + +void UpdateHarvestJobStatusResponse::unsetpackageInfo() +{ + packageInfoIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/live/src/v1/model/VodPackageInfo.cpp b/live/src/v1/model/VodPackageInfo.cpp new file mode 100644 index 000000000..0ef44d5fa --- /dev/null +++ b/live/src/v1/model/VodPackageInfo.cpp @@ -0,0 +1,114 @@ + + +#include "huaweicloud/live/v1/model/VodPackageInfo.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Live { +namespace V1 { +namespace Model { + + + + +VodPackageInfo::VodPackageInfo() +{ + packagingGroupId_ = ""; + packagingGroupIdIsSet_ = false; + resourceId_ = ""; + resourceIdIsSet_ = false; +} + +VodPackageInfo::~VodPackageInfo() = default; + +void VodPackageInfo::validate() +{ +} + +web::json::value VodPackageInfo::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(packagingGroupIdIsSet_) { + val[utility::conversions::to_string_t("packaging_group_id")] = ModelBase::toJson(packagingGroupId_); + } + if(resourceIdIsSet_) { + val[utility::conversions::to_string_t("resource_id")] = ModelBase::toJson(resourceId_); + } + + return val; +} +bool VodPackageInfo::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("packaging_group_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("packaging_group_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setPackagingGroupId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("resource_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("resource_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setResourceId(refVal); + } + } + return ok; +} + + +std::string VodPackageInfo::getPackagingGroupId() const +{ + return packagingGroupId_; +} + +void VodPackageInfo::setPackagingGroupId(const std::string& value) +{ + packagingGroupId_ = value; + packagingGroupIdIsSet_ = true; +} + +bool VodPackageInfo::packagingGroupIdIsSet() const +{ + return packagingGroupIdIsSet_; +} + +void VodPackageInfo::unsetpackagingGroupId() +{ + packagingGroupIdIsSet_ = false; +} + +std::string VodPackageInfo::getResourceId() const +{ + return resourceId_; +} + +void VodPackageInfo::setResourceId(const std::string& value) +{ + resourceId_ = value; + resourceIdIsSet_ = true; +} + +bool VodPackageInfo::resourceIdIsSet() const +{ + return resourceIdIsSet_; +} + +void VodPackageInfo::unsetresourceId() +{ + resourceIdIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/rds/include/huaweicloud/rds/v3/RdsRegion.h b/rds/include/huaweicloud/rds/v3/RdsRegion.h index d4c9baae1..dd4b4caf6 100644 --- a/rds/include/huaweicloud/rds/v3/RdsRegion.h +++ b/rds/include/huaweicloud/rds/v3/RdsRegion.h @@ -46,6 +46,10 @@ class HUAWEICLOUD_RDS_V3_EXPORT RdsRegion { { "https://rds.cn-east-5.myhuaweicloud.com" }); + regions["cn-east-4"] = Region("cn-east-4", + { + "https://rds.cn-east-4.myhuaweicloud.com" + }); regions["cn-south-1"] = Region("cn-south-1", { "https://rds.cn-south-1.myhuaweicloud.com" diff --git a/rds/include/huaweicloud/rds/v3/model/SetAuditlogPolicyResponse.h b/rds/include/huaweicloud/rds/v3/model/SetAuditlogPolicyResponse.h index 59b643cc4..2ed273b9c 100644 --- a/rds/include/huaweicloud/rds/v3/model/SetAuditlogPolicyResponse.h +++ b/rds/include/huaweicloud/rds/v3/model/SetAuditlogPolicyResponse.h @@ -9,6 +9,7 @@ #include #include +#include namespace HuaweiCloud { namespace Sdk { @@ -37,8 +38,19 @@ class HUAWEICLOUD_RDS_V3_EXPORT SetAuditlogPolicyResponse ///////////////////////////////////////////// /// SetAuditlogPolicyResponse members + /// + /// 设置审计日志策略的操作结果。 - COMPLETED：已完成。 + /// + + std::string getStatus() const; + bool statusIsSet() const; + void unsetstatus(); + void setStatus(const std::string& value); + protected: + std::string status_; + bool statusIsSet_; #ifdef RTTR_FLAG RTTR_ENABLE() diff --git a/rds/src/v3/model/SetAuditlogPolicyResponse.cpp b/rds/src/v3/model/SetAuditlogPolicyResponse.cpp index 583726c4d..9c0edbd34 100644 --- a/rds/src/v3/model/SetAuditlogPolicyResponse.cpp +++ b/rds/src/v3/model/SetAuditlogPolicyResponse.cpp @@ -12,6 +12,8 @@ namespace Model { SetAuditlogPolicyResponse::SetAuditlogPolicyResponse() { + status_ = ""; + statusIsSet_ = false; } SetAuditlogPolicyResponse::~SetAuditlogPolicyResponse() = default; @@ -24,6 +26,9 @@ web::json::value SetAuditlogPolicyResponse::toJson() const { web::json::value val = web::json::value::object(); + if(statusIsSet_) { + val[utility::conversions::to_string_t("status")] = ModelBase::toJson(status_); + } return val; } @@ -31,10 +36,40 @@ bool SetAuditlogPolicyResponse::fromJson(const web::json::value& val) { bool ok = true; + if(val.has_field(utility::conversions::to_string_t("status"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("status")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStatus(refVal); + } + } return ok; } +std::string SetAuditlogPolicyResponse::getStatus() const +{ + return status_; +} + +void SetAuditlogPolicyResponse::setStatus(const std::string& value) +{ + status_ = value; + statusIsSet_ = true; +} + +bool SetAuditlogPolicyResponse::statusIsSet() const +{ + return statusIsSet_; +} + +void SetAuditlogPolicyResponse::unsetstatus() +{ + statusIsSet_ = false; +} + } } }