From fce8925bc532da247e8f96c62187659da73d0402 Mon Sep 17 00:00:00 2001 From: Huaweicloud-SDK Date: Thu, 4 Jan 2024 16:23:57 +0800 Subject: [PATCH] release 3.1.68 source code --- CHANGELOG.md | 84 ++++++ CHANGELOG_CN.md | 84 ++++++ VERSION | 2 +- .../huaweicloud/antiddos/v1/AntiDDoSRegion.h | 4 + .../v3/model/MysqlCreateBackupRequest.h | 2 +- .../gaussdb/v3/model/MysqlInstanceRequest.h | 2 +- .../v3/model/MysqlUpdateInstanceNameRequest.h | 2 +- .../v3/model/OpenMysqlProxyRequestBody.h | 2 +- lts/include/huaweicloud/lts/v2/LtsClient.h | 2 +- .../ListStructuredLogsWithTimeRangeResponse.h | 2 +- .../QueryLtsStructLogResponseBodyNew.cpp | 44 ---- mpc/include/huaweicloud/mpc/v1/MpcClient.h | 24 ++ mpc/include/huaweicloud/mpc/v1/MpcMeta.h | 2 + .../v1/model/ShowTenantAccessInfoRequest.h | 71 +++++ .../v1/model/ShowTenantAccessInfoResponse.h | 77 ++++++ .../mpc/v1/model/UpdateTenantAccessInfoReq.h | 74 ++++++ .../v1/model/UpdateTenantAccessInfoRequest.h | 83 ++++++ .../v1/model/UpdateTenantAccessInfoResponse.h | 27 +- mpc/src/v1/MpcClient.cpp | 76 ++++++ mpc/src/v1/MpcMeta.cpp | 24 ++ .../v1/model/ShowTenantAccessInfoRequest.cpp | 79 ++++++ .../v1/model/ShowTenantAccessInfoResponse.cpp | 114 ++++++++ .../v1/model/UpdateTenantAccessInfoReq.cpp | 114 ++++++++ .../model/UpdateTenantAccessInfoRequest.cpp | 113 ++++++++ .../model/UpdateTenantAccessInfoResponse.cpp | 44 ++++ .../model/SetOffSiteBackupPolicyRequestBody.h | 9 +- .../SetOffSiteBackupPolicyRequestBody.cpp | 6 +- smn/include/huaweicloud/smn/v2/SmnClient.h | 64 +++++ smn/include/huaweicloud/smn/v2/SmnMeta.h | 6 + ...dSubscriptionFromSubscriptionUserRequest.h | 83 ++++++ ...scriptionFromSubscriptionUserRequestBody.h | 65 +++++ ...SubscriptionFromSubscriptionUserResponse.h | 68 +++++ ...criptionFromSubscriptionUserResponseItem.h | 108 ++++++++ ...hCreateSubscriptionsFilterPolicesRequest.h | 71 +++++ ...CreateSubscriptionsFilterPolicesResponse.h | 80 ++++++ ...hDeleteSubscriptionsFilterPolicesRequest.h | 71 +++++ ...eteSubscriptionsFilterPolicesRequestBody.h | 65 +++++ ...DeleteSubscriptionsFilterPolicesResponse.h | 80 ++++++ .../huaweicloud/smn/v2/model/BatchResult.h | 86 ++++++ ...tchSubscriptionsFilterPolicesRequestBody.h | 65 +++++ ...riptionsFilterPolicesRequestBody_polices.h | 77 ++++++ ...hUpdateSubscriptionsFilterPolicesRequest.h | 71 +++++ ...UpdateSubscriptionsFilterPolicesResponse.h | 80 ++++++ .../model/GetHttpDetectResponseBody_detail.h | 75 ++++++ .../smn/v2/model/HttpDetectRequestBody.h | 87 ++++++ .../model/HttpDetectRequestBody_extension.h | 66 +++++ .../model/ListSubscriptionsByTopicRequest.h | 11 + .../smn/v2/model/ListSubscriptionsItem.h | 13 + .../smn/v2/model/ListSubscriptionsRequest.h | 11 + .../smn/v2/model/ListTopicsRequest.h | 13 +- .../smn/v2/model/MessageAttribute.h | 87 ++++++ .../smn/v2/model/PublishHttpDetectRequest.h | 83 ++++++ .../smn/v2/model/PublishHttpDetectResponse.h | 78 ++++++ .../smn/v2/model/PublishMessageRequestBody.h | 12 + .../v2/model/ShowHttpDetectResultRequest.h | 82 ++++++ .../v2/model/ShowHttpDetectResultResponse.h | 90 +++++++ .../huaweicloud/smn/v2/model/Statement.h | 4 +- .../smn/v2/model/SubscriptionsFilterPolicy.h | 76 ++++++ smn/src/v2/SmnClient.cpp | 247 ++++++++++++++++++ smn/src/v2/SmnMeta.cpp | 59 +++++ ...ubscriptionFromSubscriptionUserRequest.cpp | 113 ++++++++ ...riptionFromSubscriptionUserRequestBody.cpp | 78 ++++++ ...bscriptionFromSubscriptionUserResponse.cpp | 78 ++++++ ...iptionFromSubscriptionUserResponseItem.cpp | 219 ++++++++++++++++ ...reateSubscriptionsFilterPolicesRequest.cpp | 78 ++++++ ...eateSubscriptionsFilterPolicesResponse.cpp | 113 ++++++++ ...eleteSubscriptionsFilterPolicesRequest.cpp | 78 ++++++ ...eSubscriptionsFilterPolicesRequestBody.cpp | 78 ++++++ ...leteSubscriptionsFilterPolicesResponse.cpp | 113 ++++++++ smn/src/v2/model/BatchResult.cpp | 149 +++++++++++ ...hSubscriptionsFilterPolicesRequestBody.cpp | 78 ++++++ ...ptionsFilterPolicesRequestBody_polices.cpp | 113 ++++++++ ...pdateSubscriptionsFilterPolicesRequest.cpp | 78 ++++++ ...dateSubscriptionsFilterPolicesResponse.cpp | 113 ++++++++ .../GetHttpDetectResponseBody_detail.cpp | 114 ++++++++ smn/src/v2/model/HttpDetectRequestBody.cpp | 148 +++++++++++ .../model/HttpDetectRequestBody_extension.cpp | 78 ++++++ .../model/ListSubscriptionsByTopicRequest.cpp | 35 +++ smn/src/v2/model/ListSubscriptionsItem.cpp | 34 +++ smn/src/v2/model/ListSubscriptionsRequest.cpp | 35 +++ smn/src/v2/model/ListTopicsRequest.cpp | 35 +++ smn/src/v2/model/MessageAttribute.cpp | 148 +++++++++++ smn/src/v2/model/PublishHttpDetectRequest.cpp | 113 ++++++++ .../v2/model/PublishHttpDetectResponse.cpp | 114 ++++++++ .../v2/model/PublishMessageRequestBody.cpp | 34 +++ .../v2/model/ShowHttpDetectResultRequest.cpp | 114 ++++++++ .../v2/model/ShowHttpDetectResultResponse.cpp | 148 +++++++++++ .../v2/model/SubscriptionsFilterPolicy.cpp | 113 ++++++++ vpc/include/huaweicloud/vpc/v2/model/Port.h | 11 + vpc/src/v2/model/Port.cpp | 35 +++ 90 files changed, 6115 insertions(+), 74 deletions(-) delete mode 100644 lts/src/v2/model/QueryLtsStructLogResponseBodyNew.cpp create mode 100644 mpc/include/huaweicloud/mpc/v1/model/ShowTenantAccessInfoRequest.h create mode 100644 mpc/include/huaweicloud/mpc/v1/model/ShowTenantAccessInfoResponse.h create mode 100644 mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoReq.h create mode 100644 mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoRequest.h rename lts/include/huaweicloud/lts/v2/model/QueryLtsStructLogResponseBodyNew.h => mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoResponse.h (51%) create mode 100644 mpc/src/v1/model/ShowTenantAccessInfoRequest.cpp create mode 100644 mpc/src/v1/model/ShowTenantAccessInfoResponse.cpp create mode 100644 mpc/src/v1/model/UpdateTenantAccessInfoReq.cpp create mode 100644 mpc/src/v1/model/UpdateTenantAccessInfoRequest.cpp create mode 100644 mpc/src/v1/model/UpdateTenantAccessInfoResponse.cpp create mode 100644 smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserRequest.h create mode 100644 smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserRequestBody.h create mode 100644 smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserResponse.h create mode 100644 smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserResponseItem.h create mode 100644 smn/include/huaweicloud/smn/v2/model/BatchCreateSubscriptionsFilterPolicesRequest.h create mode 100644 smn/include/huaweicloud/smn/v2/model/BatchCreateSubscriptionsFilterPolicesResponse.h create mode 100644 smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesRequest.h create mode 100644 smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesRequestBody.h create mode 100644 smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesResponse.h create mode 100644 smn/include/huaweicloud/smn/v2/model/BatchResult.h create mode 100644 smn/include/huaweicloud/smn/v2/model/BatchSubscriptionsFilterPolicesRequestBody.h create mode 100644 smn/include/huaweicloud/smn/v2/model/BatchSubscriptionsFilterPolicesRequestBody_polices.h create mode 100644 smn/include/huaweicloud/smn/v2/model/BatchUpdateSubscriptionsFilterPolicesRequest.h create mode 100644 smn/include/huaweicloud/smn/v2/model/BatchUpdateSubscriptionsFilterPolicesResponse.h create mode 100644 smn/include/huaweicloud/smn/v2/model/GetHttpDetectResponseBody_detail.h create mode 100644 smn/include/huaweicloud/smn/v2/model/HttpDetectRequestBody.h create mode 100644 smn/include/huaweicloud/smn/v2/model/HttpDetectRequestBody_extension.h create mode 100644 smn/include/huaweicloud/smn/v2/model/MessageAttribute.h create mode 100644 smn/include/huaweicloud/smn/v2/model/PublishHttpDetectRequest.h create mode 100644 smn/include/huaweicloud/smn/v2/model/PublishHttpDetectResponse.h create mode 100644 smn/include/huaweicloud/smn/v2/model/ShowHttpDetectResultRequest.h create mode 100644 smn/include/huaweicloud/smn/v2/model/ShowHttpDetectResultResponse.h create mode 100644 smn/include/huaweicloud/smn/v2/model/SubscriptionsFilterPolicy.h create mode 100644 smn/src/v2/model/AddSubscriptionFromSubscriptionUserRequest.cpp create mode 100644 smn/src/v2/model/AddSubscriptionFromSubscriptionUserRequestBody.cpp create mode 100644 smn/src/v2/model/AddSubscriptionFromSubscriptionUserResponse.cpp create mode 100644 smn/src/v2/model/AddSubscriptionFromSubscriptionUserResponseItem.cpp create mode 100644 smn/src/v2/model/BatchCreateSubscriptionsFilterPolicesRequest.cpp create mode 100644 smn/src/v2/model/BatchCreateSubscriptionsFilterPolicesResponse.cpp create mode 100644 smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesRequest.cpp create mode 100644 smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesRequestBody.cpp create mode 100644 smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesResponse.cpp create mode 100644 smn/src/v2/model/BatchResult.cpp create mode 100644 smn/src/v2/model/BatchSubscriptionsFilterPolicesRequestBody.cpp create mode 100644 smn/src/v2/model/BatchSubscriptionsFilterPolicesRequestBody_polices.cpp create mode 100644 smn/src/v2/model/BatchUpdateSubscriptionsFilterPolicesRequest.cpp create mode 100644 smn/src/v2/model/BatchUpdateSubscriptionsFilterPolicesResponse.cpp create mode 100644 smn/src/v2/model/GetHttpDetectResponseBody_detail.cpp create mode 100644 smn/src/v2/model/HttpDetectRequestBody.cpp create mode 100644 smn/src/v2/model/HttpDetectRequestBody_extension.cpp create mode 100644 smn/src/v2/model/MessageAttribute.cpp create mode 100644 smn/src/v2/model/PublishHttpDetectRequest.cpp create mode 100644 smn/src/v2/model/PublishHttpDetectResponse.cpp create mode 100644 smn/src/v2/model/ShowHttpDetectResultRequest.cpp create mode 100644 smn/src/v2/model/ShowHttpDetectResultResponse.cpp create mode 100644 smn/src/v2/model/SubscriptionsFilterPolicy.cpp diff --git a/CHANGELOG.md b/CHANGELOG.md index b06b88da3..3963fa275 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,87 @@ +# 3.1.68 2024-01-04 + +### HuaweiCloud SDK MPC + +- _Features_ + - Support the APIs `ShowTenantAccessInfo`, `UpdateTenantAccessInfo` +- _Bug Fix_ + - None +- _Change_ + - None + +### HuaweiCloud SDK RDS + +- _Features_ + - None +- _Bug Fix_ + - None +- _Change_ + - **SetOffSiteBackupPolicy** + - changes of request param + - `* policy_para: list -> object` + +### HuaweiCloud SDK SMN + +- _Features_ + - Support the following APIs: + - `PublishHttpDetect` + - `ShowHttpDetectResult` + - `BatchUpdateSubscriptionsFilterPolices` + - `BatchCreateSubscriptionsFilterPolices` + - `BatchDeleteSubscriptionsFilterPolices` + - `AddSubscriptionFromSubscriptionUser` +- _Bug Fix_ + - None +- _Change_ + - Deprecate the following APIs: + - `ListApplicationAttributes` + - `UpdateApplication` + - `DeleteApplication` + - `ListApplicationEndpointAttributes` + - `UpdateApplicationEndpoint` + - `DeleteApplicationEndpoint` + - `PublishAppMessage` + - `CreateApplication` + - `ListApplications` + - `CreateApplicationEndpoint` + - `ListApplicationEndpoints` + - **PublishMessage** + - changes of request param + - `+ message_attributes` + - **ListTopics** + - changes of request param + - `+ fuzzy_display_name` + - **ListSubscriptions** + - changes of request param + - `+ fuzzy_remark` + - changes of response param + - `+ subscriptions.filter_polices` + - **ListSubscriptionsByTopic** + - changes of request param + - `+ fuzzy_remark` + - changes of response param + - `+ subscriptions.filter_polices` + +### HuaweiCloud SDK VPC + +- _Features_ + - None +- _Bug Fix_ + - None +- _Change_ + - **ListPorts** + - changes of response param + - `+ ports.ipv6_bandwidth_id` + - **CreatePort** + - changes of response param + - `+ port.ipv6_bandwidth_id` + - **ShowPort** + - changes of response param + - `+ port.ipv6_bandwidth_id` + - **UpdatePort** + - changes of response param + - `+ port.ipv6_bandwidth_id` + # 3.1.67 2023-12-27 ### HuaweiCloud SDK AAD diff --git a/CHANGELOG_CN.md b/CHANGELOG_CN.md index 8f68debbd..385a3e68f 100644 --- a/CHANGELOG_CN.md +++ b/CHANGELOG_CN.md @@ -1,3 +1,87 @@ +# 3.1.68 2024-01-04 + +### HuaweiCloud SDK MPC + +- _新增特性_ + - 支持接口`ShowTenantAccessInfo`、`UpdateTenantAccessInfo` +- _解决问题_ + - 无 +- _特性变更_ + - 无 + +### HuaweiCloud SDK RDS + +- _新增特性_ + - 无 +- _解决问题_ + - 无 +- _特性变更_ + - **SetOffSiteBackupPolicy** + - 请求参数变更 + - `* policy_para: list -> object` + +### HuaweiCloud SDK SMN + +- _新增特性_ + - 支持以下接口： + - `PublishHttpDetect` + - `ShowHttpDetectResult` + - `BatchUpdateSubscriptionsFilterPolices` + - `BatchCreateSubscriptionsFilterPolices` + - `BatchDeleteSubscriptionsFilterPolices` + - `AddSubscriptionFromSubscriptionUser` +- _解决问题_ + - 无 +- _特性变更_ + - 废弃以下接口： + - `ListApplicationAttributes` + - `UpdateApplication` + - `DeleteApplication` + - `ListApplicationEndpointAttributes` + - `UpdateApplicationEndpoint` + - `DeleteApplicationEndpoint` + - `PublishAppMessage` + - `CreateApplication` + - `ListApplications` + - `CreateApplicationEndpoint` + - `ListApplicationEndpoints` + - **PublishMessage** + - 请求参数变更 + - `+ message_attributes` + - **ListTopics** + - 请求参数变更 + - `+ fuzzy_display_name` + - **ListSubscriptions** + - 请求参数变更 + - `+ fuzzy_remark` + - 响应参数变更 + - `+ subscriptions.filter_polices` + - **ListSubscriptionsByTopic** + - 请求参数变更 + - `+ fuzzy_remark` + - 响应参数变更 + - `+ subscriptions.filter_polices` + +### HuaweiCloud SDK VPC + +- _新增特性_ + - 无 +- _解决问题_ + - 无 +- _特性变更_ + - **ListPorts** + - 响应参数变更 + - `+ ports.ipv6_bandwidth_id` + - **CreatePort** + - 响应参数变更 + - `+ port.ipv6_bandwidth_id` + - **ShowPort** + - 响应参数变更 + - `+ port.ipv6_bandwidth_id` + - **UpdatePort** + - 响应参数变更 + - `+ port.ipv6_bandwidth_id` + # 3.1.67 2023-12-27 ### HuaweiCloud SDK AAD diff --git a/VERSION b/VERSION index e48116570..87dc130b3 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -3.1.67 +3.1.68 diff --git a/antiddos/include/huaweicloud/antiddos/v1/AntiDDoSRegion.h b/antiddos/include/huaweicloud/antiddos/v1/AntiDDoSRegion.h index 177189b38..20fb9d096 100644 --- a/antiddos/include/huaweicloud/antiddos/v1/AntiDDoSRegion.h +++ b/antiddos/include/huaweicloud/antiddos/v1/AntiDDoSRegion.h @@ -106,6 +106,10 @@ class HUAWEICLOUD_ANTIDDOS_V1_EXPORT AntiDDoSRegion { { "https://antiddos.ae-ad-1.myhuaweicloud.com" }); + regions["eu-west-0"] = Region("eu-west-0", + { + "https://antiddos.eu-west-0.myhuaweicloud.com" + }); return regions; } private: diff --git a/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlCreateBackupRequest.h b/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlCreateBackupRequest.h index 10462124b..7f40b942e 100644 --- a/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlCreateBackupRequest.h +++ b/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlCreateBackupRequest.h @@ -48,7 +48,7 @@ class HUAWEICLOUD_GAUSSDB_V3_EXPORT MysqlCreateBackupRequest void setInstanceId(const std::string& value); /// - /// 备份名称。 取值范围：4~64个字符之间，必须以字母开头，区分大小写，可以包含字母、数字、中划线或者下划线，不能包含其他的特殊字符。 + /// 备份名称。 取值范围：最小为4个字符，最大为64个字符且不超过64个字节（注意：一个中文字符占用3个字节），必须以字母或中文开头，区分大小写，可以包含字母、数字、中划线、下划线或中文，不能包含其他特殊字符。 /// std::string getName() const; diff --git a/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlInstanceRequest.h b/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlInstanceRequest.h index 032066186..452327dee 100644 --- a/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlInstanceRequest.h +++ b/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlInstanceRequest.h @@ -64,7 +64,7 @@ class HUAWEICLOUD_GAUSSDB_V3_EXPORT MysqlInstanceRequest void setRegion(const std::string& value); /// - /// 实例名称。用于表示实例的名称，同一租户下，同类型的实例名可重名。 取值范围：4~64个字符之间，必须以字母开头，区分大小写，可以包含字母、数字、中划线或者下划线，不能包含其他的特殊字符。 + /// 实例名称。用于表示实例的名称，同一租户下，同类型的实例名可重名。 取值范围：最小为4个字符，最大为64个字符且不超过64个字节（注意：一个中文字符占用3个字节），必须以字母或中文开头，区分大小写，可以包含字母、数字、中划线、下划线或中文，不能包含其他特殊字符。 /// std::string getName() const; diff --git a/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlUpdateInstanceNameRequest.h b/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlUpdateInstanceNameRequest.h index 6c30a17bf..745ce81bd 100644 --- a/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlUpdateInstanceNameRequest.h +++ b/gaussdb/include/huaweicloud/gaussdb/v3/model/MysqlUpdateInstanceNameRequest.h @@ -39,7 +39,7 @@ class HUAWEICLOUD_GAUSSDB_V3_EXPORT MysqlUpdateInstanceNameRequest /// MysqlUpdateInstanceNameRequest members /// - /// 实例名称。 用于表示实例的名称，同一租户下，同类型的实例名可重名。取值范围：4~64个字符之间，必须以字母开头，区分大小写，可以包含字母、数字、中划线或者下划线，不能包含其他的特殊字符。 + /// 实例名称。 用于表示实例的名称，同一租户下，同类型的实例名可重名。取值范围：最小为4个字符，最大为64个字符且不超过64个字节（注意：一个中文字符占用3个字节），必须以字母或中文开头，区分大小写，可以包含字母、数字、中划线、下划线或中文，不能包含其他特殊字符。 /// std::string getName() const; diff --git a/gaussdb/include/huaweicloud/gaussdb/v3/model/OpenMysqlProxyRequestBody.h b/gaussdb/include/huaweicloud/gaussdb/v3/model/OpenMysqlProxyRequestBody.h index f615daba0..236482a1e 100644 --- a/gaussdb/include/huaweicloud/gaussdb/v3/model/OpenMysqlProxyRequestBody.h +++ b/gaussdb/include/huaweicloud/gaussdb/v3/model/OpenMysqlProxyRequestBody.h @@ -59,7 +59,7 @@ class HUAWEICLOUD_GAUSSDB_V3_EXPORT OpenMysqlProxyRequestBody void setNodeNum(int32_t value); /// - /// 代理实例名称。用于表示实例的名称，同一租户下，同类型的实例名可重名。 取值范围：4~64个字符之间，必须以字母开头，区分大小写，可以包含字母、数字、中划线或者下划线，不能包含其他的特殊字符。 + /// 代理实例名称。用于表示实例的名称，同一租户下，同类型的实例名可重名。 取值范围：最小为4个字符，最大为64个字符且不超过64个字节（注意：一个中文字符占用3个字节），必须以字母或中文开头，区分大小写，可以包含字母、数字、中划线、下划线或中文，不能包含其他特殊字符。 /// std::string getProxyName() const; diff --git a/lts/include/huaweicloud/lts/v2/LtsClient.h b/lts/include/huaweicloud/lts/v2/LtsClient.h index 352f00a01..5901f8d74 100644 --- a/lts/include/huaweicloud/lts/v2/LtsClient.h +++ b/lts/include/huaweicloud/lts/v2/LtsClient.h @@ -142,13 +142,13 @@ #include #include #include +#include #include #include #include #include #include #include -#include #include #include #include diff --git a/lts/include/huaweicloud/lts/v2/model/ListStructuredLogsWithTimeRangeResponse.h b/lts/include/huaweicloud/lts/v2/model/ListStructuredLogsWithTimeRangeResponse.h index 40c1baf26..1931e6aad 100644 --- a/lts/include/huaweicloud/lts/v2/model/ListStructuredLogsWithTimeRangeResponse.h +++ b/lts/include/huaweicloud/lts/v2/model/ListStructuredLogsWithTimeRangeResponse.h @@ -39,7 +39,7 @@ class HUAWEICLOUD_LTS_V2_EXPORT ListStructuredLogsWithTimeRangeResponse /// ListStructuredLogsWithTimeRangeResponse members /// - /// 此参数在请求实体中，采用json字符串格式。 + /// /// Object getBody() const; diff --git a/lts/src/v2/model/QueryLtsStructLogResponseBodyNew.cpp b/lts/src/v2/model/QueryLtsStructLogResponseBodyNew.cpp deleted file mode 100644 index 63e20b76f..000000000 --- a/lts/src/v2/model/QueryLtsStructLogResponseBodyNew.cpp +++ /dev/null @@ -1,44 +0,0 @@ - - -#include "huaweicloud/lts/v2/model/QueryLtsStructLogResponseBodyNew.h" -namespace HuaweiCloud { -namespace Sdk { -namespace Lts { -namespace V2 { -namespace Model { - - - - -QueryLtsStructLogResponseBodyNew::QueryLtsStructLogResponseBodyNew() -{ -} - -QueryLtsStructLogResponseBodyNew::~QueryLtsStructLogResponseBodyNew() = default; - -void QueryLtsStructLogResponseBodyNew::validate() -{ -} - -web::json::value QueryLtsStructLogResponseBodyNew::toJson() const -{ - web::json::value val = web::json::value::object(); - - - return val; -} -bool QueryLtsStructLogResponseBodyNew::fromJson(const web::json::value& val) -{ - bool ok = true; - - return ok; -} - - -} -} -} -} -} - - diff --git a/mpc/include/huaweicloud/mpc/v1/MpcClient.h b/mpc/include/huaweicloud/mpc/v1/MpcClient.h index 3a5491920..9cc60f83d 100644 --- a/mpc/include/huaweicloud/mpc/v1/MpcClient.h +++ b/mpc/include/huaweicloud/mpc/v1/MpcClient.h @@ -136,6 +136,13 @@ #include #include +#include +#include +#include +#include +#include +#include + #include #include #include @@ -619,6 +626,23 @@ class HUAWEICLOUD_MPC_V1_EXPORT MpcClient : public Client UpdateTemplateGroupRequest &request ); + // 租户查询服务开通状态信息 + // + // 租户查询媒体转码服务开通状态信息。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr showTenantAccessInfo( + ShowTenantAccessInfoRequest &request + ); + // 租户开通媒体转码服务 + // + // 租户开通媒体转码服务。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr updateTenantAccessInfo( + UpdateTenantAccessInfoRequest &request + ); + // 新建截图任务 // // 新建截图任务，视频截图将从首帧开始，按设置的时间间隔截图，最后截取末帧。 diff --git a/mpc/include/huaweicloud/mpc/v1/MpcMeta.h b/mpc/include/huaweicloud/mpc/v1/MpcMeta.h index 3444595e9..a0de29643 100644 --- a/mpc/include/huaweicloud/mpc/v1/MpcMeta.h +++ b/mpc/include/huaweicloud/mpc/v1/MpcMeta.h @@ -58,6 +58,8 @@ class HUAWEICLOUD_MPC_V1_EXPORT MpcMeta { static HttpRequestDef genRequestDefForDeleteTemplateGroup(); static HttpRequestDef genRequestDefForListTemplateGroup(); static HttpRequestDef genRequestDefForUpdateTemplateGroup(); + static HttpRequestDef genRequestDefForShowTenantAccessInfo(); + static HttpRequestDef genRequestDefForUpdateTenantAccessInfo(); static HttpRequestDef genRequestDefForCreateThumbnailsTask(); static HttpRequestDef genRequestDefForDeleteThumbnailsTask(); static HttpRequestDef genRequestDefForListThumbnailsTask(); diff --git a/mpc/include/huaweicloud/mpc/v1/model/ShowTenantAccessInfoRequest.h b/mpc/include/huaweicloud/mpc/v1/model/ShowTenantAccessInfoRequest.h new file mode 100644 index 000000000..6d6958325 --- /dev/null +++ b/mpc/include/huaweicloud/mpc/v1/model/ShowTenantAccessInfoRequest.h @@ -0,0 +1,71 @@ + +#ifndef HUAWEICLOUD_SDK_MPC_V1_MODEL_ShowTenantAccessInfoRequest_H_ +#define HUAWEICLOUD_SDK_MPC_V1_MODEL_ShowTenantAccessInfoRequest_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Mpc { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_MPC_V1_EXPORT ShowTenantAccessInfoRequest + : public ModelBase +{ +public: + ShowTenantAccessInfoRequest(); + virtual ~ShowTenantAccessInfoRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// ShowTenantAccessInfoRequest members + + /// + /// 客户端语言 + /// + + std::string getXLanguage() const; + bool xLanguageIsSet() const; + void unsetxLanguage(); + void setXLanguage(const std::string& value); + + +protected: + std::string xLanguage_; + bool xLanguageIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + ShowTenantAccessInfoRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_MPC_V1_MODEL_ShowTenantAccessInfoRequest_H_ diff --git a/mpc/include/huaweicloud/mpc/v1/model/ShowTenantAccessInfoResponse.h b/mpc/include/huaweicloud/mpc/v1/model/ShowTenantAccessInfoResponse.h new file mode 100644 index 000000000..b144e14ad --- /dev/null +++ b/mpc/include/huaweicloud/mpc/v1/model/ShowTenantAccessInfoResponse.h @@ -0,0 +1,77 @@ + +#ifndef HUAWEICLOUD_SDK_MPC_V1_MODEL_ShowTenantAccessInfoResponse_H_ +#define HUAWEICLOUD_SDK_MPC_V1_MODEL_ShowTenantAccessInfoResponse_H_ + + +#include + +#include +#include +#include + + +namespace HuaweiCloud { +namespace Sdk { +namespace Mpc { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_MPC_V1_EXPORT ShowTenantAccessInfoResponse + : public ModelBase, public HttpResponse +{ +public: + ShowTenantAccessInfoResponse(); + virtual ~ShowTenantAccessInfoResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// ShowTenantAccessInfoResponse members + + /// + /// 是否已开通服务 - false：未开通 - true：已开通 + /// + + bool isIsOpen() const; + bool isOpenIsSet() const; + void unsetisOpen(); + void setIsOpen(bool value); + + /// + /// 服务协议版本 + /// + + int32_t getAgreementVersion() const; + bool agreementVersionIsSet() const; + void unsetagreementVersion(); + void setAgreementVersion(int32_t value); + + +protected: + bool isOpen_; + bool isOpenIsSet_; + int32_t agreementVersion_; + bool agreementVersionIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_MPC_V1_MODEL_ShowTenantAccessInfoResponse_H_ diff --git a/mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoReq.h b/mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoReq.h new file mode 100644 index 000000000..694f37d7a --- /dev/null +++ b/mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoReq.h @@ -0,0 +1,74 @@ + +#ifndef HUAWEICLOUD_SDK_MPC_V1_MODEL_UpdateTenantAccessInfoReq_H_ +#define HUAWEICLOUD_SDK_MPC_V1_MODEL_UpdateTenantAccessInfoReq_H_ + + +#include + +#include +#include +#include + + +namespace HuaweiCloud { +namespace Sdk { +namespace Mpc { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// +/// +class HUAWEICLOUD_MPC_V1_EXPORT UpdateTenantAccessInfoReq + : public ModelBase +{ +public: + UpdateTenantAccessInfoReq(); + virtual ~UpdateTenantAccessInfoReq(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// UpdateTenantAccessInfoReq members + + /// + /// 是否已开通服务 - false：未开通 - true：已开通 + /// + + bool isIsOpen() const; + bool isOpenIsSet() const; + void unsetisOpen(); + void setIsOpen(bool value); + + /// + /// 服务协议版本 + /// + + int32_t getAgreementVersion() const; + bool agreementVersionIsSet() const; + void unsetagreementVersion(); + void setAgreementVersion(int32_t value); + + +protected: + bool isOpen_; + bool isOpenIsSet_; + int32_t agreementVersion_; + bool agreementVersionIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_MPC_V1_MODEL_UpdateTenantAccessInfoReq_H_ diff --git a/mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoRequest.h b/mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoRequest.h new file mode 100644 index 000000000..70bea0eb9 --- /dev/null +++ b/mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoRequest.h @@ -0,0 +1,83 @@ + +#ifndef HUAWEICLOUD_SDK_MPC_V1_MODEL_UpdateTenantAccessInfoRequest_H_ +#define HUAWEICLOUD_SDK_MPC_V1_MODEL_UpdateTenantAccessInfoRequest_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Mpc { +namespace V1 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_MPC_V1_EXPORT UpdateTenantAccessInfoRequest + : public ModelBase +{ +public: + UpdateTenantAccessInfoRequest(); + virtual ~UpdateTenantAccessInfoRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// UpdateTenantAccessInfoRequest members + + /// + /// 客户端语言 + /// + + std::string getXLanguage() const; + bool xLanguageIsSet() const; + void unsetxLanguage(); + void setXLanguage(const std::string& value); + + /// + /// + /// + + UpdateTenantAccessInfoReq getBody() const; + bool bodyIsSet() const; + void unsetbody(); + void setBody(const UpdateTenantAccessInfoReq& value); + + +protected: + std::string xLanguage_; + bool xLanguageIsSet_; + UpdateTenantAccessInfoReq body_; + bool bodyIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + UpdateTenantAccessInfoRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_MPC_V1_MODEL_UpdateTenantAccessInfoRequest_H_ diff --git a/lts/include/huaweicloud/lts/v2/model/QueryLtsStructLogResponseBodyNew.h b/mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoResponse.h similarity index 51% rename from lts/include/huaweicloud/lts/v2/model/QueryLtsStructLogResponseBodyNew.h rename to mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoResponse.h index bfd1fc58b..ea82d6787 100644 --- a/lts/include/huaweicloud/lts/v2/model/QueryLtsStructLogResponseBodyNew.h +++ b/mpc/include/huaweicloud/mpc/v1/model/UpdateTenantAccessInfoResponse.h @@ -1,9 +1,9 @@ -#ifndef HUAWEICLOUD_SDK_LTS_V2_MODEL_QueryLtsStructLogResponseBodyNew_H_ -#define HUAWEICLOUD_SDK_LTS_V2_MODEL_QueryLtsStructLogResponseBodyNew_H_ +#ifndef HUAWEICLOUD_SDK_MPC_V1_MODEL_UpdateTenantAccessInfoResponse_H_ +#define HUAWEICLOUD_SDK_MPC_V1_MODEL_UpdateTenantAccessInfoResponse_H_ -#include +#include #include #include @@ -12,21 +12,21 @@ namespace HuaweiCloud { namespace Sdk { -namespace Lts { -namespace V2 { +namespace Mpc { +namespace V1 { namespace Model { using namespace HuaweiCloud::Sdk::Core::Utils; using namespace HuaweiCloud::Sdk::Core::Http; /// -/// 此参数在请求实体中，采用json字符串格式。 +/// Response Object /// -class HUAWEICLOUD_LTS_V2_EXPORT QueryLtsStructLogResponseBodyNew - : public ModelBase +class HUAWEICLOUD_MPC_V1_EXPORT UpdateTenantAccessInfoResponse + : public ModelBase, public HttpResponse { public: - QueryLtsStructLogResponseBodyNew(); - virtual ~QueryLtsStructLogResponseBodyNew(); + UpdateTenantAccessInfoResponse(); + virtual ~UpdateTenantAccessInfoResponse(); ///////////////////////////////////////////// /// ModelBase overrides @@ -35,11 +35,14 @@ class HUAWEICLOUD_LTS_V2_EXPORT QueryLtsStructLogResponseBodyNew web::json::value toJson() const override; bool fromJson(const web::json::value& json) override; ///////////////////////////////////////////// - /// QueryLtsStructLogResponseBodyNew members + /// UpdateTenantAccessInfoResponse members protected: +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif }; @@ -49,4 +52,4 @@ class HUAWEICLOUD_LTS_V2_EXPORT QueryLtsStructLogResponseBodyNew } } -#endif // HUAWEICLOUD_SDK_LTS_V2_MODEL_QueryLtsStructLogResponseBodyNew_H_ +#endif // HUAWEICLOUD_SDK_MPC_V1_MODEL_UpdateTenantAccessInfoResponse_H_ diff --git a/mpc/src/v1/MpcClient.cpp b/mpc/src/v1/MpcClient.cpp index ba118edf8..fdf7e6634 100644 --- a/mpc/src/v1/MpcClient.cpp +++ b/mpc/src/v1/MpcClient.cpp @@ -1769,6 +1769,82 @@ std::shared_ptr MpcClient::updateTemplateGroup(Upda return localVarResult; } +std::shared_ptr MpcClient::showTenantAccessInfo(ShowTenantAccessInfoRequest &request) +{ + std::string localVarPath = "/v1/{project_id}/tenant/access"; + + 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.xLanguageIsSet()) { + localVarHeaderParams["x-language"] = parameterToString(request.getXLanguage()); + } + + std::string localVarHttpBody; + + std::unique_ptr res = callApi("GET", localVarPath, localVarPathParams, localVarQueryParams, + localVarHeaderParams, localVarHttpBody, MpcMeta::genRequestDefForShowTenantAccessInfo()); + + std::shared_ptr localVarResult = std::make_shared(); + localVarResult->setStatusCode(res->getStatusCode()); + localVarResult->setHeaderParams(res->getHeaderParams()); + localVarResult->setHttpBody(res->getHttpBody()); + + return localVarResult; +} +std::shared_ptr MpcClient::updateTenantAccessInfo(UpdateTenantAccessInfoRequest &request) +{ + std::string localVarPath = "/v1/{project_id}/tenant/access"; + + 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.xLanguageIsSet()) { + localVarHeaderParams["x-language"] = parameterToString(request.getXLanguage()); + } + + 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, MpcMeta::genRequestDefForUpdateTenantAccessInfo()); + + 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 MpcClient::createThumbnailsTask(CreateThumbnailsTaskRequest &request) { std::string localVarPath = "/v1/{project_id}/thumbnails"; diff --git a/mpc/src/v1/MpcMeta.cpp b/mpc/src/v1/MpcMeta.cpp index 537c86d1b..dff676a9b 100644 --- a/mpc/src/v1/MpcMeta.cpp +++ b/mpc/src/v1/MpcMeta.cpp @@ -527,6 +527,30 @@ HttpRequestDef MpcMeta::genRequestDefForUpdateTemplateGroup() { return reqDefBuilder; } +HttpRequestDef MpcMeta::genRequestDefForShowTenantAccessInfo() { + HttpRequestDef reqDefBuilder; + FieldDef headerParamXLanguage; + reqDefBuilder.withRequestField(headerParamXLanguage + .withName("XLanguage") + .withJsonTag("x-language") + .withLocationType(Header_)); + return reqDefBuilder; +} + +HttpRequestDef MpcMeta::genRequestDefForUpdateTenantAccessInfo() { + HttpRequestDef reqDefBuilder; + FieldDef headerParamXLanguage; + reqDefBuilder.withRequestField(headerParamXLanguage + .withName("XLanguage") + .withJsonTag("x-language") + .withLocationType(Header_)); + FieldDef bodyParam; + reqDefBuilder.withRequestField(bodyParam. + withName("Body"). + withLocationType(Body_)); + return reqDefBuilder; +} + HttpRequestDef MpcMeta::genRequestDefForCreateThumbnailsTask() { HttpRequestDef reqDefBuilder; FieldDef bodyParam; diff --git a/mpc/src/v1/model/ShowTenantAccessInfoRequest.cpp b/mpc/src/v1/model/ShowTenantAccessInfoRequest.cpp new file mode 100644 index 000000000..0dc2b1ebc --- /dev/null +++ b/mpc/src/v1/model/ShowTenantAccessInfoRequest.cpp @@ -0,0 +1,79 @@ + + +#include "huaweicloud/mpc/v1/model/ShowTenantAccessInfoRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Mpc { +namespace V1 { +namespace Model { + + + + +ShowTenantAccessInfoRequest::ShowTenantAccessInfoRequest() +{ + xLanguage_ = ""; + xLanguageIsSet_ = false; +} + +ShowTenantAccessInfoRequest::~ShowTenantAccessInfoRequest() = default; + +void ShowTenantAccessInfoRequest::validate() +{ +} + +web::json::value ShowTenantAccessInfoRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(xLanguageIsSet_) { + val[utility::conversions::to_string_t("x-language")] = ModelBase::toJson(xLanguage_); + } + + return val; +} +bool ShowTenantAccessInfoRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("x-language"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("x-language")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setXLanguage(refVal); + } + } + return ok; +} + + +std::string ShowTenantAccessInfoRequest::getXLanguage() const +{ + return xLanguage_; +} + +void ShowTenantAccessInfoRequest::setXLanguage(const std::string& value) +{ + xLanguage_ = value; + xLanguageIsSet_ = true; +} + +bool ShowTenantAccessInfoRequest::xLanguageIsSet() const +{ + return xLanguageIsSet_; +} + +void ShowTenantAccessInfoRequest::unsetxLanguage() +{ + xLanguageIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/mpc/src/v1/model/ShowTenantAccessInfoResponse.cpp b/mpc/src/v1/model/ShowTenantAccessInfoResponse.cpp new file mode 100644 index 000000000..e4d4f44eb --- /dev/null +++ b/mpc/src/v1/model/ShowTenantAccessInfoResponse.cpp @@ -0,0 +1,114 @@ + + +#include "huaweicloud/mpc/v1/model/ShowTenantAccessInfoResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Mpc { +namespace V1 { +namespace Model { + + + + +ShowTenantAccessInfoResponse::ShowTenantAccessInfoResponse() +{ + isOpen_ = false; + isOpenIsSet_ = false; + agreementVersion_ = 0; + agreementVersionIsSet_ = false; +} + +ShowTenantAccessInfoResponse::~ShowTenantAccessInfoResponse() = default; + +void ShowTenantAccessInfoResponse::validate() +{ +} + +web::json::value ShowTenantAccessInfoResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(isOpenIsSet_) { + val[utility::conversions::to_string_t("is_open")] = ModelBase::toJson(isOpen_); + } + if(agreementVersionIsSet_) { + val[utility::conversions::to_string_t("agreement_version")] = ModelBase::toJson(agreementVersion_); + } + + return val; +} +bool ShowTenantAccessInfoResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("is_open"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("is_open")); + if(!fieldValue.is_null()) + { + bool refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setIsOpen(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("agreement_version"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("agreement_version")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAgreementVersion(refVal); + } + } + return ok; +} + + +bool ShowTenantAccessInfoResponse::isIsOpen() const +{ + return isOpen_; +} + +void ShowTenantAccessInfoResponse::setIsOpen(bool value) +{ + isOpen_ = value; + isOpenIsSet_ = true; +} + +bool ShowTenantAccessInfoResponse::isOpenIsSet() const +{ + return isOpenIsSet_; +} + +void ShowTenantAccessInfoResponse::unsetisOpen() +{ + isOpenIsSet_ = false; +} + +int32_t ShowTenantAccessInfoResponse::getAgreementVersion() const +{ + return agreementVersion_; +} + +void ShowTenantAccessInfoResponse::setAgreementVersion(int32_t value) +{ + agreementVersion_ = value; + agreementVersionIsSet_ = true; +} + +bool ShowTenantAccessInfoResponse::agreementVersionIsSet() const +{ + return agreementVersionIsSet_; +} + +void ShowTenantAccessInfoResponse::unsetagreementVersion() +{ + agreementVersionIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/mpc/src/v1/model/UpdateTenantAccessInfoReq.cpp b/mpc/src/v1/model/UpdateTenantAccessInfoReq.cpp new file mode 100644 index 000000000..44edae629 --- /dev/null +++ b/mpc/src/v1/model/UpdateTenantAccessInfoReq.cpp @@ -0,0 +1,114 @@ + + +#include "huaweicloud/mpc/v1/model/UpdateTenantAccessInfoReq.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Mpc { +namespace V1 { +namespace Model { + + + + +UpdateTenantAccessInfoReq::UpdateTenantAccessInfoReq() +{ + isOpen_ = false; + isOpenIsSet_ = false; + agreementVersion_ = 0; + agreementVersionIsSet_ = false; +} + +UpdateTenantAccessInfoReq::~UpdateTenantAccessInfoReq() = default; + +void UpdateTenantAccessInfoReq::validate() +{ +} + +web::json::value UpdateTenantAccessInfoReq::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(isOpenIsSet_) { + val[utility::conversions::to_string_t("is_open")] = ModelBase::toJson(isOpen_); + } + if(agreementVersionIsSet_) { + val[utility::conversions::to_string_t("agreement_version")] = ModelBase::toJson(agreementVersion_); + } + + return val; +} +bool UpdateTenantAccessInfoReq::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("is_open"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("is_open")); + if(!fieldValue.is_null()) + { + bool refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setIsOpen(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("agreement_version"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("agreement_version")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setAgreementVersion(refVal); + } + } + return ok; +} + + +bool UpdateTenantAccessInfoReq::isIsOpen() const +{ + return isOpen_; +} + +void UpdateTenantAccessInfoReq::setIsOpen(bool value) +{ + isOpen_ = value; + isOpenIsSet_ = true; +} + +bool UpdateTenantAccessInfoReq::isOpenIsSet() const +{ + return isOpenIsSet_; +} + +void UpdateTenantAccessInfoReq::unsetisOpen() +{ + isOpenIsSet_ = false; +} + +int32_t UpdateTenantAccessInfoReq::getAgreementVersion() const +{ + return agreementVersion_; +} + +void UpdateTenantAccessInfoReq::setAgreementVersion(int32_t value) +{ + agreementVersion_ = value; + agreementVersionIsSet_ = true; +} + +bool UpdateTenantAccessInfoReq::agreementVersionIsSet() const +{ + return agreementVersionIsSet_; +} + +void UpdateTenantAccessInfoReq::unsetagreementVersion() +{ + agreementVersionIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/mpc/src/v1/model/UpdateTenantAccessInfoRequest.cpp b/mpc/src/v1/model/UpdateTenantAccessInfoRequest.cpp new file mode 100644 index 000000000..b198ebb66 --- /dev/null +++ b/mpc/src/v1/model/UpdateTenantAccessInfoRequest.cpp @@ -0,0 +1,113 @@ + + +#include "huaweicloud/mpc/v1/model/UpdateTenantAccessInfoRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Mpc { +namespace V1 { +namespace Model { + + + + +UpdateTenantAccessInfoRequest::UpdateTenantAccessInfoRequest() +{ + xLanguage_ = ""; + xLanguageIsSet_ = false; + bodyIsSet_ = false; +} + +UpdateTenantAccessInfoRequest::~UpdateTenantAccessInfoRequest() = default; + +void UpdateTenantAccessInfoRequest::validate() +{ +} + +web::json::value UpdateTenantAccessInfoRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(xLanguageIsSet_) { + val[utility::conversions::to_string_t("x-language")] = ModelBase::toJson(xLanguage_); + } + if(bodyIsSet_) { + val[utility::conversions::to_string_t("body")] = ModelBase::toJson(body_); + } + + return val; +} +bool UpdateTenantAccessInfoRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("x-language"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("x-language")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setXLanguage(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()) + { + UpdateTenantAccessInfoReq refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBody(refVal); + } + } + return ok; +} + + +std::string UpdateTenantAccessInfoRequest::getXLanguage() const +{ + return xLanguage_; +} + +void UpdateTenantAccessInfoRequest::setXLanguage(const std::string& value) +{ + xLanguage_ = value; + xLanguageIsSet_ = true; +} + +bool UpdateTenantAccessInfoRequest::xLanguageIsSet() const +{ + return xLanguageIsSet_; +} + +void UpdateTenantAccessInfoRequest::unsetxLanguage() +{ + xLanguageIsSet_ = false; +} + +UpdateTenantAccessInfoReq UpdateTenantAccessInfoRequest::getBody() const +{ + return body_; +} + +void UpdateTenantAccessInfoRequest::setBody(const UpdateTenantAccessInfoReq& value) +{ + body_ = value; + bodyIsSet_ = true; +} + +bool UpdateTenantAccessInfoRequest::bodyIsSet() const +{ + return bodyIsSet_; +} + +void UpdateTenantAccessInfoRequest::unsetbody() +{ + bodyIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/mpc/src/v1/model/UpdateTenantAccessInfoResponse.cpp b/mpc/src/v1/model/UpdateTenantAccessInfoResponse.cpp new file mode 100644 index 000000000..3120ac23e --- /dev/null +++ b/mpc/src/v1/model/UpdateTenantAccessInfoResponse.cpp @@ -0,0 +1,44 @@ + + +#include "huaweicloud/mpc/v1/model/UpdateTenantAccessInfoResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Mpc { +namespace V1 { +namespace Model { + + + + +UpdateTenantAccessInfoResponse::UpdateTenantAccessInfoResponse() +{ +} + +UpdateTenantAccessInfoResponse::~UpdateTenantAccessInfoResponse() = default; + +void UpdateTenantAccessInfoResponse::validate() +{ +} + +web::json::value UpdateTenantAccessInfoResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + + return val; +} +bool UpdateTenantAccessInfoResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + return ok; +} + + +} +} +} +} +} + + diff --git a/rds/include/huaweicloud/rds/v3/model/SetOffSiteBackupPolicyRequestBody.h b/rds/include/huaweicloud/rds/v3/model/SetOffSiteBackupPolicyRequestBody.h index dc06a5a15..508609e36 100644 --- a/rds/include/huaweicloud/rds/v3/model/SetOffSiteBackupPolicyRequestBody.h +++ b/rds/include/huaweicloud/rds/v3/model/SetOffSiteBackupPolicyRequestBody.h @@ -10,7 +10,6 @@ #include #include -#include namespace HuaweiCloud { namespace Sdk { @@ -40,17 +39,17 @@ class HUAWEICLOUD_RDS_V3_EXPORT SetOffSiteBackupPolicyRequestBody /// SetOffSiteBackupPolicyRequestBody members /// - /// 备份策略对象，包括备份类型、备份保留天数、目标区域ID和目标project ID。 + /// /// - std::vector& getPolicyPara(); + OffSiteBackupPolicy getPolicyPara() const; bool policyParaIsSet() const; void unsetpolicyPara(); - void setPolicyPara(const std::vector& value); + void setPolicyPara(const OffSiteBackupPolicy& value); protected: - std::vector policyPara_; + OffSiteBackupPolicy policyPara_; bool policyParaIsSet_; }; diff --git a/rds/src/v3/model/SetOffSiteBackupPolicyRequestBody.cpp b/rds/src/v3/model/SetOffSiteBackupPolicyRequestBody.cpp index ee925095a..836a9490a 100644 --- a/rds/src/v3/model/SetOffSiteBackupPolicyRequestBody.cpp +++ b/rds/src/v3/model/SetOffSiteBackupPolicyRequestBody.cpp @@ -39,7 +39,7 @@ bool SetOffSiteBackupPolicyRequestBody::fromJson(const web::json::value& val) const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("policy_para")); if(!fieldValue.is_null()) { - std::vector refVal; + OffSiteBackupPolicy refVal; ok &= ModelBase::fromJson(fieldValue, refVal); setPolicyPara(refVal); } @@ -48,12 +48,12 @@ bool SetOffSiteBackupPolicyRequestBody::fromJson(const web::json::value& val) } -std::vector& SetOffSiteBackupPolicyRequestBody::getPolicyPara() +OffSiteBackupPolicy SetOffSiteBackupPolicyRequestBody::getPolicyPara() const { return policyPara_; } -void SetOffSiteBackupPolicyRequestBody::setPolicyPara(const std::vector& value) +void SetOffSiteBackupPolicyRequestBody::setPolicyPara(const OffSiteBackupPolicy& value) { policyPara_ = value; policyParaIsSet_ = true; diff --git a/smn/include/huaweicloud/smn/v2/SmnClient.h b/smn/include/huaweicloud/smn/v2/SmnClient.h index 97c30eab8..eacfbbda5 100644 --- a/smn/include/huaweicloud/smn/v2/SmnClient.h +++ b/smn/include/huaweicloud/smn/v2/SmnClient.h @@ -6,12 +6,23 @@ #include +#include +#include +#include #include #include #include #include #include #include +#include +#include +#include +#include +#include +#include +#include +#include #include #include #include @@ -38,6 +49,7 @@ #include #include #include +#include #include #include #include @@ -65,9 +77,13 @@ #include #include #include +#include +#include #include #include #include +#include +#include #include #include #include @@ -148,6 +164,14 @@ class HUAWEICLOUD_SMN_V2_EXPORT SmnClient : public Client std::shared_ptr addSubscription( AddSubscriptionRequest &request ); + // 导入订阅 + // + // 为指定的Topic添加订阅者，订阅者信息来源为订阅用户列表。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr addSubscriptionFromSubscriptionUser( + AddSubscriptionFromSubscriptionUserRequest &request + ); // 批量添加删除资源标签 // // 为指定实例批量添加或删除标签。一个资源上最多有10个标签。 @@ -159,6 +183,30 @@ class HUAWEICLOUD_SMN_V2_EXPORT SmnClient : public Client std::shared_ptr batchCreateOrDeleteResourceTags( BatchCreateOrDeleteResourceTagsRequest &request ); + // 批量创建订阅过滤策略 + // + // 创建订阅者的消息过滤策略。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr batchCreateSubscriptionsFilterPolices( + BatchCreateSubscriptionsFilterPolicesRequest &request + ); + // 批量删除订阅过滤策略 + // + // 删除订阅者的消息过滤策略。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr batchDeleteSubscriptionsFilterPolices( + BatchDeleteSubscriptionsFilterPolicesRequest &request + ); + // 批量更新订阅过滤策略 + // + // 更新订阅者的消息过滤策略。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr batchUpdateSubscriptionsFilterPolices( + BatchUpdateSubscriptionsFilterPolicesRequest &request + ); // 取消订阅 // // 删除指定的订阅者。 @@ -353,6 +401,14 @@ class HUAWEICLOUD_SMN_V2_EXPORT SmnClient : public Client std::shared_ptr listVersions( ListVersionsRequest &request ); + // 发布探测消息 + // + // 基于主题发送http/https探测消息，探测当前http/https 终端是否可用，SMN出口是否能够正常访问该终端。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr publishHttpDetect( + PublishHttpDetectRequest &request + ); // 消息发布 // // 将消息发送给Topic的所有订阅端点。当返回消息ID时，该消息已被保存并开始尝试将其推送给Topic的订阅者。三种消息发送方式 @@ -370,6 +426,14 @@ class HUAWEICLOUD_SMN_V2_EXPORT SmnClient : public Client std::shared_ptr publishMessage( PublishMessageRequest &request ); + // 获取http探测结果 + // + // 根据http探测发送返回的task_id查询探测结果。 + // + // Please refer to HUAWEI cloud API Explorer for details. + std::shared_ptr showHttpDetectResult( + ShowHttpDetectResultRequest &request + ); // 更新云日志 // // 更新指定Topic绑定的云日志。 diff --git a/smn/include/huaweicloud/smn/v2/SmnMeta.h b/smn/include/huaweicloud/smn/v2/SmnMeta.h index 833565559..c9d3cedfb 100644 --- a/smn/include/huaweicloud/smn/v2/SmnMeta.h +++ b/smn/include/huaweicloud/smn/v2/SmnMeta.h @@ -14,7 +14,11 @@ using namespace HuaweiCloud::Sdk::Core::Http; class HUAWEICLOUD_SMN_V2_EXPORT SmnMeta { public: static HttpRequestDef genRequestDefForAddSubscription(); + static HttpRequestDef genRequestDefForAddSubscriptionFromSubscriptionUser(); static HttpRequestDef genRequestDefForBatchCreateOrDeleteResourceTags(); + static HttpRequestDef genRequestDefForBatchCreateSubscriptionsFilterPolices(); + static HttpRequestDef genRequestDefForBatchDeleteSubscriptionsFilterPolices(); + static HttpRequestDef genRequestDefForBatchUpdateSubscriptionsFilterPolices(); static HttpRequestDef genRequestDefForCancelSubscription(); static HttpRequestDef genRequestDefForCreateLogtank(); static HttpRequestDef genRequestDefForCreateMessageTemplate(); @@ -39,7 +43,9 @@ class HUAWEICLOUD_SMN_V2_EXPORT SmnMeta { static HttpRequestDef genRequestDefForListTopics(); static HttpRequestDef genRequestDefForListVersion(); static HttpRequestDef genRequestDefForListVersions(); + static HttpRequestDef genRequestDefForPublishHttpDetect(); static HttpRequestDef genRequestDefForPublishMessage(); + static HttpRequestDef genRequestDefForShowHttpDetectResult(); static HttpRequestDef genRequestDefForUpdateLogtank(); static HttpRequestDef genRequestDefForUpdateMessageTemplate(); static HttpRequestDef genRequestDefForUpdateSubscription(); diff --git a/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserRequest.h b/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserRequest.h new file mode 100644 index 000000000..9710c6ad3 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserRequest.h @@ -0,0 +1,83 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserRequest_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserRequest_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT AddSubscriptionFromSubscriptionUserRequest + : public ModelBase +{ +public: + AddSubscriptionFromSubscriptionUserRequest(); + virtual ~AddSubscriptionFromSubscriptionUserRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// AddSubscriptionFromSubscriptionUserRequest members + + /// + /// Topic的唯一的资源标识，可通过[查询主题列表](smn_api_51004.xml)获取该标识。 + /// + + std::string getTopicUrn() const; + bool topicUrnIsSet() const; + void unsettopicUrn(); + void setTopicUrn(const std::string& value); + + /// + /// + /// + + AddSubscriptionFromSubscriptionUserRequestBody getBody() const; + bool bodyIsSet() const; + void unsetbody(); + void setBody(const AddSubscriptionFromSubscriptionUserRequestBody& value); + + +protected: + std::string topicUrn_; + bool topicUrnIsSet_; + AddSubscriptionFromSubscriptionUserRequestBody body_; + bool bodyIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + AddSubscriptionFromSubscriptionUserRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserRequest_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserRequestBody.h b/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserRequestBody.h new file mode 100644 index 000000000..7b856b12f --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserRequestBody.h @@ -0,0 +1,65 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserRequestBody_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserRequestBody_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// +/// +class HUAWEICLOUD_SMN_V2_EXPORT AddSubscriptionFromSubscriptionUserRequestBody + : public ModelBase +{ +public: + AddSubscriptionFromSubscriptionUserRequestBody(); + virtual ~AddSubscriptionFromSubscriptionUserRequestBody(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// AddSubscriptionFromSubscriptionUserRequestBody members + + /// + /// 订阅用户ID列表。 + /// + + std::vector& getIds(); + bool idsIsSet() const; + void unsetids(); + void setIds(const std::vector& value); + + +protected: + std::vector ids_; + bool idsIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserRequestBody_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserResponse.h b/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserResponse.h new file mode 100644 index 000000000..7a1efa19a --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserResponse.h @@ -0,0 +1,68 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserResponse_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserResponse_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT AddSubscriptionFromSubscriptionUserResponse + : public ModelBase, public HttpResponse +{ +public: + AddSubscriptionFromSubscriptionUserResponse(); + virtual ~AddSubscriptionFromSubscriptionUserResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// AddSubscriptionFromSubscriptionUserResponse members + + /// + /// 添加订阅返回结果。 + /// + + std::vector& getSubscriptionsResult(); + bool subscriptionsResultIsSet() const; + void unsetsubscriptionsResult(); + void setSubscriptionsResult(const std::vector& value); + + +protected: + std::vector subscriptionsResult_; + bool subscriptionsResultIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserResponse_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserResponseItem.h b/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserResponseItem.h new file mode 100644 index 000000000..8c5f8040a --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserResponseItem.h @@ -0,0 +1,108 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserResponseItem_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserResponseItem_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// +/// +class HUAWEICLOUD_SMN_V2_EXPORT AddSubscriptionFromSubscriptionUserResponseItem + : public ModelBase +{ +public: + AddSubscriptionFromSubscriptionUserResponseItem(); + virtual ~AddSubscriptionFromSubscriptionUserResponseItem(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// AddSubscriptionFromSubscriptionUserResponseItem members + + /// + /// 返回码。 + /// + + int32_t getHttpCode() const; + bool httpCodeIsSet() const; + void unsethttpCode(); + void setHttpCode(int32_t value); + + /// + /// 请求的唯一标识ID。 + /// + + std::string getRequestId() const; + bool requestIdIsSet() const; + void unsetrequestId(); + void setRequestId(const std::string& value); + + /// + /// 订阅者的唯一资源标识。 + /// + + std::string getSubscriptionUrn() const; + bool subscriptionUrnIsSet() const; + void unsetsubscriptionUrn(); + void setSubscriptionUrn(const std::string& value); + + /// + /// 返回信息对应的代码。 + /// + + std::string getErrorCode() const; + bool errorCodeIsSet() const; + void unseterrorCode(); + void setErrorCode(const std::string& value); + + /// + /// 服务异常错误信息描述。 + /// + + std::string getErrorMsg() const; + bool errorMsgIsSet() const; + void unseterrorMsg(); + void setErrorMsg(const std::string& value); + + +protected: + int32_t httpCode_; + bool httpCodeIsSet_; + std::string requestId_; + bool requestIdIsSet_; + std::string subscriptionUrn_; + bool subscriptionUrnIsSet_; + std::string errorCode_; + bool errorCodeIsSet_; + std::string errorMsg_; + bool errorMsgIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_AddSubscriptionFromSubscriptionUserResponseItem_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/BatchCreateSubscriptionsFilterPolicesRequest.h b/smn/include/huaweicloud/smn/v2/model/BatchCreateSubscriptionsFilterPolicesRequest.h new file mode 100644 index 000000000..3a5808f21 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/BatchCreateSubscriptionsFilterPolicesRequest.h @@ -0,0 +1,71 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchCreateSubscriptionsFilterPolicesRequest_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchCreateSubscriptionsFilterPolicesRequest_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT BatchCreateSubscriptionsFilterPolicesRequest + : public ModelBase +{ +public: + BatchCreateSubscriptionsFilterPolicesRequest(); + virtual ~BatchCreateSubscriptionsFilterPolicesRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// BatchCreateSubscriptionsFilterPolicesRequest members + + /// + /// + /// + + BatchSubscriptionsFilterPolicesRequestBody getBody() const; + bool bodyIsSet() const; + void unsetbody(); + void setBody(const BatchSubscriptionsFilterPolicesRequestBody& value); + + +protected: + BatchSubscriptionsFilterPolicesRequestBody body_; + bool bodyIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + BatchCreateSubscriptionsFilterPolicesRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchCreateSubscriptionsFilterPolicesRequest_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/BatchCreateSubscriptionsFilterPolicesResponse.h b/smn/include/huaweicloud/smn/v2/model/BatchCreateSubscriptionsFilterPolicesResponse.h new file mode 100644 index 000000000..2bf1101a0 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/BatchCreateSubscriptionsFilterPolicesResponse.h @@ -0,0 +1,80 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchCreateSubscriptionsFilterPolicesResponse_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchCreateSubscriptionsFilterPolicesResponse_H_ + + +#include + +#include +#include +#include + +#include +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT BatchCreateSubscriptionsFilterPolicesResponse + : public ModelBase, public HttpResponse +{ +public: + BatchCreateSubscriptionsFilterPolicesResponse(); + virtual ~BatchCreateSubscriptionsFilterPolicesResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// BatchCreateSubscriptionsFilterPolicesResponse members + + /// + /// 请求的唯一标识ID。 + /// + + std::string getRequestId() const; + bool requestIdIsSet() const; + void unsetrequestId(); + void setRequestId(const std::string& value); + + /// + /// 批量结果 + /// + + std::vector& getBatchResult(); + bool batchResultIsSet() const; + void unsetbatchResult(); + void setBatchResult(const std::vector& value); + + +protected: + std::string requestId_; + bool requestIdIsSet_; + std::vector batchResult_; + bool batchResultIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchCreateSubscriptionsFilterPolicesResponse_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesRequest.h b/smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesRequest.h new file mode 100644 index 000000000..7b549faac --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesRequest.h @@ -0,0 +1,71 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchDeleteSubscriptionsFilterPolicesRequest_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchDeleteSubscriptionsFilterPolicesRequest_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT BatchDeleteSubscriptionsFilterPolicesRequest + : public ModelBase +{ +public: + BatchDeleteSubscriptionsFilterPolicesRequest(); + virtual ~BatchDeleteSubscriptionsFilterPolicesRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// BatchDeleteSubscriptionsFilterPolicesRequest members + + /// + /// + /// + + BatchDeleteSubscriptionsFilterPolicesRequestBody getBody() const; + bool bodyIsSet() const; + void unsetbody(); + void setBody(const BatchDeleteSubscriptionsFilterPolicesRequestBody& value); + + +protected: + BatchDeleteSubscriptionsFilterPolicesRequestBody body_; + bool bodyIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + BatchDeleteSubscriptionsFilterPolicesRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchDeleteSubscriptionsFilterPolicesRequest_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesRequestBody.h b/smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesRequestBody.h new file mode 100644 index 000000000..0009a0ea8 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesRequestBody.h @@ -0,0 +1,65 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchDeleteSubscriptionsFilterPolicesRequestBody_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchDeleteSubscriptionsFilterPolicesRequestBody_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// +/// +class HUAWEICLOUD_SMN_V2_EXPORT BatchDeleteSubscriptionsFilterPolicesRequestBody + : public ModelBase +{ +public: + BatchDeleteSubscriptionsFilterPolicesRequestBody(); + virtual ~BatchDeleteSubscriptionsFilterPolicesRequestBody(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// BatchDeleteSubscriptionsFilterPolicesRequestBody members + + /// + /// 订阅者的唯一的资源标识，可通过[查询订阅者列表](ListSubscriptions.xml)获取该标识。 + /// + + std::vector& getSubscriptionUrns(); + bool subscriptionUrnsIsSet() const; + void unsetsubscriptionUrns(); + void setSubscriptionUrns(const std::vector& value); + + +protected: + std::vector subscriptionUrns_; + bool subscriptionUrnsIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchDeleteSubscriptionsFilterPolicesRequestBody_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesResponse.h b/smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesResponse.h new file mode 100644 index 000000000..faf076f58 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesResponse.h @@ -0,0 +1,80 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchDeleteSubscriptionsFilterPolicesResponse_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchDeleteSubscriptionsFilterPolicesResponse_H_ + + +#include + +#include +#include +#include + +#include +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT BatchDeleteSubscriptionsFilterPolicesResponse + : public ModelBase, public HttpResponse +{ +public: + BatchDeleteSubscriptionsFilterPolicesResponse(); + virtual ~BatchDeleteSubscriptionsFilterPolicesResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// BatchDeleteSubscriptionsFilterPolicesResponse members + + /// + /// 请求的唯一标识ID。 + /// + + std::string getRequestId() const; + bool requestIdIsSet() const; + void unsetrequestId(); + void setRequestId(const std::string& value); + + /// + /// 批量结果 + /// + + std::vector& getBatchResult(); + bool batchResultIsSet() const; + void unsetbatchResult(); + void setBatchResult(const std::vector& value); + + +protected: + std::string requestId_; + bool requestIdIsSet_; + std::vector batchResult_; + bool batchResultIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchDeleteSubscriptionsFilterPolicesResponse_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/BatchResult.h b/smn/include/huaweicloud/smn/v2/model/BatchResult.h new file mode 100644 index 000000000..b59c17aa2 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/BatchResult.h @@ -0,0 +1,86 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchResult_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchResult_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// +/// +class HUAWEICLOUD_SMN_V2_EXPORT BatchResult + : public ModelBase +{ +public: + BatchResult(); + virtual ~BatchResult(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// BatchResult members + + /// + /// 执行结果code + /// + + std::string getCode() const; + bool codeIsSet() const; + void unsetcode(); + void setCode(const std::string& value); + + /// + /// 执行结果message + /// + + std::string getMessage() const; + bool messageIsSet() const; + void unsetmessage(); + void setMessage(const std::string& value); + + /// + /// 订阅者urn + /// + + std::string getSubscriptionUrn() const; + bool subscriptionUrnIsSet() const; + void unsetsubscriptionUrn(); + void setSubscriptionUrn(const std::string& value); + + +protected: + std::string code_; + bool codeIsSet_; + std::string message_; + bool messageIsSet_; + std::string subscriptionUrn_; + bool subscriptionUrnIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchResult_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/BatchSubscriptionsFilterPolicesRequestBody.h b/smn/include/huaweicloud/smn/v2/model/BatchSubscriptionsFilterPolicesRequestBody.h new file mode 100644 index 000000000..3c5188954 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/BatchSubscriptionsFilterPolicesRequestBody.h @@ -0,0 +1,65 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchSubscriptionsFilterPolicesRequestBody_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchSubscriptionsFilterPolicesRequestBody_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// filter_polices字段，必填，一个筛选策略最多可具有 5 个属性策略。 name-属性名称：满足正则 ^(?!smn_)(?!.*?_$)(?!^_)(?!.*?__)[a-z0-9_]{1,32}$ （英文字母([a-z])、数字([0-9])、下划线(_)，下划线不得开始、结尾或连续出现），长度限制{1,32}，key不能是smn_开头 字符串匹配策略： string_equals：精准匹配字符串；类型：字符串数组，数组长度[1,10]，字符串长度限制[1,32]，不能重复，不能空值“ ” +/// +class HUAWEICLOUD_SMN_V2_EXPORT BatchSubscriptionsFilterPolicesRequestBody + : public ModelBase +{ +public: + BatchSubscriptionsFilterPolicesRequestBody(); + virtual ~BatchSubscriptionsFilterPolicesRequestBody(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// BatchSubscriptionsFilterPolicesRequestBody members + + /// + /// 批量处理订阅者策略列表。 + /// + + std::vector& getPolices(); + bool policesIsSet() const; + void unsetpolices(); + void setPolices(const std::vector& value); + + +protected: + std::vector polices_; + bool policesIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchSubscriptionsFilterPolicesRequestBody_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/BatchSubscriptionsFilterPolicesRequestBody_polices.h b/smn/include/huaweicloud/smn/v2/model/BatchSubscriptionsFilterPolicesRequestBody_polices.h new file mode 100644 index 000000000..937e8fc7a --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/BatchSubscriptionsFilterPolicesRequestBody_polices.h @@ -0,0 +1,77 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchSubscriptionsFilterPolicesRequestBody_polices_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchSubscriptionsFilterPolicesRequestBody_polices_H_ + + +#include + +#include +#include +#include + +#include +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// +/// +class HUAWEICLOUD_SMN_V2_EXPORT BatchSubscriptionsFilterPolicesRequestBody_polices + : public ModelBase +{ +public: + BatchSubscriptionsFilterPolicesRequestBody_polices(); + virtual ~BatchSubscriptionsFilterPolicesRequestBody_polices(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// BatchSubscriptionsFilterPolicesRequestBody_polices members + + /// + /// 订阅者的唯一的资源标识，可通过[查询订阅者列表](ListSubscriptions.xml)获取该标识。 + /// + + std::string getSubscriptionUrn() const; + bool subscriptionUrnIsSet() const; + void unsetsubscriptionUrn(); + void setSubscriptionUrn(const std::string& value); + + /// + /// 订阅者的过滤策略。策略name不能重复 + /// + + std::vector& getFilterPolices(); + bool filterPolicesIsSet() const; + void unsetfilterPolices(); + void setFilterPolices(const std::vector& value); + + +protected: + std::string subscriptionUrn_; + bool subscriptionUrnIsSet_; + std::vector filterPolices_; + bool filterPolicesIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchSubscriptionsFilterPolicesRequestBody_polices_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/BatchUpdateSubscriptionsFilterPolicesRequest.h b/smn/include/huaweicloud/smn/v2/model/BatchUpdateSubscriptionsFilterPolicesRequest.h new file mode 100644 index 000000000..271541764 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/BatchUpdateSubscriptionsFilterPolicesRequest.h @@ -0,0 +1,71 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchUpdateSubscriptionsFilterPolicesRequest_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchUpdateSubscriptionsFilterPolicesRequest_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT BatchUpdateSubscriptionsFilterPolicesRequest + : public ModelBase +{ +public: + BatchUpdateSubscriptionsFilterPolicesRequest(); + virtual ~BatchUpdateSubscriptionsFilterPolicesRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// BatchUpdateSubscriptionsFilterPolicesRequest members + + /// + /// + /// + + BatchSubscriptionsFilterPolicesRequestBody getBody() const; + bool bodyIsSet() const; + void unsetbody(); + void setBody(const BatchSubscriptionsFilterPolicesRequestBody& value); + + +protected: + BatchSubscriptionsFilterPolicesRequestBody body_; + bool bodyIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + BatchUpdateSubscriptionsFilterPolicesRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchUpdateSubscriptionsFilterPolicesRequest_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/BatchUpdateSubscriptionsFilterPolicesResponse.h b/smn/include/huaweicloud/smn/v2/model/BatchUpdateSubscriptionsFilterPolicesResponse.h new file mode 100644 index 000000000..403012ea2 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/BatchUpdateSubscriptionsFilterPolicesResponse.h @@ -0,0 +1,80 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchUpdateSubscriptionsFilterPolicesResponse_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchUpdateSubscriptionsFilterPolicesResponse_H_ + + +#include + +#include +#include +#include + +#include +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT BatchUpdateSubscriptionsFilterPolicesResponse + : public ModelBase, public HttpResponse +{ +public: + BatchUpdateSubscriptionsFilterPolicesResponse(); + virtual ~BatchUpdateSubscriptionsFilterPolicesResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// BatchUpdateSubscriptionsFilterPolicesResponse members + + /// + /// 请求的唯一标识ID。 + /// + + std::string getRequestId() const; + bool requestIdIsSet() const; + void unsetrequestId(); + void setRequestId(const std::string& value); + + /// + /// 批量结果 + /// + + std::vector& getBatchResult(); + bool batchResultIsSet() const; + void unsetbatchResult(); + void setBatchResult(const std::vector& value); + + +protected: + std::string requestId_; + bool requestIdIsSet_; + std::vector batchResult_; + bool batchResultIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_BatchUpdateSubscriptionsFilterPolicesResponse_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/GetHttpDetectResponseBody_detail.h b/smn/include/huaweicloud/smn/v2/model/GetHttpDetectResponseBody_detail.h new file mode 100644 index 000000000..919cdc4e6 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/GetHttpDetectResponseBody_detail.h @@ -0,0 +1,75 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_GetHttpDetectResponseBody_detail_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_GetHttpDetectResponseBody_detail_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// 终端探测详情 +/// +class HUAWEICLOUD_SMN_V2_EXPORT GetHttpDetectResponseBody_detail + : public ModelBase +{ +public: + GetHttpDetectResponseBody_detail(); + virtual ~GetHttpDetectResponseBody_detail(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// GetHttpDetectResponseBody_detail members + + /// + /// 探测终端返回的http返回码，0代表用户在黑名单无法发送，-1代表用户终端超过5秒未响应，-2代表队列已满，Http探测任务未执行。其他httpcode为终端实际返回值。 + /// + + int32_t getHttpCode() const; + bool httpCodeIsSet() const; + void unsethttpCode(); + void setHttpCode(int32_t value); + + /// + /// 终端探测响应体，如果httpCode为0，-1，-2, 2xx时响应体内容固定，由SMN定义。其余httpCode的响应体内容为终端返回内容。 + /// + + std::string getHttpResponse() const; + bool httpResponseIsSet() const; + void unsethttpResponse(); + void setHttpResponse(const std::string& value); + + +protected: + int32_t httpCode_; + bool httpCodeIsSet_; + std::string httpResponse_; + bool httpResponseIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_GetHttpDetectResponseBody_detail_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/HttpDetectRequestBody.h b/smn/include/huaweicloud/smn/v2/model/HttpDetectRequestBody.h new file mode 100644 index 000000000..7c3aa3b0f --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/HttpDetectRequestBody.h @@ -0,0 +1,87 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_HttpDetectRequestBody_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_HttpDetectRequestBody_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Http探测请求参数，包含protocol，endpoint，extension字段，详细限制见参数描述。 +/// +class HUAWEICLOUD_SMN_V2_EXPORT HttpDetectRequestBody + : public ModelBase +{ +public: + HttpDetectRequestBody(); + virtual ~HttpDetectRequestBody(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// HttpDetectRequestBody members + + /// + /// 协议类型，当前仅支持http/https，不可为空 + /// + + std::string getProtocol() const; + bool protocolIsSet() const; + void unsetprotocol(); + void setProtocol(const std::string& value); + + /// + /// 待探测的终端地址，当前仅支持以http:// 或https://开头，不可为空 + /// + + std::string getEndpoint() const; + bool endpointIsSet() const; + void unsetendpoint(); + void setEndpoint(const std::string& value); + + /// + /// + /// + + HttpDetectRequestBody_extension getExtension() const; + bool extensionIsSet() const; + void unsetextension(); + void setExtension(const HttpDetectRequestBody_extension& value); + + +protected: + std::string protocol_; + bool protocolIsSet_; + std::string endpoint_; + bool endpointIsSet_; + HttpDetectRequestBody_extension extension_; + bool extensionIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_HttpDetectRequestBody_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/HttpDetectRequestBody_extension.h b/smn/include/huaweicloud/smn/v2/model/HttpDetectRequestBody_extension.h new file mode 100644 index 000000000..3672d69fc --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/HttpDetectRequestBody_extension.h @@ -0,0 +1,66 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_HttpDetectRequestBody_extension_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_HttpDetectRequestBody_extension_H_ + + +#include + +#include +#include +#include + +#include +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Http/Https协议可以指定多个K/V对，在发送Http/Https协议消息时会携带这些K/V对作为请求header。extension字段允许为空，header字段允许为空。 +/// +class HUAWEICLOUD_SMN_V2_EXPORT HttpDetectRequestBody_extension + : public ModelBase +{ +public: + HttpDetectRequestBody_extension(); + virtual ~HttpDetectRequestBody_extension(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// HttpDetectRequestBody_extension members + + /// + /// header应满足如下要求： 1. key值限定为：包含英文字母([A-Za-z])、数字([0-9])、中划线(-)hyphens，中划线不得作为结尾，不得连续出现。 2. K/V不得超过10个 3. key需要以\"x-\"开头，不能以\"x-smn\"开头，正确示例：x-abc-cba, x-abc 4. 所有K/V长度总和不得超过1024个字符 5. key不区分大小写 6. key值不可重复 7. value值限定为ASCII码，不支持中文或其他Unicode，支持空格 + /// + + std::map& getHeader(); + bool headerIsSet() const; + void unsetheader(); + void setHeader(const std::map& value); + + +protected: + std::map header_; + bool headerIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_HttpDetectRequestBody_extension_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsByTopicRequest.h b/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsByTopicRequest.h index a0073804f..bd07f975d 100644 --- a/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsByTopicRequest.h +++ b/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsByTopicRequest.h @@ -65,6 +65,15 @@ class HUAWEICLOUD_SMN_V2_EXPORT ListSubscriptionsByTopicRequest void unsetlimit(); void setLimit(int32_t value); + /// + /// 检索的订阅备注字段，模糊匹配。最大长度限制为128字节。 + /// + + std::string getFuzzyRemark() const; + bool fuzzyRemarkIsSet() const; + void unsetfuzzyRemark(); + void setFuzzyRemark(const std::string& value); + protected: std::string topicUrn_; @@ -73,6 +82,8 @@ class HUAWEICLOUD_SMN_V2_EXPORT ListSubscriptionsByTopicRequest bool offsetIsSet_; int32_t limit_; bool limitIsSet_; + std::string fuzzyRemark_; + bool fuzzyRemarkIsSet_; #ifdef RTTR_FLAG RTTR_ENABLE() diff --git a/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsItem.h b/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsItem.h index b34f4892f..f6064aee4 100644 --- a/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsItem.h +++ b/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsItem.h @@ -9,7 +9,9 @@ #include #include +#include #include +#include namespace HuaweiCloud { namespace Sdk { @@ -101,6 +103,15 @@ class HUAWEICLOUD_SMN_V2_EXPORT ListSubscriptionsItem void unsetstatus(); void setStatus(int32_t value); + /// + /// + /// + + std::vector& getFilterPolices(); + bool filterPolicesIsSet() const; + void unsetfilterPolices(); + void setFilterPolices(const std::vector& value); + protected: std::string topicUrn_; @@ -117,6 +128,8 @@ class HUAWEICLOUD_SMN_V2_EXPORT ListSubscriptionsItem bool remarkIsSet_; int32_t status_; bool statusIsSet_; + std::vector filterPolices_; + bool filterPolicesIsSet_; }; diff --git a/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsRequest.h b/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsRequest.h index 71f2c9131..a0233ebbe 100644 --- a/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsRequest.h +++ b/smn/include/huaweicloud/smn/v2/model/ListSubscriptionsRequest.h @@ -83,6 +83,15 @@ class HUAWEICLOUD_SMN_V2_EXPORT ListSubscriptionsRequest void unsetendpoint(); void setEndpoint(const std::string& value); + /// + /// 检索的订阅备注字段，模糊匹配。最大长度限制为128个字节。 + /// + + std::string getFuzzyRemark() const; + bool fuzzyRemarkIsSet() const; + void unsetfuzzyRemark(); + void setFuzzyRemark(const std::string& value); + protected: int32_t offset_; @@ -95,6 +104,8 @@ class HUAWEICLOUD_SMN_V2_EXPORT ListSubscriptionsRequest bool statusIsSet_; std::string endpoint_; bool endpointIsSet_; + std::string fuzzyRemark_; + bool fuzzyRemarkIsSet_; #ifdef RTTR_FLAG RTTR_ENABLE() diff --git a/smn/include/huaweicloud/smn/v2/model/ListTopicsRequest.h b/smn/include/huaweicloud/smn/v2/model/ListTopicsRequest.h index 6e952d50b..f6493588e 100644 --- a/smn/include/huaweicloud/smn/v2/model/ListTopicsRequest.h +++ b/smn/include/huaweicloud/smn/v2/model/ListTopicsRequest.h @@ -75,7 +75,7 @@ class HUAWEICLOUD_SMN_V2_EXPORT ListTopicsRequest void setName(const std::string& value); /// - /// 检索的主题名称，模糊匹配，按照startwith模式进行匹配。 + /// 检索的主题名称，模糊匹配。 /// std::string getFuzzyName() const; @@ -92,6 +92,15 @@ class HUAWEICLOUD_SMN_V2_EXPORT ListTopicsRequest void unsettopicId(); void setTopicId(const std::string& value); + /// + /// 检索的主题显示名。模糊匹配。参数字节长度不能大于192字节。 + /// + + std::string getFuzzyDisplayName() const; + bool fuzzyDisplayNameIsSet() const; + void unsetfuzzyDisplayName(); + void setFuzzyDisplayName(const std::string& value); + protected: int32_t offset_; @@ -106,6 +115,8 @@ class HUAWEICLOUD_SMN_V2_EXPORT ListTopicsRequest bool fuzzyNameIsSet_; std::string topicId_; bool topicIdIsSet_; + std::string fuzzyDisplayName_; + bool fuzzyDisplayNameIsSet_; #ifdef RTTR_FLAG RTTR_ENABLE() diff --git a/smn/include/huaweicloud/smn/v2/model/MessageAttribute.h b/smn/include/huaweicloud/smn/v2/model/MessageAttribute.h new file mode 100644 index 000000000..0ac798258 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/MessageAttribute.h @@ -0,0 +1,87 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_MessageAttribute_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_MessageAttribute_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// 消息属性 +/// +class HUAWEICLOUD_SMN_V2_EXPORT MessageAttribute + : public ModelBase +{ +public: + MessageAttribute(); + virtual ~MessageAttribute(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// MessageAttribute members + + /// + /// 属性名称。属性名称只能包含小写英文字母([a-z])、数字([0-9])、下划线(_)，下划线不能出现在开始或结尾，下划线不能连续出现，长度为1到32个字符 + /// + + std::string getName() const; + bool nameIsSet() const; + void unsetname(); + void setName(const std::string& value); + + /// + /// 属性类型 STRING：字符串（String）类型 STRING_ARRAY：字符串数组（String.Array）类型 PROTOCOL：协议类型 + /// + + std::string getType() const; + bool typeIsSet() const; + void unsettype(); + void setType(const std::string& value); + + /// + /// 属性值。 当属性类型为“STRING”时，属性值只能包含中英文、数字、下划线，长度为1到32个字符。 当属性类型为“STRING_ARRAY”时，属性值为字符串数组，数组长度为1到10，数组中的元素内容不能重复，数组中的每个字符串都只能包含中英文、数字、下划线，且长度为1到32个字符。 当属性类型为“PROTOCOL”时，属性值为支持协议类型的字符串数组。 + /// + + Object getValue() const; + bool valueIsSet() const; + void unsetvalue(); + void setValue(const Object& value); + + +protected: + std::string name_; + bool nameIsSet_; + std::string type_; + bool typeIsSet_; + Object value_; + bool valueIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_MessageAttribute_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/PublishHttpDetectRequest.h b/smn/include/huaweicloud/smn/v2/model/PublishHttpDetectRequest.h new file mode 100644 index 000000000..0b0c134ec --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/PublishHttpDetectRequest.h @@ -0,0 +1,83 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_PublishHttpDetectRequest_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_PublishHttpDetectRequest_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT PublishHttpDetectRequest + : public ModelBase +{ +public: + PublishHttpDetectRequest(); + virtual ~PublishHttpDetectRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// PublishHttpDetectRequest members + + /// + /// Topic的唯一的资源标识，可通过[查询主题列表](smn_api_51004.xml)获取该标识。 + /// + + std::string getTopicUrn() const; + bool topicUrnIsSet() const; + void unsettopicUrn(); + void setTopicUrn(const std::string& value); + + /// + /// + /// + + HttpDetectRequestBody getBody() const; + bool bodyIsSet() const; + void unsetbody(); + void setBody(const HttpDetectRequestBody& value); + + +protected: + std::string topicUrn_; + bool topicUrnIsSet_; + HttpDetectRequestBody body_; + bool bodyIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + PublishHttpDetectRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_PublishHttpDetectRequest_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/PublishHttpDetectResponse.h b/smn/include/huaweicloud/smn/v2/model/PublishHttpDetectResponse.h new file mode 100644 index 000000000..040173a83 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/PublishHttpDetectResponse.h @@ -0,0 +1,78 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_PublishHttpDetectResponse_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_PublishHttpDetectResponse_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT PublishHttpDetectResponse + : public ModelBase, public HttpResponse +{ +public: + PublishHttpDetectResponse(); + virtual ~PublishHttpDetectResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// PublishHttpDetectResponse members + + /// + /// 请求ID + /// + + std::string getRequestId() const; + bool requestIdIsSet() const; + void unsetrequestId(); + void setRequestId(const std::string& value); + + /// + /// 探测任务ID + /// + + std::string getTaskId() const; + bool taskIdIsSet() const; + void unsettaskId(); + void setTaskId(const std::string& value); + + +protected: + std::string requestId_; + bool requestIdIsSet_; + std::string taskId_; + bool taskIdIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_PublishHttpDetectResponse_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/PublishMessageRequestBody.h b/smn/include/huaweicloud/smn/v2/model/PublishMessageRequestBody.h index 2106a81fd..8d44d31f5 100644 --- a/smn/include/huaweicloud/smn/v2/model/PublishMessageRequestBody.h +++ b/smn/include/huaweicloud/smn/v2/model/PublishMessageRequestBody.h @@ -9,6 +9,7 @@ #include #include +#include #include #include #include @@ -94,6 +95,15 @@ class HUAWEICLOUD_SMN_V2_EXPORT PublishMessageRequestBody void unsettimeToLive(); void setTimeToLive(const std::string& value); + /// + /// 消息属性列表 + /// + + std::vector& getMessageAttributes(); + bool messageAttributesIsSet() const; + void unsetmessageAttributes(); + void setMessageAttributes(const std::vector& value); + protected: std::string subject_; @@ -108,6 +118,8 @@ class HUAWEICLOUD_SMN_V2_EXPORT PublishMessageRequestBody bool tagsIsSet_; std::string timeToLive_; bool timeToLiveIsSet_; + std::vector messageAttributes_; + bool messageAttributesIsSet_; }; diff --git a/smn/include/huaweicloud/smn/v2/model/ShowHttpDetectResultRequest.h b/smn/include/huaweicloud/smn/v2/model/ShowHttpDetectResultRequest.h new file mode 100644 index 000000000..32a6e386c --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/ShowHttpDetectResultRequest.h @@ -0,0 +1,82 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_ShowHttpDetectResultRequest_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_ShowHttpDetectResultRequest_H_ + + +#include + +#include +#include +#include + +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Request Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT ShowHttpDetectResultRequest + : public ModelBase +{ +public: + ShowHttpDetectResultRequest(); + virtual ~ShowHttpDetectResultRequest(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// ShowHttpDetectResultRequest members + + /// + /// Topic的唯一的资源标识，可通过[查询主题列表](smn_api_51004.xml)获取该标识。 + /// + + std::string getTopicUrn() const; + bool topicUrnIsSet() const; + void unsettopicUrn(); + void setTopicUrn(const std::string& value); + + /// + /// http探测任务id + /// + + std::string getTaskId() const; + bool taskIdIsSet() const; + void unsettaskId(); + void setTaskId(const std::string& value); + + +protected: + std::string topicUrn_; + bool topicUrnIsSet_; + std::string taskId_; + bool taskIdIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +public: + ShowHttpDetectResultRequest& dereference_from_shared_ptr(std::shared_ptr ptr) { + return *ptr; + } +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_ShowHttpDetectResultRequest_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/ShowHttpDetectResultResponse.h b/smn/include/huaweicloud/smn/v2/model/ShowHttpDetectResultResponse.h new file mode 100644 index 000000000..a191f7567 --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/ShowHttpDetectResultResponse.h @@ -0,0 +1,90 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_ShowHttpDetectResultResponse_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_ShowHttpDetectResultResponse_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// Response Object +/// +class HUAWEICLOUD_SMN_V2_EXPORT ShowHttpDetectResultResponse + : public ModelBase, public HttpResponse +{ +public: + ShowHttpDetectResultResponse(); + virtual ~ShowHttpDetectResultResponse(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// ShowHttpDetectResultResponse members + + /// + /// + /// + + GetHttpDetectResponseBody_detail getDetail() const; + bool detailIsSet() const; + void unsetdetail(); + void setDetail(const GetHttpDetectResponseBody_detail& value); + + /// + /// http探测任务状态，0代表执行成功，终端可用，1代表未执行，2代表执行失败，终端不可用 + /// + + int32_t getStatus() const; + bool statusIsSet() const; + void unsetstatus(); + void setStatus(int32_t value); + + /// + /// 请求ID + /// + + std::string getRequestId() const; + bool requestIdIsSet() const; + void unsetrequestId(); + void setRequestId(const std::string& value); + + +protected: + GetHttpDetectResponseBody_detail detail_; + bool detailIsSet_; + int32_t status_; + bool statusIsSet_; + std::string requestId_; + bool requestIdIsSet_; + +#ifdef RTTR_FLAG + RTTR_ENABLE() +#endif +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_ShowHttpDetectResultResponse_H_ diff --git a/smn/include/huaweicloud/smn/v2/model/Statement.h b/smn/include/huaweicloud/smn/v2/model/Statement.h index d04500a41..cd2d4b638 100644 --- a/smn/include/huaweicloud/smn/v2/model/Statement.h +++ b/smn/include/huaweicloud/smn/v2/model/Statement.h @@ -57,7 +57,7 @@ class HUAWEICLOUD_SMN_V2_EXPORT Statement void setEffect(const std::string& value); /// - /// Statement语句作用的对象。 目前支持“CSP”和“Service”两类对象。 “CSP”对象指的是其他用户，可以作用于多个用户。 “Service”对象指的是云服务，可以作用于多个云服务。 Principal元素和NotPrincipal元素两者任选其一。选定后， “CSP”对象填写内容的格式为urn:csp:iam::domainId:root或“\\*”，其中domainId为其他用户的“账号ID”，“\\*”指作用于所有人。 “Service”对象填写内容的格式为小写的云服务名称缩写。 + /// Statement语句作用的对象。 目前支持“CSP”和“Service”两类对象。 “CSP”对象指的是其他用户，可以作用于多个用户。 “Service”对象指的是云服务，可以作用于多个云服务。 Principal元素和NotPrincipal元素两者任选其一。选定后， “CSP”对象填写内容的格式为urn:csp:iam::domainId:root或“\\*”，其中domainId为其他用户的“帐号ID”，“\\*”指作用于所有人。 “Service”对象填写内容的格式为小写的云服务名称缩写。 /// std::string getPrincipal() const; @@ -66,7 +66,7 @@ class HUAWEICLOUD_SMN_V2_EXPORT Statement void setPrincipal(const std::string& value); /// - /// NotPrincipal：Statement语句排除作用的对象。 目前支持“CSP”和“Service”两类对象。 “CSP”对象指的是其他用户，可以作用于多个用户。 “Service”对象指的是云服务，可以作用于多个云服务。 Principal元素和NotPrincipal元素两者任选其一。选定后， “CSP”对象填写内容的格式为urn:csp:iam::domainId:root或“\\*”，其中domainId为其他用户的“账号ID”，“\\*”指作用于所有人。 “Service”对象填写内容的格式为小写的云服务名称缩写。 + /// NotPrincipal：Statement语句排除作用的对象。 目前支持“CSP”和“Service”两类对象。 “CSP”对象指的是其他用户，可以作用于多个用户。 “Service”对象指的是云服务，可以作用于多个云服务。 Principal元素和NotPrincipal元素两者任选其一。选定后， “CSP”对象填写内容的格式为urn:csp:iam::domainId:root或“\\*”，其中domainId为其他用户的“帐号ID”，“\\*”指作用于所有人。 “Service”对象填写内容的格式为小写的云服务名称缩写。 /// std::string getNotPrincipal() const; diff --git a/smn/include/huaweicloud/smn/v2/model/SubscriptionsFilterPolicy.h b/smn/include/huaweicloud/smn/v2/model/SubscriptionsFilterPolicy.h new file mode 100644 index 000000000..f1b0d7a1b --- /dev/null +++ b/smn/include/huaweicloud/smn/v2/model/SubscriptionsFilterPolicy.h @@ -0,0 +1,76 @@ + +#ifndef HUAWEICLOUD_SDK_SMN_V2_MODEL_SubscriptionsFilterPolicy_H_ +#define HUAWEICLOUD_SDK_SMN_V2_MODEL_SubscriptionsFilterPolicy_H_ + + +#include + +#include +#include +#include + +#include +#include + +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + +using namespace HuaweiCloud::Sdk::Core::Utils; +using namespace HuaweiCloud::Sdk::Core::Http; +/// +/// 过滤策略。 +/// +class HUAWEICLOUD_SMN_V2_EXPORT SubscriptionsFilterPolicy + : public ModelBase +{ +public: + SubscriptionsFilterPolicy(); + virtual ~SubscriptionsFilterPolicy(); + + ///////////////////////////////////////////// + /// ModelBase overrides + + void validate() override; + web::json::value toJson() const override; + bool fromJson(const web::json::value& json) override; + ///////////////////////////////////////////// + /// SubscriptionsFilterPolicy members + + /// + /// 过滤策略名称。 包含小写英文字母([a-z])、数字([0-9])、下划线(_)，下划线不得开始、结尾或连续出现），长度限制{1,32}，不能是smn_开头。 + /// + + std::string getName() const; + bool nameIsSet() const; + void unsetname(); + void setName(const std::string& value); + + /// + /// 字符串精确匹配数组。数组长度[1, 10]，数组内容不能重复，值不能为null或者空字符串“ ”，长度限制[1,32]，中英文、数字、下划线 + /// + + std::vector& getStringEquals(); + bool stringEqualsIsSet() const; + void unsetstringEquals(); + void setStringEquals(const std::vector& value); + + +protected: + std::string name_; + bool nameIsSet_; + std::vector stringEquals_; + bool stringEqualsIsSet_; + +}; + + +} +} +} +} +} + +#endif // HUAWEICLOUD_SDK_SMN_V2_MODEL_SubscriptionsFilterPolicy_H_ diff --git a/smn/src/v2/SmnClient.cpp b/smn/src/v2/SmnClient.cpp index 065d70606..4e6a60aa5 100644 --- a/smn/src/v2/SmnClient.cpp +++ b/smn/src/v2/SmnClient.cpp @@ -74,6 +74,48 @@ std::shared_ptr SmnClient::addSubscription(AddSubscript return localVarResult; } +std::shared_ptr SmnClient::addSubscriptionFromSubscriptionUser(AddSubscriptionFromSubscriptionUserRequest &request) +{ + std::string localVarPath = "/v2/{project_id}/notifications/topics/{topic_urn}/subscriptions/from-subscription-users"; + + std::map localVarQueryParams; + std::map localVarHeaderParams; + std::map localVarFormParams; + std::map localVarPathParams; + + localVarPathParams["topic_urn"] = parameterToString(request.getTopicUrn()); + + 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; + + + 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, SmnMeta::genRequestDefForAddSubscriptionFromSubscriptionUser()); + + 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 SmnClient::batchCreateOrDeleteResourceTags(BatchCreateOrDeleteResourceTagsRequest &request) { std::string localVarPath = "/v2/{project_id}/{resource_type}/{resource_id}/tags/action"; @@ -117,6 +159,129 @@ std::shared_ptr SmnClient::batchCreateO return localVarResult; } +std::shared_ptr SmnClient::batchCreateSubscriptionsFilterPolices(BatchCreateSubscriptionsFilterPolicesRequest &request) +{ + std::string localVarPath = "/v2/{project_id}/notifications/subscriptions/filter_polices"; + + 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; + + + 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, SmnMeta::genRequestDefForBatchCreateSubscriptionsFilterPolices()); + + 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 SmnClient::batchDeleteSubscriptionsFilterPolices(BatchDeleteSubscriptionsFilterPolicesRequest &request) +{ + std::string localVarPath = "/v2/{project_id}/notifications/subscriptions/filter_polices"; + + 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; + + + 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("DELETE", localVarPath, localVarPathParams, localVarQueryParams, + localVarHeaderParams, localVarHttpBody, SmnMeta::genRequestDefForBatchDeleteSubscriptionsFilterPolices()); + + 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 SmnClient::batchUpdateSubscriptionsFilterPolices(BatchUpdateSubscriptionsFilterPolicesRequest &request) +{ + std::string localVarPath = "/v2/{project_id}/notifications/subscriptions/filter_polices"; + + 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; + + + 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, SmnMeta::genRequestDefForBatchUpdateSubscriptionsFilterPolices()); + + 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 SmnClient::cancelSubscription(CancelSubscriptionRequest &request) { std::string localVarPath = "/v2/{project_id}/notifications/subscriptions/{subscription_urn}"; @@ -733,6 +898,9 @@ std::shared_ptr SmnClient::listSubscriptions(ListSubs if (request.endpointIsSet()) { localVarQueryParams["endpoint"] = parameterToString(request.getEndpoint()); } + if (request.fuzzyRemarkIsSet()) { + localVarQueryParams["fuzzy_remark"] = parameterToString(request.getFuzzyRemark()); + } std::string localVarHttpBody; @@ -769,6 +937,9 @@ std::shared_ptr SmnClient::listSubscriptionsBy if (request.limitIsSet()) { localVarQueryParams["limit"] = parameterToString(request.getLimit()); } + if (request.fuzzyRemarkIsSet()) { + localVarQueryParams["fuzzy_remark"] = parameterToString(request.getFuzzyRemark()); + } std::string localVarHttpBody; @@ -879,6 +1050,9 @@ std::shared_ptr SmnClient::listTopics(ListTopicsRequest &req if (request.topicIdIsSet()) { localVarQueryParams["topic_id"] = parameterToString(request.getTopicId()); } + if (request.fuzzyDisplayNameIsSet()) { + localVarQueryParams["fuzzy_display_name"] = parameterToString(request.getFuzzyDisplayName()); + } std::string localVarHttpBody; @@ -950,6 +1124,48 @@ std::shared_ptr SmnClient::listVersions(ListVersionsReques return localVarResult; } +std::shared_ptr SmnClient::publishHttpDetect(PublishHttpDetectRequest &request) +{ + std::string localVarPath = "/v2/{project_id}/notifications/topics/{topic_urn}/detection"; + + std::map localVarQueryParams; + std::map localVarHeaderParams; + std::map localVarFormParams; + std::map localVarPathParams; + + localVarPathParams["topic_urn"] = parameterToString(request.getTopicUrn()); + + 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; + + + 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, SmnMeta::genRequestDefForPublishHttpDetect()); + + 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 SmnClient::publishMessage(PublishMessageRequest &request) { std::string localVarPath = "/v2/{project_id}/notifications/topics/{topic_urn}/publish"; @@ -992,6 +1208,37 @@ std::shared_ptr SmnClient::publishMessage(PublishMessage return localVarResult; } +std::shared_ptr SmnClient::showHttpDetectResult(ShowHttpDetectResultRequest &request) +{ + std::string localVarPath = "/v2/{project_id}/notifications/topics/{topic_urn}/detection/{task_id}"; + + std::map localVarQueryParams; + std::map localVarHeaderParams; + std::map localVarFormParams; + std::map localVarPathParams; + + localVarPathParams["topic_urn"] = parameterToString(request.getTopicUrn()); + localVarPathParams["task_id"] = parameterToString(request.getTaskId()); + + bool isJson = false; + bool isMultiPart = false; + bool isBson = false; + std::string contentType = getContentType("application/json", isJson, isMultiPart, isBson); + localVarHeaderParams["Content-Type"] = contentType; + + + std::string localVarHttpBody; + + std::unique_ptr res = callApi("GET", localVarPath, localVarPathParams, localVarQueryParams, + localVarHeaderParams, localVarHttpBody, SmnMeta::genRequestDefForShowHttpDetectResult()); + + std::shared_ptr localVarResult = std::make_shared(); + localVarResult->setStatusCode(res->getStatusCode()); + localVarResult->setHeaderParams(res->getHeaderParams()); + localVarResult->setHttpBody(res->getHttpBody()); + + return localVarResult; +} std::shared_ptr SmnClient::updateLogtank(UpdateLogtankRequest &request) { std::string localVarPath = "/v2/{project_id}/notifications/topics/{topic_urn}/logtanks/{logtank_id}"; diff --git a/smn/src/v2/SmnMeta.cpp b/smn/src/v2/SmnMeta.cpp index 8701ae014..e651b9fcd 100644 --- a/smn/src/v2/SmnMeta.cpp +++ b/smn/src/v2/SmnMeta.cpp @@ -17,6 +17,15 @@ HttpRequestDef SmnMeta::genRequestDefForAddSubscription() { return reqDefBuilder; } +HttpRequestDef SmnMeta::genRequestDefForAddSubscriptionFromSubscriptionUser() { + HttpRequestDef reqDefBuilder; + FieldDef bodyParam; + reqDefBuilder.withRequestField(bodyParam. + withName("Body"). + withLocationType(Body_)); + return reqDefBuilder; +} + HttpRequestDef SmnMeta::genRequestDefForBatchCreateOrDeleteResourceTags() { HttpRequestDef reqDefBuilder; FieldDef bodyParam; @@ -26,6 +35,33 @@ HttpRequestDef SmnMeta::genRequestDefForBatchCreateOrDeleteResourceTags() { return reqDefBuilder; } +HttpRequestDef SmnMeta::genRequestDefForBatchCreateSubscriptionsFilterPolices() { + HttpRequestDef reqDefBuilder; + FieldDef bodyParam; + reqDefBuilder.withRequestField(bodyParam. + withName("Body"). + withLocationType(Body_)); + return reqDefBuilder; +} + +HttpRequestDef SmnMeta::genRequestDefForBatchDeleteSubscriptionsFilterPolices() { + HttpRequestDef reqDefBuilder; + FieldDef bodyParam; + reqDefBuilder.withRequestField(bodyParam. + withName("Body"). + withLocationType(Body_)); + return reqDefBuilder; +} + +HttpRequestDef SmnMeta::genRequestDefForBatchUpdateSubscriptionsFilterPolices() { + HttpRequestDef reqDefBuilder; + FieldDef bodyParam; + reqDefBuilder.withRequestField(bodyParam. + withName("Body"). + withLocationType(Body_)); + return reqDefBuilder; +} + HttpRequestDef SmnMeta::genRequestDefForCancelSubscription() { HttpRequestDef reqDefBuilder; return reqDefBuilder; @@ -160,6 +196,9 @@ HttpRequestDef SmnMeta::genRequestDefForListSubscriptions() { reqDefBuilder.withRequestField(FieldDef().withName("Endpoint") .withJsonTag("endpoint") .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("FuzzyRemark") + .withJsonTag("fuzzy_remark") + .withLocationType(Query_)); return reqDefBuilder; } @@ -171,6 +210,9 @@ HttpRequestDef SmnMeta::genRequestDefForListSubscriptionsByTopic() { reqDefBuilder.withRequestField(FieldDef().withName("Limit") .withJsonTag("limit") .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("FuzzyRemark") + .withJsonTag("fuzzy_remark") + .withLocationType(Query_)); return reqDefBuilder; } @@ -207,6 +249,9 @@ HttpRequestDef SmnMeta::genRequestDefForListTopics() { reqDefBuilder.withRequestField(FieldDef().withName("TopicId") .withJsonTag("topic_id") .withLocationType(Query_)); + reqDefBuilder.withRequestField(FieldDef().withName("FuzzyDisplayName") + .withJsonTag("fuzzy_display_name") + .withLocationType(Query_)); return reqDefBuilder; } @@ -220,6 +265,15 @@ HttpRequestDef SmnMeta::genRequestDefForListVersions() { return reqDefBuilder; } +HttpRequestDef SmnMeta::genRequestDefForPublishHttpDetect() { + HttpRequestDef reqDefBuilder; + FieldDef bodyParam; + reqDefBuilder.withRequestField(bodyParam. + withName("Body"). + withLocationType(Body_)); + return reqDefBuilder; +} + HttpRequestDef SmnMeta::genRequestDefForPublishMessage() { HttpRequestDef reqDefBuilder; FieldDef bodyParam; @@ -229,6 +283,11 @@ HttpRequestDef SmnMeta::genRequestDefForPublishMessage() { return reqDefBuilder; } +HttpRequestDef SmnMeta::genRequestDefForShowHttpDetectResult() { + HttpRequestDef reqDefBuilder; + return reqDefBuilder; +} + HttpRequestDef SmnMeta::genRequestDefForUpdateLogtank() { HttpRequestDef reqDefBuilder; FieldDef bodyParam; diff --git a/smn/src/v2/model/AddSubscriptionFromSubscriptionUserRequest.cpp b/smn/src/v2/model/AddSubscriptionFromSubscriptionUserRequest.cpp new file mode 100644 index 000000000..e4c3fd186 --- /dev/null +++ b/smn/src/v2/model/AddSubscriptionFromSubscriptionUserRequest.cpp @@ -0,0 +1,113 @@ + + +#include "huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +AddSubscriptionFromSubscriptionUserRequest::AddSubscriptionFromSubscriptionUserRequest() +{ + topicUrn_ = ""; + topicUrnIsSet_ = false; + bodyIsSet_ = false; +} + +AddSubscriptionFromSubscriptionUserRequest::~AddSubscriptionFromSubscriptionUserRequest() = default; + +void AddSubscriptionFromSubscriptionUserRequest::validate() +{ +} + +web::json::value AddSubscriptionFromSubscriptionUserRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(topicUrnIsSet_) { + val[utility::conversions::to_string_t("topic_urn")] = ModelBase::toJson(topicUrn_); + } + if(bodyIsSet_) { + val[utility::conversions::to_string_t("body")] = ModelBase::toJson(body_); + } + + return val; +} +bool AddSubscriptionFromSubscriptionUserRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("topic_urn"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("topic_urn")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTopicUrn(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()) + { + AddSubscriptionFromSubscriptionUserRequestBody refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBody(refVal); + } + } + return ok; +} + + +std::string AddSubscriptionFromSubscriptionUserRequest::getTopicUrn() const +{ + return topicUrn_; +} + +void AddSubscriptionFromSubscriptionUserRequest::setTopicUrn(const std::string& value) +{ + topicUrn_ = value; + topicUrnIsSet_ = true; +} + +bool AddSubscriptionFromSubscriptionUserRequest::topicUrnIsSet() const +{ + return topicUrnIsSet_; +} + +void AddSubscriptionFromSubscriptionUserRequest::unsettopicUrn() +{ + topicUrnIsSet_ = false; +} + +AddSubscriptionFromSubscriptionUserRequestBody AddSubscriptionFromSubscriptionUserRequest::getBody() const +{ + return body_; +} + +void AddSubscriptionFromSubscriptionUserRequest::setBody(const AddSubscriptionFromSubscriptionUserRequestBody& value) +{ + body_ = value; + bodyIsSet_ = true; +} + +bool AddSubscriptionFromSubscriptionUserRequest::bodyIsSet() const +{ + return bodyIsSet_; +} + +void AddSubscriptionFromSubscriptionUserRequest::unsetbody() +{ + bodyIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/AddSubscriptionFromSubscriptionUserRequestBody.cpp b/smn/src/v2/model/AddSubscriptionFromSubscriptionUserRequestBody.cpp new file mode 100644 index 000000000..cca282ca6 --- /dev/null +++ b/smn/src/v2/model/AddSubscriptionFromSubscriptionUserRequestBody.cpp @@ -0,0 +1,78 @@ + + +#include "huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserRequestBody.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +AddSubscriptionFromSubscriptionUserRequestBody::AddSubscriptionFromSubscriptionUserRequestBody() +{ + idsIsSet_ = false; +} + +AddSubscriptionFromSubscriptionUserRequestBody::~AddSubscriptionFromSubscriptionUserRequestBody() = default; + +void AddSubscriptionFromSubscriptionUserRequestBody::validate() +{ +} + +web::json::value AddSubscriptionFromSubscriptionUserRequestBody::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(idsIsSet_) { + val[utility::conversions::to_string_t("ids")] = ModelBase::toJson(ids_); + } + + return val; +} +bool AddSubscriptionFromSubscriptionUserRequestBody::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("ids"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("ids")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setIds(refVal); + } + } + return ok; +} + + +std::vector& AddSubscriptionFromSubscriptionUserRequestBody::getIds() +{ + return ids_; +} + +void AddSubscriptionFromSubscriptionUserRequestBody::setIds(const std::vector& value) +{ + ids_ = value; + idsIsSet_ = true; +} + +bool AddSubscriptionFromSubscriptionUserRequestBody::idsIsSet() const +{ + return idsIsSet_; +} + +void AddSubscriptionFromSubscriptionUserRequestBody::unsetids() +{ + idsIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/AddSubscriptionFromSubscriptionUserResponse.cpp b/smn/src/v2/model/AddSubscriptionFromSubscriptionUserResponse.cpp new file mode 100644 index 000000000..6ffac059e --- /dev/null +++ b/smn/src/v2/model/AddSubscriptionFromSubscriptionUserResponse.cpp @@ -0,0 +1,78 @@ + + +#include "huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +AddSubscriptionFromSubscriptionUserResponse::AddSubscriptionFromSubscriptionUserResponse() +{ + subscriptionsResultIsSet_ = false; +} + +AddSubscriptionFromSubscriptionUserResponse::~AddSubscriptionFromSubscriptionUserResponse() = default; + +void AddSubscriptionFromSubscriptionUserResponse::validate() +{ +} + +web::json::value AddSubscriptionFromSubscriptionUserResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(subscriptionsResultIsSet_) { + val[utility::conversions::to_string_t("subscriptions_result")] = ModelBase::toJson(subscriptionsResult_); + } + + return val; +} +bool AddSubscriptionFromSubscriptionUserResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("subscriptions_result"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("subscriptions_result")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setSubscriptionsResult(refVal); + } + } + return ok; +} + + +std::vector& AddSubscriptionFromSubscriptionUserResponse::getSubscriptionsResult() +{ + return subscriptionsResult_; +} + +void AddSubscriptionFromSubscriptionUserResponse::setSubscriptionsResult(const std::vector& value) +{ + subscriptionsResult_ = value; + subscriptionsResultIsSet_ = true; +} + +bool AddSubscriptionFromSubscriptionUserResponse::subscriptionsResultIsSet() const +{ + return subscriptionsResultIsSet_; +} + +void AddSubscriptionFromSubscriptionUserResponse::unsetsubscriptionsResult() +{ + subscriptionsResultIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/AddSubscriptionFromSubscriptionUserResponseItem.cpp b/smn/src/v2/model/AddSubscriptionFromSubscriptionUserResponseItem.cpp new file mode 100644 index 000000000..9db391b84 --- /dev/null +++ b/smn/src/v2/model/AddSubscriptionFromSubscriptionUserResponseItem.cpp @@ -0,0 +1,219 @@ + + +#include "huaweicloud/smn/v2/model/AddSubscriptionFromSubscriptionUserResponseItem.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +AddSubscriptionFromSubscriptionUserResponseItem::AddSubscriptionFromSubscriptionUserResponseItem() +{ + httpCode_ = 0; + httpCodeIsSet_ = false; + requestId_ = ""; + requestIdIsSet_ = false; + subscriptionUrn_ = ""; + subscriptionUrnIsSet_ = false; + errorCode_ = ""; + errorCodeIsSet_ = false; + errorMsg_ = ""; + errorMsgIsSet_ = false; +} + +AddSubscriptionFromSubscriptionUserResponseItem::~AddSubscriptionFromSubscriptionUserResponseItem() = default; + +void AddSubscriptionFromSubscriptionUserResponseItem::validate() +{ +} + +web::json::value AddSubscriptionFromSubscriptionUserResponseItem::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(httpCodeIsSet_) { + val[utility::conversions::to_string_t("http_code")] = ModelBase::toJson(httpCode_); + } + if(requestIdIsSet_) { + val[utility::conversions::to_string_t("request_id")] = ModelBase::toJson(requestId_); + } + if(subscriptionUrnIsSet_) { + val[utility::conversions::to_string_t("subscription_urn")] = ModelBase::toJson(subscriptionUrn_); + } + if(errorCodeIsSet_) { + val[utility::conversions::to_string_t("error_code")] = ModelBase::toJson(errorCode_); + } + if(errorMsgIsSet_) { + val[utility::conversions::to_string_t("error_msg")] = ModelBase::toJson(errorMsg_); + } + + return val; +} +bool AddSubscriptionFromSubscriptionUserResponseItem::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("http_code"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("http_code")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setHttpCode(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("request_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("request_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setRequestId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("subscription_urn"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("subscription_urn")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setSubscriptionUrn(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("error_code"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("error_code")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setErrorCode(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("error_msg"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("error_msg")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setErrorMsg(refVal); + } + } + return ok; +} + + +int32_t AddSubscriptionFromSubscriptionUserResponseItem::getHttpCode() const +{ + return httpCode_; +} + +void AddSubscriptionFromSubscriptionUserResponseItem::setHttpCode(int32_t value) +{ + httpCode_ = value; + httpCodeIsSet_ = true; +} + +bool AddSubscriptionFromSubscriptionUserResponseItem::httpCodeIsSet() const +{ + return httpCodeIsSet_; +} + +void AddSubscriptionFromSubscriptionUserResponseItem::unsethttpCode() +{ + httpCodeIsSet_ = false; +} + +std::string AddSubscriptionFromSubscriptionUserResponseItem::getRequestId() const +{ + return requestId_; +} + +void AddSubscriptionFromSubscriptionUserResponseItem::setRequestId(const std::string& value) +{ + requestId_ = value; + requestIdIsSet_ = true; +} + +bool AddSubscriptionFromSubscriptionUserResponseItem::requestIdIsSet() const +{ + return requestIdIsSet_; +} + +void AddSubscriptionFromSubscriptionUserResponseItem::unsetrequestId() +{ + requestIdIsSet_ = false; +} + +std::string AddSubscriptionFromSubscriptionUserResponseItem::getSubscriptionUrn() const +{ + return subscriptionUrn_; +} + +void AddSubscriptionFromSubscriptionUserResponseItem::setSubscriptionUrn(const std::string& value) +{ + subscriptionUrn_ = value; + subscriptionUrnIsSet_ = true; +} + +bool AddSubscriptionFromSubscriptionUserResponseItem::subscriptionUrnIsSet() const +{ + return subscriptionUrnIsSet_; +} + +void AddSubscriptionFromSubscriptionUserResponseItem::unsetsubscriptionUrn() +{ + subscriptionUrnIsSet_ = false; +} + +std::string AddSubscriptionFromSubscriptionUserResponseItem::getErrorCode() const +{ + return errorCode_; +} + +void AddSubscriptionFromSubscriptionUserResponseItem::setErrorCode(const std::string& value) +{ + errorCode_ = value; + errorCodeIsSet_ = true; +} + +bool AddSubscriptionFromSubscriptionUserResponseItem::errorCodeIsSet() const +{ + return errorCodeIsSet_; +} + +void AddSubscriptionFromSubscriptionUserResponseItem::unseterrorCode() +{ + errorCodeIsSet_ = false; +} + +std::string AddSubscriptionFromSubscriptionUserResponseItem::getErrorMsg() const +{ + return errorMsg_; +} + +void AddSubscriptionFromSubscriptionUserResponseItem::setErrorMsg(const std::string& value) +{ + errorMsg_ = value; + errorMsgIsSet_ = true; +} + +bool AddSubscriptionFromSubscriptionUserResponseItem::errorMsgIsSet() const +{ + return errorMsgIsSet_; +} + +void AddSubscriptionFromSubscriptionUserResponseItem::unseterrorMsg() +{ + errorMsgIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/BatchCreateSubscriptionsFilterPolicesRequest.cpp b/smn/src/v2/model/BatchCreateSubscriptionsFilterPolicesRequest.cpp new file mode 100644 index 000000000..f25f481b1 --- /dev/null +++ b/smn/src/v2/model/BatchCreateSubscriptionsFilterPolicesRequest.cpp @@ -0,0 +1,78 @@ + + +#include "huaweicloud/smn/v2/model/BatchCreateSubscriptionsFilterPolicesRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +BatchCreateSubscriptionsFilterPolicesRequest::BatchCreateSubscriptionsFilterPolicesRequest() +{ + bodyIsSet_ = false; +} + +BatchCreateSubscriptionsFilterPolicesRequest::~BatchCreateSubscriptionsFilterPolicesRequest() = default; + +void BatchCreateSubscriptionsFilterPolicesRequest::validate() +{ +} + +web::json::value BatchCreateSubscriptionsFilterPolicesRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(bodyIsSet_) { + val[utility::conversions::to_string_t("body")] = ModelBase::toJson(body_); + } + + return val; +} +bool BatchCreateSubscriptionsFilterPolicesRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + 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()) + { + BatchSubscriptionsFilterPolicesRequestBody refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBody(refVal); + } + } + return ok; +} + + +BatchSubscriptionsFilterPolicesRequestBody BatchCreateSubscriptionsFilterPolicesRequest::getBody() const +{ + return body_; +} + +void BatchCreateSubscriptionsFilterPolicesRequest::setBody(const BatchSubscriptionsFilterPolicesRequestBody& value) +{ + body_ = value; + bodyIsSet_ = true; +} + +bool BatchCreateSubscriptionsFilterPolicesRequest::bodyIsSet() const +{ + return bodyIsSet_; +} + +void BatchCreateSubscriptionsFilterPolicesRequest::unsetbody() +{ + bodyIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/BatchCreateSubscriptionsFilterPolicesResponse.cpp b/smn/src/v2/model/BatchCreateSubscriptionsFilterPolicesResponse.cpp new file mode 100644 index 000000000..bfaee53c9 --- /dev/null +++ b/smn/src/v2/model/BatchCreateSubscriptionsFilterPolicesResponse.cpp @@ -0,0 +1,113 @@ + + +#include "huaweicloud/smn/v2/model/BatchCreateSubscriptionsFilterPolicesResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +BatchCreateSubscriptionsFilterPolicesResponse::BatchCreateSubscriptionsFilterPolicesResponse() +{ + requestId_ = ""; + requestIdIsSet_ = false; + batchResultIsSet_ = false; +} + +BatchCreateSubscriptionsFilterPolicesResponse::~BatchCreateSubscriptionsFilterPolicesResponse() = default; + +void BatchCreateSubscriptionsFilterPolicesResponse::validate() +{ +} + +web::json::value BatchCreateSubscriptionsFilterPolicesResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(requestIdIsSet_) { + val[utility::conversions::to_string_t("request_id")] = ModelBase::toJson(requestId_); + } + if(batchResultIsSet_) { + val[utility::conversions::to_string_t("batch_result")] = ModelBase::toJson(batchResult_); + } + + return val; +} +bool BatchCreateSubscriptionsFilterPolicesResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("request_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("request_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setRequestId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("batch_result"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("batch_result")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBatchResult(refVal); + } + } + return ok; +} + + +std::string BatchCreateSubscriptionsFilterPolicesResponse::getRequestId() const +{ + return requestId_; +} + +void BatchCreateSubscriptionsFilterPolicesResponse::setRequestId(const std::string& value) +{ + requestId_ = value; + requestIdIsSet_ = true; +} + +bool BatchCreateSubscriptionsFilterPolicesResponse::requestIdIsSet() const +{ + return requestIdIsSet_; +} + +void BatchCreateSubscriptionsFilterPolicesResponse::unsetrequestId() +{ + requestIdIsSet_ = false; +} + +std::vector& BatchCreateSubscriptionsFilterPolicesResponse::getBatchResult() +{ + return batchResult_; +} + +void BatchCreateSubscriptionsFilterPolicesResponse::setBatchResult(const std::vector& value) +{ + batchResult_ = value; + batchResultIsSet_ = true; +} + +bool BatchCreateSubscriptionsFilterPolicesResponse::batchResultIsSet() const +{ + return batchResultIsSet_; +} + +void BatchCreateSubscriptionsFilterPolicesResponse::unsetbatchResult() +{ + batchResultIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesRequest.cpp b/smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesRequest.cpp new file mode 100644 index 000000000..75d3df13c --- /dev/null +++ b/smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesRequest.cpp @@ -0,0 +1,78 @@ + + +#include "huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +BatchDeleteSubscriptionsFilterPolicesRequest::BatchDeleteSubscriptionsFilterPolicesRequest() +{ + bodyIsSet_ = false; +} + +BatchDeleteSubscriptionsFilterPolicesRequest::~BatchDeleteSubscriptionsFilterPolicesRequest() = default; + +void BatchDeleteSubscriptionsFilterPolicesRequest::validate() +{ +} + +web::json::value BatchDeleteSubscriptionsFilterPolicesRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(bodyIsSet_) { + val[utility::conversions::to_string_t("body")] = ModelBase::toJson(body_); + } + + return val; +} +bool BatchDeleteSubscriptionsFilterPolicesRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + 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()) + { + BatchDeleteSubscriptionsFilterPolicesRequestBody refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBody(refVal); + } + } + return ok; +} + + +BatchDeleteSubscriptionsFilterPolicesRequestBody BatchDeleteSubscriptionsFilterPolicesRequest::getBody() const +{ + return body_; +} + +void BatchDeleteSubscriptionsFilterPolicesRequest::setBody(const BatchDeleteSubscriptionsFilterPolicesRequestBody& value) +{ + body_ = value; + bodyIsSet_ = true; +} + +bool BatchDeleteSubscriptionsFilterPolicesRequest::bodyIsSet() const +{ + return bodyIsSet_; +} + +void BatchDeleteSubscriptionsFilterPolicesRequest::unsetbody() +{ + bodyIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesRequestBody.cpp b/smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesRequestBody.cpp new file mode 100644 index 000000000..d04040e76 --- /dev/null +++ b/smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesRequestBody.cpp @@ -0,0 +1,78 @@ + + +#include "huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesRequestBody.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +BatchDeleteSubscriptionsFilterPolicesRequestBody::BatchDeleteSubscriptionsFilterPolicesRequestBody() +{ + subscriptionUrnsIsSet_ = false; +} + +BatchDeleteSubscriptionsFilterPolicesRequestBody::~BatchDeleteSubscriptionsFilterPolicesRequestBody() = default; + +void BatchDeleteSubscriptionsFilterPolicesRequestBody::validate() +{ +} + +web::json::value BatchDeleteSubscriptionsFilterPolicesRequestBody::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(subscriptionUrnsIsSet_) { + val[utility::conversions::to_string_t("subscription_urns")] = ModelBase::toJson(subscriptionUrns_); + } + + return val; +} +bool BatchDeleteSubscriptionsFilterPolicesRequestBody::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("subscription_urns"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("subscription_urns")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setSubscriptionUrns(refVal); + } + } + return ok; +} + + +std::vector& BatchDeleteSubscriptionsFilterPolicesRequestBody::getSubscriptionUrns() +{ + return subscriptionUrns_; +} + +void BatchDeleteSubscriptionsFilterPolicesRequestBody::setSubscriptionUrns(const std::vector& value) +{ + subscriptionUrns_ = value; + subscriptionUrnsIsSet_ = true; +} + +bool BatchDeleteSubscriptionsFilterPolicesRequestBody::subscriptionUrnsIsSet() const +{ + return subscriptionUrnsIsSet_; +} + +void BatchDeleteSubscriptionsFilterPolicesRequestBody::unsetsubscriptionUrns() +{ + subscriptionUrnsIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesResponse.cpp b/smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesResponse.cpp new file mode 100644 index 000000000..07cf4c8c1 --- /dev/null +++ b/smn/src/v2/model/BatchDeleteSubscriptionsFilterPolicesResponse.cpp @@ -0,0 +1,113 @@ + + +#include "huaweicloud/smn/v2/model/BatchDeleteSubscriptionsFilterPolicesResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +BatchDeleteSubscriptionsFilterPolicesResponse::BatchDeleteSubscriptionsFilterPolicesResponse() +{ + requestId_ = ""; + requestIdIsSet_ = false; + batchResultIsSet_ = false; +} + +BatchDeleteSubscriptionsFilterPolicesResponse::~BatchDeleteSubscriptionsFilterPolicesResponse() = default; + +void BatchDeleteSubscriptionsFilterPolicesResponse::validate() +{ +} + +web::json::value BatchDeleteSubscriptionsFilterPolicesResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(requestIdIsSet_) { + val[utility::conversions::to_string_t("request_id")] = ModelBase::toJson(requestId_); + } + if(batchResultIsSet_) { + val[utility::conversions::to_string_t("batch_result")] = ModelBase::toJson(batchResult_); + } + + return val; +} +bool BatchDeleteSubscriptionsFilterPolicesResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("request_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("request_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setRequestId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("batch_result"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("batch_result")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBatchResult(refVal); + } + } + return ok; +} + + +std::string BatchDeleteSubscriptionsFilterPolicesResponse::getRequestId() const +{ + return requestId_; +} + +void BatchDeleteSubscriptionsFilterPolicesResponse::setRequestId(const std::string& value) +{ + requestId_ = value; + requestIdIsSet_ = true; +} + +bool BatchDeleteSubscriptionsFilterPolicesResponse::requestIdIsSet() const +{ + return requestIdIsSet_; +} + +void BatchDeleteSubscriptionsFilterPolicesResponse::unsetrequestId() +{ + requestIdIsSet_ = false; +} + +std::vector& BatchDeleteSubscriptionsFilterPolicesResponse::getBatchResult() +{ + return batchResult_; +} + +void BatchDeleteSubscriptionsFilterPolicesResponse::setBatchResult(const std::vector& value) +{ + batchResult_ = value; + batchResultIsSet_ = true; +} + +bool BatchDeleteSubscriptionsFilterPolicesResponse::batchResultIsSet() const +{ + return batchResultIsSet_; +} + +void BatchDeleteSubscriptionsFilterPolicesResponse::unsetbatchResult() +{ + batchResultIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/BatchResult.cpp b/smn/src/v2/model/BatchResult.cpp new file mode 100644 index 000000000..e679738ef --- /dev/null +++ b/smn/src/v2/model/BatchResult.cpp @@ -0,0 +1,149 @@ + + +#include "huaweicloud/smn/v2/model/BatchResult.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +BatchResult::BatchResult() +{ + code_ = ""; + codeIsSet_ = false; + message_ = ""; + messageIsSet_ = false; + subscriptionUrn_ = ""; + subscriptionUrnIsSet_ = false; +} + +BatchResult::~BatchResult() = default; + +void BatchResult::validate() +{ +} + +web::json::value BatchResult::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(codeIsSet_) { + val[utility::conversions::to_string_t("code")] = ModelBase::toJson(code_); + } + if(messageIsSet_) { + val[utility::conversions::to_string_t("message")] = ModelBase::toJson(message_); + } + if(subscriptionUrnIsSet_) { + val[utility::conversions::to_string_t("subscription_urn")] = ModelBase::toJson(subscriptionUrn_); + } + + return val; +} +bool BatchResult::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("code"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("code")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setCode(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("message"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("message")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setMessage(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("subscription_urn"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("subscription_urn")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setSubscriptionUrn(refVal); + } + } + return ok; +} + + +std::string BatchResult::getCode() const +{ + return code_; +} + +void BatchResult::setCode(const std::string& value) +{ + code_ = value; + codeIsSet_ = true; +} + +bool BatchResult::codeIsSet() const +{ + return codeIsSet_; +} + +void BatchResult::unsetcode() +{ + codeIsSet_ = false; +} + +std::string BatchResult::getMessage() const +{ + return message_; +} + +void BatchResult::setMessage(const std::string& value) +{ + message_ = value; + messageIsSet_ = true; +} + +bool BatchResult::messageIsSet() const +{ + return messageIsSet_; +} + +void BatchResult::unsetmessage() +{ + messageIsSet_ = false; +} + +std::string BatchResult::getSubscriptionUrn() const +{ + return subscriptionUrn_; +} + +void BatchResult::setSubscriptionUrn(const std::string& value) +{ + subscriptionUrn_ = value; + subscriptionUrnIsSet_ = true; +} + +bool BatchResult::subscriptionUrnIsSet() const +{ + return subscriptionUrnIsSet_; +} + +void BatchResult::unsetsubscriptionUrn() +{ + subscriptionUrnIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/BatchSubscriptionsFilterPolicesRequestBody.cpp b/smn/src/v2/model/BatchSubscriptionsFilterPolicesRequestBody.cpp new file mode 100644 index 000000000..85ccc2ba5 --- /dev/null +++ b/smn/src/v2/model/BatchSubscriptionsFilterPolicesRequestBody.cpp @@ -0,0 +1,78 @@ + + +#include "huaweicloud/smn/v2/model/BatchSubscriptionsFilterPolicesRequestBody.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +BatchSubscriptionsFilterPolicesRequestBody::BatchSubscriptionsFilterPolicesRequestBody() +{ + policesIsSet_ = false; +} + +BatchSubscriptionsFilterPolicesRequestBody::~BatchSubscriptionsFilterPolicesRequestBody() = default; + +void BatchSubscriptionsFilterPolicesRequestBody::validate() +{ +} + +web::json::value BatchSubscriptionsFilterPolicesRequestBody::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(policesIsSet_) { + val[utility::conversions::to_string_t("polices")] = ModelBase::toJson(polices_); + } + + return val; +} +bool BatchSubscriptionsFilterPolicesRequestBody::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("polices"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("polices")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setPolices(refVal); + } + } + return ok; +} + + +std::vector& BatchSubscriptionsFilterPolicesRequestBody::getPolices() +{ + return polices_; +} + +void BatchSubscriptionsFilterPolicesRequestBody::setPolices(const std::vector& value) +{ + polices_ = value; + policesIsSet_ = true; +} + +bool BatchSubscriptionsFilterPolicesRequestBody::policesIsSet() const +{ + return policesIsSet_; +} + +void BatchSubscriptionsFilterPolicesRequestBody::unsetpolices() +{ + policesIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/BatchSubscriptionsFilterPolicesRequestBody_polices.cpp b/smn/src/v2/model/BatchSubscriptionsFilterPolicesRequestBody_polices.cpp new file mode 100644 index 000000000..04036105e --- /dev/null +++ b/smn/src/v2/model/BatchSubscriptionsFilterPolicesRequestBody_polices.cpp @@ -0,0 +1,113 @@ + + +#include "huaweicloud/smn/v2/model/BatchSubscriptionsFilterPolicesRequestBody_polices.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +BatchSubscriptionsFilterPolicesRequestBody_polices::BatchSubscriptionsFilterPolicesRequestBody_polices() +{ + subscriptionUrn_ = ""; + subscriptionUrnIsSet_ = false; + filterPolicesIsSet_ = false; +} + +BatchSubscriptionsFilterPolicesRequestBody_polices::~BatchSubscriptionsFilterPolicesRequestBody_polices() = default; + +void BatchSubscriptionsFilterPolicesRequestBody_polices::validate() +{ +} + +web::json::value BatchSubscriptionsFilterPolicesRequestBody_polices::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(subscriptionUrnIsSet_) { + val[utility::conversions::to_string_t("subscription_urn")] = ModelBase::toJson(subscriptionUrn_); + } + if(filterPolicesIsSet_) { + val[utility::conversions::to_string_t("filter_polices")] = ModelBase::toJson(filterPolices_); + } + + return val; +} +bool BatchSubscriptionsFilterPolicesRequestBody_polices::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("subscription_urn"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("subscription_urn")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setSubscriptionUrn(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("filter_polices"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("filter_polices")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setFilterPolices(refVal); + } + } + return ok; +} + + +std::string BatchSubscriptionsFilterPolicesRequestBody_polices::getSubscriptionUrn() const +{ + return subscriptionUrn_; +} + +void BatchSubscriptionsFilterPolicesRequestBody_polices::setSubscriptionUrn(const std::string& value) +{ + subscriptionUrn_ = value; + subscriptionUrnIsSet_ = true; +} + +bool BatchSubscriptionsFilterPolicesRequestBody_polices::subscriptionUrnIsSet() const +{ + return subscriptionUrnIsSet_; +} + +void BatchSubscriptionsFilterPolicesRequestBody_polices::unsetsubscriptionUrn() +{ + subscriptionUrnIsSet_ = false; +} + +std::vector& BatchSubscriptionsFilterPolicesRequestBody_polices::getFilterPolices() +{ + return filterPolices_; +} + +void BatchSubscriptionsFilterPolicesRequestBody_polices::setFilterPolices(const std::vector& value) +{ + filterPolices_ = value; + filterPolicesIsSet_ = true; +} + +bool BatchSubscriptionsFilterPolicesRequestBody_polices::filterPolicesIsSet() const +{ + return filterPolicesIsSet_; +} + +void BatchSubscriptionsFilterPolicesRequestBody_polices::unsetfilterPolices() +{ + filterPolicesIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/BatchUpdateSubscriptionsFilterPolicesRequest.cpp b/smn/src/v2/model/BatchUpdateSubscriptionsFilterPolicesRequest.cpp new file mode 100644 index 000000000..a6f95de41 --- /dev/null +++ b/smn/src/v2/model/BatchUpdateSubscriptionsFilterPolicesRequest.cpp @@ -0,0 +1,78 @@ + + +#include "huaweicloud/smn/v2/model/BatchUpdateSubscriptionsFilterPolicesRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +BatchUpdateSubscriptionsFilterPolicesRequest::BatchUpdateSubscriptionsFilterPolicesRequest() +{ + bodyIsSet_ = false; +} + +BatchUpdateSubscriptionsFilterPolicesRequest::~BatchUpdateSubscriptionsFilterPolicesRequest() = default; + +void BatchUpdateSubscriptionsFilterPolicesRequest::validate() +{ +} + +web::json::value BatchUpdateSubscriptionsFilterPolicesRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(bodyIsSet_) { + val[utility::conversions::to_string_t("body")] = ModelBase::toJson(body_); + } + + return val; +} +bool BatchUpdateSubscriptionsFilterPolicesRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + 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()) + { + BatchSubscriptionsFilterPolicesRequestBody refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBody(refVal); + } + } + return ok; +} + + +BatchSubscriptionsFilterPolicesRequestBody BatchUpdateSubscriptionsFilterPolicesRequest::getBody() const +{ + return body_; +} + +void BatchUpdateSubscriptionsFilterPolicesRequest::setBody(const BatchSubscriptionsFilterPolicesRequestBody& value) +{ + body_ = value; + bodyIsSet_ = true; +} + +bool BatchUpdateSubscriptionsFilterPolicesRequest::bodyIsSet() const +{ + return bodyIsSet_; +} + +void BatchUpdateSubscriptionsFilterPolicesRequest::unsetbody() +{ + bodyIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/BatchUpdateSubscriptionsFilterPolicesResponse.cpp b/smn/src/v2/model/BatchUpdateSubscriptionsFilterPolicesResponse.cpp new file mode 100644 index 000000000..415e90a12 --- /dev/null +++ b/smn/src/v2/model/BatchUpdateSubscriptionsFilterPolicesResponse.cpp @@ -0,0 +1,113 @@ + + +#include "huaweicloud/smn/v2/model/BatchUpdateSubscriptionsFilterPolicesResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +BatchUpdateSubscriptionsFilterPolicesResponse::BatchUpdateSubscriptionsFilterPolicesResponse() +{ + requestId_ = ""; + requestIdIsSet_ = false; + batchResultIsSet_ = false; +} + +BatchUpdateSubscriptionsFilterPolicesResponse::~BatchUpdateSubscriptionsFilterPolicesResponse() = default; + +void BatchUpdateSubscriptionsFilterPolicesResponse::validate() +{ +} + +web::json::value BatchUpdateSubscriptionsFilterPolicesResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(requestIdIsSet_) { + val[utility::conversions::to_string_t("request_id")] = ModelBase::toJson(requestId_); + } + if(batchResultIsSet_) { + val[utility::conversions::to_string_t("batch_result")] = ModelBase::toJson(batchResult_); + } + + return val; +} +bool BatchUpdateSubscriptionsFilterPolicesResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("request_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("request_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setRequestId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("batch_result"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("batch_result")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBatchResult(refVal); + } + } + return ok; +} + + +std::string BatchUpdateSubscriptionsFilterPolicesResponse::getRequestId() const +{ + return requestId_; +} + +void BatchUpdateSubscriptionsFilterPolicesResponse::setRequestId(const std::string& value) +{ + requestId_ = value; + requestIdIsSet_ = true; +} + +bool BatchUpdateSubscriptionsFilterPolicesResponse::requestIdIsSet() const +{ + return requestIdIsSet_; +} + +void BatchUpdateSubscriptionsFilterPolicesResponse::unsetrequestId() +{ + requestIdIsSet_ = false; +} + +std::vector& BatchUpdateSubscriptionsFilterPolicesResponse::getBatchResult() +{ + return batchResult_; +} + +void BatchUpdateSubscriptionsFilterPolicesResponse::setBatchResult(const std::vector& value) +{ + batchResult_ = value; + batchResultIsSet_ = true; +} + +bool BatchUpdateSubscriptionsFilterPolicesResponse::batchResultIsSet() const +{ + return batchResultIsSet_; +} + +void BatchUpdateSubscriptionsFilterPolicesResponse::unsetbatchResult() +{ + batchResultIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/GetHttpDetectResponseBody_detail.cpp b/smn/src/v2/model/GetHttpDetectResponseBody_detail.cpp new file mode 100644 index 000000000..01571e614 --- /dev/null +++ b/smn/src/v2/model/GetHttpDetectResponseBody_detail.cpp @@ -0,0 +1,114 @@ + + +#include "huaweicloud/smn/v2/model/GetHttpDetectResponseBody_detail.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +GetHttpDetectResponseBody_detail::GetHttpDetectResponseBody_detail() +{ + httpCode_ = 0; + httpCodeIsSet_ = false; + httpResponse_ = ""; + httpResponseIsSet_ = false; +} + +GetHttpDetectResponseBody_detail::~GetHttpDetectResponseBody_detail() = default; + +void GetHttpDetectResponseBody_detail::validate() +{ +} + +web::json::value GetHttpDetectResponseBody_detail::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(httpCodeIsSet_) { + val[utility::conversions::to_string_t("httpCode")] = ModelBase::toJson(httpCode_); + } + if(httpResponseIsSet_) { + val[utility::conversions::to_string_t("httpResponse")] = ModelBase::toJson(httpResponse_); + } + + return val; +} +bool GetHttpDetectResponseBody_detail::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("httpCode"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("httpCode")); + if(!fieldValue.is_null()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setHttpCode(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("httpResponse"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("httpResponse")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setHttpResponse(refVal); + } + } + return ok; +} + + +int32_t GetHttpDetectResponseBody_detail::getHttpCode() const +{ + return httpCode_; +} + +void GetHttpDetectResponseBody_detail::setHttpCode(int32_t value) +{ + httpCode_ = value; + httpCodeIsSet_ = true; +} + +bool GetHttpDetectResponseBody_detail::httpCodeIsSet() const +{ + return httpCodeIsSet_; +} + +void GetHttpDetectResponseBody_detail::unsethttpCode() +{ + httpCodeIsSet_ = false; +} + +std::string GetHttpDetectResponseBody_detail::getHttpResponse() const +{ + return httpResponse_; +} + +void GetHttpDetectResponseBody_detail::setHttpResponse(const std::string& value) +{ + httpResponse_ = value; + httpResponseIsSet_ = true; +} + +bool GetHttpDetectResponseBody_detail::httpResponseIsSet() const +{ + return httpResponseIsSet_; +} + +void GetHttpDetectResponseBody_detail::unsethttpResponse() +{ + httpResponseIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/HttpDetectRequestBody.cpp b/smn/src/v2/model/HttpDetectRequestBody.cpp new file mode 100644 index 000000000..7824ab81f --- /dev/null +++ b/smn/src/v2/model/HttpDetectRequestBody.cpp @@ -0,0 +1,148 @@ + + +#include "huaweicloud/smn/v2/model/HttpDetectRequestBody.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +HttpDetectRequestBody::HttpDetectRequestBody() +{ + protocol_ = ""; + protocolIsSet_ = false; + endpoint_ = ""; + endpointIsSet_ = false; + extensionIsSet_ = false; +} + +HttpDetectRequestBody::~HttpDetectRequestBody() = default; + +void HttpDetectRequestBody::validate() +{ +} + +web::json::value HttpDetectRequestBody::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(protocolIsSet_) { + val[utility::conversions::to_string_t("protocol")] = ModelBase::toJson(protocol_); + } + if(endpointIsSet_) { + val[utility::conversions::to_string_t("endpoint")] = ModelBase::toJson(endpoint_); + } + if(extensionIsSet_) { + val[utility::conversions::to_string_t("extension")] = ModelBase::toJson(extension_); + } + + return val; +} +bool HttpDetectRequestBody::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("protocol"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("protocol")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setProtocol(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("endpoint"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("endpoint")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setEndpoint(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("extension"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("extension")); + if(!fieldValue.is_null()) + { + HttpDetectRequestBody_extension refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setExtension(refVal); + } + } + return ok; +} + + +std::string HttpDetectRequestBody::getProtocol() const +{ + return protocol_; +} + +void HttpDetectRequestBody::setProtocol(const std::string& value) +{ + protocol_ = value; + protocolIsSet_ = true; +} + +bool HttpDetectRequestBody::protocolIsSet() const +{ + return protocolIsSet_; +} + +void HttpDetectRequestBody::unsetprotocol() +{ + protocolIsSet_ = false; +} + +std::string HttpDetectRequestBody::getEndpoint() const +{ + return endpoint_; +} + +void HttpDetectRequestBody::setEndpoint(const std::string& value) +{ + endpoint_ = value; + endpointIsSet_ = true; +} + +bool HttpDetectRequestBody::endpointIsSet() const +{ + return endpointIsSet_; +} + +void HttpDetectRequestBody::unsetendpoint() +{ + endpointIsSet_ = false; +} + +HttpDetectRequestBody_extension HttpDetectRequestBody::getExtension() const +{ + return extension_; +} + +void HttpDetectRequestBody::setExtension(const HttpDetectRequestBody_extension& value) +{ + extension_ = value; + extensionIsSet_ = true; +} + +bool HttpDetectRequestBody::extensionIsSet() const +{ + return extensionIsSet_; +} + +void HttpDetectRequestBody::unsetextension() +{ + extensionIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/HttpDetectRequestBody_extension.cpp b/smn/src/v2/model/HttpDetectRequestBody_extension.cpp new file mode 100644 index 000000000..22fe1ca05 --- /dev/null +++ b/smn/src/v2/model/HttpDetectRequestBody_extension.cpp @@ -0,0 +1,78 @@ + + +#include "huaweicloud/smn/v2/model/HttpDetectRequestBody_extension.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +HttpDetectRequestBody_extension::HttpDetectRequestBody_extension() +{ + headerIsSet_ = false; +} + +HttpDetectRequestBody_extension::~HttpDetectRequestBody_extension() = default; + +void HttpDetectRequestBody_extension::validate() +{ +} + +web::json::value HttpDetectRequestBody_extension::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(headerIsSet_) { + val[utility::conversions::to_string_t("header")] = ModelBase::toJson(header_); + } + + return val; +} +bool HttpDetectRequestBody_extension::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("header"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("header")); + if(!fieldValue.is_null()) + { + std::map refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setHeader(refVal); + } + } + return ok; +} + + +std::map& HttpDetectRequestBody_extension::getHeader() +{ + return header_; +} + +void HttpDetectRequestBody_extension::setHeader(const std::map& value) +{ + header_ = value; + headerIsSet_ = true; +} + +bool HttpDetectRequestBody_extension::headerIsSet() const +{ + return headerIsSet_; +} + +void HttpDetectRequestBody_extension::unsetheader() +{ + headerIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/ListSubscriptionsByTopicRequest.cpp b/smn/src/v2/model/ListSubscriptionsByTopicRequest.cpp index c5be944c5..9f7e56476 100644 --- a/smn/src/v2/model/ListSubscriptionsByTopicRequest.cpp +++ b/smn/src/v2/model/ListSubscriptionsByTopicRequest.cpp @@ -18,6 +18,8 @@ ListSubscriptionsByTopicRequest::ListSubscriptionsByTopicRequest() offsetIsSet_ = false; limit_ = 0; limitIsSet_ = false; + fuzzyRemark_ = ""; + fuzzyRemarkIsSet_ = false; } ListSubscriptionsByTopicRequest::~ListSubscriptionsByTopicRequest() = default; @@ -39,6 +41,9 @@ web::json::value ListSubscriptionsByTopicRequest::toJson() const if(limitIsSet_) { val[utility::conversions::to_string_t("limit")] = ModelBase::toJson(limit_); } + if(fuzzyRemarkIsSet_) { + val[utility::conversions::to_string_t("fuzzy_remark")] = ModelBase::toJson(fuzzyRemark_); + } return val; } @@ -73,6 +78,15 @@ bool ListSubscriptionsByTopicRequest::fromJson(const web::json::value& val) setLimit(refVal); } } + if(val.has_field(utility::conversions::to_string_t("fuzzy_remark"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("fuzzy_remark")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setFuzzyRemark(refVal); + } + } return ok; } @@ -140,6 +154,27 @@ void ListSubscriptionsByTopicRequest::unsetlimit() limitIsSet_ = false; } +std::string ListSubscriptionsByTopicRequest::getFuzzyRemark() const +{ + return fuzzyRemark_; +} + +void ListSubscriptionsByTopicRequest::setFuzzyRemark(const std::string& value) +{ + fuzzyRemark_ = value; + fuzzyRemarkIsSet_ = true; +} + +bool ListSubscriptionsByTopicRequest::fuzzyRemarkIsSet() const +{ + return fuzzyRemarkIsSet_; +} + +void ListSubscriptionsByTopicRequest::unsetfuzzyRemark() +{ + fuzzyRemarkIsSet_ = false; +} + } } } diff --git a/smn/src/v2/model/ListSubscriptionsItem.cpp b/smn/src/v2/model/ListSubscriptionsItem.cpp index f752df4e4..06d7a472c 100644 --- a/smn/src/v2/model/ListSubscriptionsItem.cpp +++ b/smn/src/v2/model/ListSubscriptionsItem.cpp @@ -26,6 +26,7 @@ ListSubscriptionsItem::ListSubscriptionsItem() remarkIsSet_ = false; status_ = 0; statusIsSet_ = false; + filterPolicesIsSet_ = false; } ListSubscriptionsItem::~ListSubscriptionsItem() = default; @@ -59,6 +60,9 @@ web::json::value ListSubscriptionsItem::toJson() const if(statusIsSet_) { val[utility::conversions::to_string_t("status")] = ModelBase::toJson(status_); } + if(filterPolicesIsSet_) { + val[utility::conversions::to_string_t("filter_polices")] = ModelBase::toJson(filterPolices_); + } return val; } @@ -129,6 +133,15 @@ bool ListSubscriptionsItem::fromJson(const web::json::value& val) setStatus(refVal); } } + if(val.has_field(utility::conversions::to_string_t("filter_polices"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("filter_polices")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setFilterPolices(refVal); + } + } return ok; } @@ -280,6 +293,27 @@ void ListSubscriptionsItem::unsetstatus() statusIsSet_ = false; } +std::vector& ListSubscriptionsItem::getFilterPolices() +{ + return filterPolices_; +} + +void ListSubscriptionsItem::setFilterPolices(const std::vector& value) +{ + filterPolices_ = value; + filterPolicesIsSet_ = true; +} + +bool ListSubscriptionsItem::filterPolicesIsSet() const +{ + return filterPolicesIsSet_; +} + +void ListSubscriptionsItem::unsetfilterPolices() +{ + filterPolicesIsSet_ = false; +} + } } } diff --git a/smn/src/v2/model/ListSubscriptionsRequest.cpp b/smn/src/v2/model/ListSubscriptionsRequest.cpp index ed0c12c77..9eeda58fb 100644 --- a/smn/src/v2/model/ListSubscriptionsRequest.cpp +++ b/smn/src/v2/model/ListSubscriptionsRequest.cpp @@ -22,6 +22,8 @@ ListSubscriptionsRequest::ListSubscriptionsRequest() statusIsSet_ = false; endpoint_ = ""; endpointIsSet_ = false; + fuzzyRemark_ = ""; + fuzzyRemarkIsSet_ = false; } ListSubscriptionsRequest::~ListSubscriptionsRequest() = default; @@ -49,6 +51,9 @@ web::json::value ListSubscriptionsRequest::toJson() const if(endpointIsSet_) { val[utility::conversions::to_string_t("endpoint")] = ModelBase::toJson(endpoint_); } + if(fuzzyRemarkIsSet_) { + val[utility::conversions::to_string_t("fuzzy_remark")] = ModelBase::toJson(fuzzyRemark_); + } return val; } @@ -101,6 +106,15 @@ bool ListSubscriptionsRequest::fromJson(const web::json::value& val) setEndpoint(refVal); } } + if(val.has_field(utility::conversions::to_string_t("fuzzy_remark"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("fuzzy_remark")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setFuzzyRemark(refVal); + } + } return ok; } @@ -210,6 +224,27 @@ void ListSubscriptionsRequest::unsetendpoint() endpointIsSet_ = false; } +std::string ListSubscriptionsRequest::getFuzzyRemark() const +{ + return fuzzyRemark_; +} + +void ListSubscriptionsRequest::setFuzzyRemark(const std::string& value) +{ + fuzzyRemark_ = value; + fuzzyRemarkIsSet_ = true; +} + +bool ListSubscriptionsRequest::fuzzyRemarkIsSet() const +{ + return fuzzyRemarkIsSet_; +} + +void ListSubscriptionsRequest::unsetfuzzyRemark() +{ + fuzzyRemarkIsSet_ = false; +} + } } } diff --git a/smn/src/v2/model/ListTopicsRequest.cpp b/smn/src/v2/model/ListTopicsRequest.cpp index 3a230feb0..5582eaa0c 100644 --- a/smn/src/v2/model/ListTopicsRequest.cpp +++ b/smn/src/v2/model/ListTopicsRequest.cpp @@ -24,6 +24,8 @@ ListTopicsRequest::ListTopicsRequest() fuzzyNameIsSet_ = false; topicId_ = ""; topicIdIsSet_ = false; + fuzzyDisplayName_ = ""; + fuzzyDisplayNameIsSet_ = false; } ListTopicsRequest::~ListTopicsRequest() = default; @@ -54,6 +56,9 @@ web::json::value ListTopicsRequest::toJson() const if(topicIdIsSet_) { val[utility::conversions::to_string_t("topic_id")] = ModelBase::toJson(topicId_); } + if(fuzzyDisplayNameIsSet_) { + val[utility::conversions::to_string_t("fuzzy_display_name")] = ModelBase::toJson(fuzzyDisplayName_); + } return val; } @@ -115,6 +120,15 @@ bool ListTopicsRequest::fromJson(const web::json::value& val) setTopicId(refVal); } } + if(val.has_field(utility::conversions::to_string_t("fuzzy_display_name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("fuzzy_display_name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setFuzzyDisplayName(refVal); + } + } return ok; } @@ -245,6 +259,27 @@ void ListTopicsRequest::unsettopicId() topicIdIsSet_ = false; } +std::string ListTopicsRequest::getFuzzyDisplayName() const +{ + return fuzzyDisplayName_; +} + +void ListTopicsRequest::setFuzzyDisplayName(const std::string& value) +{ + fuzzyDisplayName_ = value; + fuzzyDisplayNameIsSet_ = true; +} + +bool ListTopicsRequest::fuzzyDisplayNameIsSet() const +{ + return fuzzyDisplayNameIsSet_; +} + +void ListTopicsRequest::unsetfuzzyDisplayName() +{ + fuzzyDisplayNameIsSet_ = false; +} + } } } diff --git a/smn/src/v2/model/MessageAttribute.cpp b/smn/src/v2/model/MessageAttribute.cpp new file mode 100644 index 000000000..feebab0df --- /dev/null +++ b/smn/src/v2/model/MessageAttribute.cpp @@ -0,0 +1,148 @@ + + +#include "huaweicloud/smn/v2/model/MessageAttribute.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +MessageAttribute::MessageAttribute() +{ + name_ = ""; + nameIsSet_ = false; + type_ = ""; + typeIsSet_ = false; + valueIsSet_ = false; +} + +MessageAttribute::~MessageAttribute() = default; + +void MessageAttribute::validate() +{ +} + +web::json::value MessageAttribute::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(nameIsSet_) { + val[utility::conversions::to_string_t("name")] = ModelBase::toJson(name_); + } + if(typeIsSet_) { + val[utility::conversions::to_string_t("type")] = ModelBase::toJson(type_); + } + if(valueIsSet_) { + val[utility::conversions::to_string_t("value")] = ModelBase::toJson(value_); + } + + return val; +} +bool MessageAttribute::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("type"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("type")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setType(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("value"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("value")); + if(!fieldValue.is_null()) + { + Object refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setValue(refVal); + } + } + return ok; +} + + +std::string MessageAttribute::getName() const +{ + return name_; +} + +void MessageAttribute::setName(const std::string& value) +{ + name_ = value; + nameIsSet_ = true; +} + +bool MessageAttribute::nameIsSet() const +{ + return nameIsSet_; +} + +void MessageAttribute::unsetname() +{ + nameIsSet_ = false; +} + +std::string MessageAttribute::getType() const +{ + return type_; +} + +void MessageAttribute::setType(const std::string& value) +{ + type_ = value; + typeIsSet_ = true; +} + +bool MessageAttribute::typeIsSet() const +{ + return typeIsSet_; +} + +void MessageAttribute::unsettype() +{ + typeIsSet_ = false; +} + +Object MessageAttribute::getValue() const +{ + return value_; +} + +void MessageAttribute::setValue(const Object& value) +{ + value_ = value; + valueIsSet_ = true; +} + +bool MessageAttribute::valueIsSet() const +{ + return valueIsSet_; +} + +void MessageAttribute::unsetvalue() +{ + valueIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/PublishHttpDetectRequest.cpp b/smn/src/v2/model/PublishHttpDetectRequest.cpp new file mode 100644 index 000000000..e50af1332 --- /dev/null +++ b/smn/src/v2/model/PublishHttpDetectRequest.cpp @@ -0,0 +1,113 @@ + + +#include "huaweicloud/smn/v2/model/PublishHttpDetectRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +PublishHttpDetectRequest::PublishHttpDetectRequest() +{ + topicUrn_ = ""; + topicUrnIsSet_ = false; + bodyIsSet_ = false; +} + +PublishHttpDetectRequest::~PublishHttpDetectRequest() = default; + +void PublishHttpDetectRequest::validate() +{ +} + +web::json::value PublishHttpDetectRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(topicUrnIsSet_) { + val[utility::conversions::to_string_t("topic_urn")] = ModelBase::toJson(topicUrn_); + } + if(bodyIsSet_) { + val[utility::conversions::to_string_t("body")] = ModelBase::toJson(body_); + } + + return val; +} +bool PublishHttpDetectRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("topic_urn"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("topic_urn")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTopicUrn(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()) + { + HttpDetectRequestBody refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setBody(refVal); + } + } + return ok; +} + + +std::string PublishHttpDetectRequest::getTopicUrn() const +{ + return topicUrn_; +} + +void PublishHttpDetectRequest::setTopicUrn(const std::string& value) +{ + topicUrn_ = value; + topicUrnIsSet_ = true; +} + +bool PublishHttpDetectRequest::topicUrnIsSet() const +{ + return topicUrnIsSet_; +} + +void PublishHttpDetectRequest::unsettopicUrn() +{ + topicUrnIsSet_ = false; +} + +HttpDetectRequestBody PublishHttpDetectRequest::getBody() const +{ + return body_; +} + +void PublishHttpDetectRequest::setBody(const HttpDetectRequestBody& value) +{ + body_ = value; + bodyIsSet_ = true; +} + +bool PublishHttpDetectRequest::bodyIsSet() const +{ + return bodyIsSet_; +} + +void PublishHttpDetectRequest::unsetbody() +{ + bodyIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/PublishHttpDetectResponse.cpp b/smn/src/v2/model/PublishHttpDetectResponse.cpp new file mode 100644 index 000000000..db3de12c1 --- /dev/null +++ b/smn/src/v2/model/PublishHttpDetectResponse.cpp @@ -0,0 +1,114 @@ + + +#include "huaweicloud/smn/v2/model/PublishHttpDetectResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +PublishHttpDetectResponse::PublishHttpDetectResponse() +{ + requestId_ = ""; + requestIdIsSet_ = false; + taskId_ = ""; + taskIdIsSet_ = false; +} + +PublishHttpDetectResponse::~PublishHttpDetectResponse() = default; + +void PublishHttpDetectResponse::validate() +{ +} + +web::json::value PublishHttpDetectResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(requestIdIsSet_) { + val[utility::conversions::to_string_t("request_id")] = ModelBase::toJson(requestId_); + } + if(taskIdIsSet_) { + val[utility::conversions::to_string_t("task_id")] = ModelBase::toJson(taskId_); + } + + return val; +} +bool PublishHttpDetectResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("request_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("request_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setRequestId(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("task_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("task_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTaskId(refVal); + } + } + return ok; +} + + +std::string PublishHttpDetectResponse::getRequestId() const +{ + return requestId_; +} + +void PublishHttpDetectResponse::setRequestId(const std::string& value) +{ + requestId_ = value; + requestIdIsSet_ = true; +} + +bool PublishHttpDetectResponse::requestIdIsSet() const +{ + return requestIdIsSet_; +} + +void PublishHttpDetectResponse::unsetrequestId() +{ + requestIdIsSet_ = false; +} + +std::string PublishHttpDetectResponse::getTaskId() const +{ + return taskId_; +} + +void PublishHttpDetectResponse::setTaskId(const std::string& value) +{ + taskId_ = value; + taskIdIsSet_ = true; +} + +bool PublishHttpDetectResponse::taskIdIsSet() const +{ + return taskIdIsSet_; +} + +void PublishHttpDetectResponse::unsettaskId() +{ + taskIdIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/PublishMessageRequestBody.cpp b/smn/src/v2/model/PublishMessageRequestBody.cpp index fe56edd08..b96c31fc4 100644 --- a/smn/src/v2/model/PublishMessageRequestBody.cpp +++ b/smn/src/v2/model/PublishMessageRequestBody.cpp @@ -23,6 +23,7 @@ PublishMessageRequestBody::PublishMessageRequestBody() tagsIsSet_ = false; timeToLive_ = ""; timeToLiveIsSet_ = false; + messageAttributesIsSet_ = false; } PublishMessageRequestBody::~PublishMessageRequestBody() = default; @@ -53,6 +54,9 @@ web::json::value PublishMessageRequestBody::toJson() const if(timeToLiveIsSet_) { val[utility::conversions::to_string_t("time_to_live")] = ModelBase::toJson(timeToLive_); } + if(messageAttributesIsSet_) { + val[utility::conversions::to_string_t("message_attributes")] = ModelBase::toJson(messageAttributes_); + } return val; } @@ -114,6 +118,15 @@ bool PublishMessageRequestBody::fromJson(const web::json::value& val) setTimeToLive(refVal); } } + if(val.has_field(utility::conversions::to_string_t("message_attributes"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("message_attributes")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setMessageAttributes(refVal); + } + } return ok; } @@ -244,6 +257,27 @@ void PublishMessageRequestBody::unsettimeToLive() timeToLiveIsSet_ = false; } +std::vector& PublishMessageRequestBody::getMessageAttributes() +{ + return messageAttributes_; +} + +void PublishMessageRequestBody::setMessageAttributes(const std::vector& value) +{ + messageAttributes_ = value; + messageAttributesIsSet_ = true; +} + +bool PublishMessageRequestBody::messageAttributesIsSet() const +{ + return messageAttributesIsSet_; +} + +void PublishMessageRequestBody::unsetmessageAttributes() +{ + messageAttributesIsSet_ = false; +} + } } } diff --git a/smn/src/v2/model/ShowHttpDetectResultRequest.cpp b/smn/src/v2/model/ShowHttpDetectResultRequest.cpp new file mode 100644 index 000000000..ecd298dd4 --- /dev/null +++ b/smn/src/v2/model/ShowHttpDetectResultRequest.cpp @@ -0,0 +1,114 @@ + + +#include "huaweicloud/smn/v2/model/ShowHttpDetectResultRequest.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +ShowHttpDetectResultRequest::ShowHttpDetectResultRequest() +{ + topicUrn_ = ""; + topicUrnIsSet_ = false; + taskId_ = ""; + taskIdIsSet_ = false; +} + +ShowHttpDetectResultRequest::~ShowHttpDetectResultRequest() = default; + +void ShowHttpDetectResultRequest::validate() +{ +} + +web::json::value ShowHttpDetectResultRequest::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(topicUrnIsSet_) { + val[utility::conversions::to_string_t("topic_urn")] = ModelBase::toJson(topicUrn_); + } + if(taskIdIsSet_) { + val[utility::conversions::to_string_t("task_id")] = ModelBase::toJson(taskId_); + } + + return val; +} +bool ShowHttpDetectResultRequest::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("topic_urn"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("topic_urn")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTopicUrn(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("task_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("task_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setTaskId(refVal); + } + } + return ok; +} + + +std::string ShowHttpDetectResultRequest::getTopicUrn() const +{ + return topicUrn_; +} + +void ShowHttpDetectResultRequest::setTopicUrn(const std::string& value) +{ + topicUrn_ = value; + topicUrnIsSet_ = true; +} + +bool ShowHttpDetectResultRequest::topicUrnIsSet() const +{ + return topicUrnIsSet_; +} + +void ShowHttpDetectResultRequest::unsettopicUrn() +{ + topicUrnIsSet_ = false; +} + +std::string ShowHttpDetectResultRequest::getTaskId() const +{ + return taskId_; +} + +void ShowHttpDetectResultRequest::setTaskId(const std::string& value) +{ + taskId_ = value; + taskIdIsSet_ = true; +} + +bool ShowHttpDetectResultRequest::taskIdIsSet() const +{ + return taskIdIsSet_; +} + +void ShowHttpDetectResultRequest::unsettaskId() +{ + taskIdIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/ShowHttpDetectResultResponse.cpp b/smn/src/v2/model/ShowHttpDetectResultResponse.cpp new file mode 100644 index 000000000..464ce4953 --- /dev/null +++ b/smn/src/v2/model/ShowHttpDetectResultResponse.cpp @@ -0,0 +1,148 @@ + + +#include "huaweicloud/smn/v2/model/ShowHttpDetectResultResponse.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +ShowHttpDetectResultResponse::ShowHttpDetectResultResponse() +{ + detailIsSet_ = false; + status_ = 0; + statusIsSet_ = false; + requestId_ = ""; + requestIdIsSet_ = false; +} + +ShowHttpDetectResultResponse::~ShowHttpDetectResultResponse() = default; + +void ShowHttpDetectResultResponse::validate() +{ +} + +web::json::value ShowHttpDetectResultResponse::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(detailIsSet_) { + val[utility::conversions::to_string_t("detail")] = ModelBase::toJson(detail_); + } + if(statusIsSet_) { + val[utility::conversions::to_string_t("status")] = ModelBase::toJson(status_); + } + if(requestIdIsSet_) { + val[utility::conversions::to_string_t("request_id")] = ModelBase::toJson(requestId_); + } + + return val; +} +bool ShowHttpDetectResultResponse::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("detail"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("detail")); + if(!fieldValue.is_null()) + { + GetHttpDetectResponseBody_detail refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setDetail(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()) + { + int32_t refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStatus(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("request_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("request_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setRequestId(refVal); + } + } + return ok; +} + + +GetHttpDetectResponseBody_detail ShowHttpDetectResultResponse::getDetail() const +{ + return detail_; +} + +void ShowHttpDetectResultResponse::setDetail(const GetHttpDetectResponseBody_detail& value) +{ + detail_ = value; + detailIsSet_ = true; +} + +bool ShowHttpDetectResultResponse::detailIsSet() const +{ + return detailIsSet_; +} + +void ShowHttpDetectResultResponse::unsetdetail() +{ + detailIsSet_ = false; +} + +int32_t ShowHttpDetectResultResponse::getStatus() const +{ + return status_; +} + +void ShowHttpDetectResultResponse::setStatus(int32_t value) +{ + status_ = value; + statusIsSet_ = true; +} + +bool ShowHttpDetectResultResponse::statusIsSet() const +{ + return statusIsSet_; +} + +void ShowHttpDetectResultResponse::unsetstatus() +{ + statusIsSet_ = false; +} + +std::string ShowHttpDetectResultResponse::getRequestId() const +{ + return requestId_; +} + +void ShowHttpDetectResultResponse::setRequestId(const std::string& value) +{ + requestId_ = value; + requestIdIsSet_ = true; +} + +bool ShowHttpDetectResultResponse::requestIdIsSet() const +{ + return requestIdIsSet_; +} + +void ShowHttpDetectResultResponse::unsetrequestId() +{ + requestIdIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/smn/src/v2/model/SubscriptionsFilterPolicy.cpp b/smn/src/v2/model/SubscriptionsFilterPolicy.cpp new file mode 100644 index 000000000..f442e5c10 --- /dev/null +++ b/smn/src/v2/model/SubscriptionsFilterPolicy.cpp @@ -0,0 +1,113 @@ + + +#include "huaweicloud/smn/v2/model/SubscriptionsFilterPolicy.h" +namespace HuaweiCloud { +namespace Sdk { +namespace Smn { +namespace V2 { +namespace Model { + + + + +SubscriptionsFilterPolicy::SubscriptionsFilterPolicy() +{ + name_ = ""; + nameIsSet_ = false; + stringEqualsIsSet_ = false; +} + +SubscriptionsFilterPolicy::~SubscriptionsFilterPolicy() = default; + +void SubscriptionsFilterPolicy::validate() +{ +} + +web::json::value SubscriptionsFilterPolicy::toJson() const +{ + web::json::value val = web::json::value::object(); + + if(nameIsSet_) { + val[utility::conversions::to_string_t("name")] = ModelBase::toJson(name_); + } + if(stringEqualsIsSet_) { + val[utility::conversions::to_string_t("string_equals")] = ModelBase::toJson(stringEquals_); + } + + return val; +} +bool SubscriptionsFilterPolicy::fromJson(const web::json::value& val) +{ + bool ok = true; + + if(val.has_field(utility::conversions::to_string_t("name"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("name")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setName(refVal); + } + } + if(val.has_field(utility::conversions::to_string_t("string_equals"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("string_equals")); + if(!fieldValue.is_null()) + { + std::vector refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setStringEquals(refVal); + } + } + return ok; +} + + +std::string SubscriptionsFilterPolicy::getName() const +{ + return name_; +} + +void SubscriptionsFilterPolicy::setName(const std::string& value) +{ + name_ = value; + nameIsSet_ = true; +} + +bool SubscriptionsFilterPolicy::nameIsSet() const +{ + return nameIsSet_; +} + +void SubscriptionsFilterPolicy::unsetname() +{ + nameIsSet_ = false; +} + +std::vector& SubscriptionsFilterPolicy::getStringEquals() +{ + return stringEquals_; +} + +void SubscriptionsFilterPolicy::setStringEquals(const std::vector& value) +{ + stringEquals_ = value; + stringEqualsIsSet_ = true; +} + +bool SubscriptionsFilterPolicy::stringEqualsIsSet() const +{ + return stringEqualsIsSet_; +} + +void SubscriptionsFilterPolicy::unsetstringEquals() +{ + stringEqualsIsSet_ = false; +} + +} +} +} +} +} + + diff --git a/vpc/include/huaweicloud/vpc/v2/model/Port.h b/vpc/include/huaweicloud/vpc/v2/model/Port.h index f88b5fa5d..383c4ef9c 100644 --- a/vpc/include/huaweicloud/vpc/v2/model/Port.h +++ b/vpc/include/huaweicloud/vpc/v2/model/Port.h @@ -252,6 +252,15 @@ class HUAWEICLOUD_VPC_V2_EXPORT Port void unsetenableEfi(); void setEnableEfi(bool value); + /// + /// 功能说明：IPv6网卡绑定的共享带宽ID 约束：只有IPv6网卡绑定了共享带宽，才会显示此参数 + /// + + std::string getIpv6BandwidthId() const; + bool ipv6BandwidthIdIsSet() const; + void unsetipv6BandwidthId(); + void setIpv6BandwidthId(const std::string& value); + protected: std::string id_; @@ -300,6 +309,8 @@ class HUAWEICLOUD_VPC_V2_EXPORT Port bool zoneIdIsSet_; bool enableEfi_; bool enableEfiIsSet_; + std::string ipv6BandwidthId_; + bool ipv6BandwidthIdIsSet_; }; diff --git a/vpc/src/v2/model/Port.cpp b/vpc/src/v2/model/Port.cpp index 2de55d95e..4b1ee85e2 100644 --- a/vpc/src/v2/model/Port.cpp +++ b/vpc/src/v2/model/Port.cpp @@ -51,6 +51,8 @@ Port::Port() zoneIdIsSet_ = false; enableEfi_ = false; enableEfiIsSet_ = false; + ipv6BandwidthId_ = ""; + ipv6BandwidthIdIsSet_ = false; } Port::~Port() = default; @@ -132,6 +134,9 @@ web::json::value Port::toJson() const if(enableEfiIsSet_) { val[utility::conversions::to_string_t("enable_efi")] = ModelBase::toJson(enableEfi_); } + if(ipv6BandwidthIdIsSet_) { + val[utility::conversions::to_string_t("ipv6_bandwidth_id")] = ModelBase::toJson(ipv6BandwidthId_); + } return val; } @@ -346,6 +351,15 @@ bool Port::fromJson(const web::json::value& val) setEnableEfi(refVal); } } + if(val.has_field(utility::conversions::to_string_t("ipv6_bandwidth_id"))) { + const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("ipv6_bandwidth_id")); + if(!fieldValue.is_null()) + { + std::string refVal; + ok &= ModelBase::fromJson(fieldValue, refVal); + setIpv6BandwidthId(refVal); + } + } return ok; } @@ -833,6 +847,27 @@ void Port::unsetenableEfi() enableEfiIsSet_ = false; } +std::string Port::getIpv6BandwidthId() const +{ + return ipv6BandwidthId_; +} + +void Port::setIpv6BandwidthId(const std::string& value) +{ + ipv6BandwidthId_ = value; + ipv6BandwidthIdIsSet_ = true; +} + +bool Port::ipv6BandwidthIdIsSet() const +{ + return ipv6BandwidthIdIsSet_; +} + +void Port::unsetipv6BandwidthId() +{ + ipv6BandwidthIdIsSet_ = false; +} + } } }