1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Supported all language sdk.

Browse Source
This commit is contained in:
sdk-team
2020-12-03 05:49:56 +00:00
parent cf4cda767c
commit 8f21fa7c59
36 changed files with 1875 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG
View File

@@ -1,3 +1,7 @@
2020-12-03 Version: patch
- Supported all language sdk.
- Fixed some bugs for polardbx.
2020-12-03 Version: patch
- Update DetectLungNodule.

24
polardbx/CMakeLists.txt
View File

@@ -23,6 +23,8 @@ set(polardbx_public_header
set(polardbx_public_header_model
include/alibabacloud/polardbx/model/AllocateInstancePublicConnectionRequest.h
include/alibabacloud/polardbx/model/AllocateInstancePublicConnectionResult.h
include/alibabacloud/polardbx/model/CancelPolarxOrderRequest.h
include/alibabacloud/polardbx/model/CancelPolarxOrderResult.h
include/alibabacloud/polardbx/model/CheckHealthRequest.h
include/alibabacloud/polardbx/model/CheckHealthResult.h
include/alibabacloud/polardbx/model/CreateAccountRequest.h
@@ -33,6 +35,8 @@ set(polardbx_public_header_model
include/alibabacloud/polardbx/model/CreateDBInstanceResult.h
include/alibabacloud/polardbx/model/CreatePolarxInstanceRequest.h
include/alibabacloud/polardbx/model/CreatePolarxInstanceResult.h
include/alibabacloud/polardbx/model/CreatePolarxOrderRequest.h
include/alibabacloud/polardbx/model/CreatePolarxOrderResult.h
include/alibabacloud/polardbx/model/CreateSuperAccountRequest.h
include/alibabacloud/polardbx/model/CreateSuperAccountResult.h
include/alibabacloud/polardbx/model/DeleteAccountRequest.h
@@ -85,6 +89,10 @@ set(polardbx_public_header_model
include/alibabacloud/polardbx/model/DisableSqlAuditResult.h
include/alibabacloud/polardbx/model/EnableSqlAuditRequest.h
include/alibabacloud/polardbx/model/EnableSqlAuditResult.h
include/alibabacloud/polardbx/model/GetPolarXPriceRequest.h
include/alibabacloud/polardbx/model/GetPolarXPriceResult.h
include/alibabacloud/polardbx/model/GetPolarxCommodityRequest.h
include/alibabacloud/polardbx/model/GetPolarxCommodityResult.h
include/alibabacloud/polardbx/model/ModifyAccountDescriptionRequest.h
include/alibabacloud/polardbx/model/ModifyAccountDescriptionResult.h
include/alibabacloud/polardbx/model/ModifyAccountPrivilegeRequest.h
@@ -111,6 +119,10 @@ set(polardbx_public_header_model
include/alibabacloud/polardbx/model/ResetPolarxPgAccountPasswordResult.h
include/alibabacloud/polardbx/model/RestartDBInstanceRequest.h
include/alibabacloud/polardbx/model/RestartDBInstanceResult.h
include/alibabacloud/polardbx/model/RetryPolarxOrderRequest.h
include/alibabacloud/polardbx/model/RetryPolarxOrderResult.h
include/alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeRequest.h
include/alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeResult.h
include/alibabacloud/polardbx/model/UpgradeDBInstanceKernelVersionRequest.h
include/alibabacloud/polardbx/model/UpgradeDBInstanceKernelVersionResult.h )
@@ -118,6 +130,8 @@ set(polardbx_src
src/PolardbxClient.cc
src/model/AllocateInstancePublicConnectionRequest.cc
src/model/AllocateInstancePublicConnectionResult.cc
src/model/CancelPolarxOrderRequest.cc
src/model/CancelPolarxOrderResult.cc
src/model/CheckHealthRequest.cc
src/model/CheckHealthResult.cc
src/model/CreateAccountRequest.cc
@@ -128,6 +142,8 @@ set(polardbx_src
src/model/CreateDBInstanceResult.cc
src/model/CreatePolarxInstanceRequest.cc
src/model/CreatePolarxInstanceResult.cc
src/model/CreatePolarxOrderRequest.cc
src/model/CreatePolarxOrderResult.cc
src/model/CreateSuperAccountRequest.cc
src/model/CreateSuperAccountResult.cc
src/model/DeleteAccountRequest.cc
@@ -180,6 +196,10 @@ set(polardbx_src
src/model/DisableSqlAuditResult.cc
src/model/EnableSqlAuditRequest.cc
src/model/EnableSqlAuditResult.cc
src/model/GetPolarXPriceRequest.cc
src/model/GetPolarXPriceResult.cc
src/model/GetPolarxCommodityRequest.cc
src/model/GetPolarxCommodityResult.cc
src/model/ModifyAccountDescriptionRequest.cc
src/model/ModifyAccountDescriptionResult.cc
src/model/ModifyAccountPrivilegeRequest.cc
@@ -206,6 +226,10 @@ set(polardbx_src
src/model/ResetPolarxPgAccountPasswordResult.cc
src/model/RestartDBInstanceRequest.cc
src/model/RestartDBInstanceResult.cc
src/model/RetryPolarxOrderRequest.cc
src/model/RetryPolarxOrderResult.cc
src/model/UpdatePolarDBXInstanceNodeRequest.cc
src/model/UpdatePolarDBXInstanceNodeResult.cc
src/model/UpgradeDBInstanceKernelVersionRequest.cc
src/model/UpgradeDBInstanceKernelVersionResult.cc )

48
polardbx/include/alibabacloud/polardbx/PolardbxClient.h
View File

@@ -24,6 +24,8 @@
#include "PolardbxExport.h"
#include "model/AllocateInstancePublicConnectionRequest.h"
#include "model/AllocateInstancePublicConnectionResult.h"
#include "model/CancelPolarxOrderRequest.h"
#include "model/CancelPolarxOrderResult.h"
#include "model/CheckHealthRequest.h"
#include "model/CheckHealthResult.h"
#include "model/CreateAccountRequest.h"
@@ -34,6 +36,8 @@
#include "model/CreateDBInstanceResult.h"
#include "model/CreatePolarxInstanceRequest.h"
#include "model/CreatePolarxInstanceResult.h"
#include "model/CreatePolarxOrderRequest.h"
#include "model/CreatePolarxOrderResult.h"
#include "model/CreateSuperAccountRequest.h"
#include "model/CreateSuperAccountResult.h"
#include "model/DeleteAccountRequest.h"
@@ -86,6 +90,10 @@
#include "model/DisableSqlAuditResult.h"
#include "model/EnableSqlAuditRequest.h"
#include "model/EnableSqlAuditResult.h"
#include "model/GetPolarXPriceRequest.h"
#include "model/GetPolarXPriceResult.h"
#include "model/GetPolarxCommodityRequest.h"
#include "model/GetPolarxCommodityResult.h"
#include "model/ModifyAccountDescriptionRequest.h"
#include "model/ModifyAccountDescriptionResult.h"
#include "model/ModifyAccountPrivilegeRequest.h"
@@ -112,6 +120,10 @@
#include "model/ResetPolarxPgAccountPasswordResult.h"
#include "model/RestartDBInstanceRequest.h"
#include "model/RestartDBInstanceResult.h"
#include "model/RetryPolarxOrderRequest.h"
#include "model/RetryPolarxOrderResult.h"
#include "model/UpdatePolarDBXInstanceNodeRequest.h"
#include "model/UpdatePolarDBXInstanceNodeResult.h"
#include "model/UpgradeDBInstanceKernelVersionRequest.h"
#include "model/UpgradeDBInstanceKernelVersionResult.h"
@@ -126,6 +138,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::AllocateInstancePublicConnectionResult> AllocateInstancePublicConnectionOutcome;
typedef std::future<AllocateInstancePublicConnectionOutcome> AllocateInstancePublicConnectionOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::AllocateInstancePublicConnectionRequest&, const AllocateInstancePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateInstancePublicConnectionAsyncHandler;
typedef Outcome<Error, Model::CancelPolarxOrderResult> CancelPolarxOrderOutcome;
typedef std::future<CancelPolarxOrderOutcome> CancelPolarxOrderOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CancelPolarxOrderRequest&, const CancelPolarxOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelPolarxOrderAsyncHandler;
typedef Outcome<Error, Model::CheckHealthResult> CheckHealthOutcome;
typedef std::future<CheckHealthOutcome> CheckHealthOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CheckHealthRequest&, const CheckHealthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckHealthAsyncHandler;
@@ -141,6 +156,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreatePolarxInstanceResult> CreatePolarxInstanceOutcome;
typedef std::future<CreatePolarxInstanceOutcome> CreatePolarxInstanceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CreatePolarxInstanceRequest&, const CreatePolarxInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePolarxInstanceAsyncHandler;
typedef Outcome<Error, Model::CreatePolarxOrderResult> CreatePolarxOrderOutcome;
typedef std::future<CreatePolarxOrderOutcome> CreatePolarxOrderOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CreatePolarxOrderRequest&, const CreatePolarxOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePolarxOrderAsyncHandler;
typedef Outcome<Error, Model::CreateSuperAccountResult> CreateSuperAccountOutcome;
typedef std::future<CreateSuperAccountOutcome> CreateSuperAccountOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CreateSuperAccountRequest&, const CreateSuperAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSuperAccountAsyncHandler;
@@ -219,6 +237,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::EnableSqlAuditResult> EnableSqlAuditOutcome;
typedef std::future<EnableSqlAuditOutcome> EnableSqlAuditOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::EnableSqlAuditRequest&, const EnableSqlAuditOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableSqlAuditAsyncHandler;
typedef Outcome<Error, Model::GetPolarXPriceResult> GetPolarXPriceOutcome;
typedef std::future<GetPolarXPriceOutcome> GetPolarXPriceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::GetPolarXPriceRequest&, const GetPolarXPriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPolarXPriceAsyncHandler;
typedef Outcome<Error, Model::GetPolarxCommodityResult> GetPolarxCommodityOutcome;
typedef std::future<GetPolarxCommodityOutcome> GetPolarxCommodityOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::GetPolarxCommodityRequest&, const GetPolarxCommodityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPolarxCommodityAsyncHandler;
typedef Outcome<Error, Model::ModifyAccountDescriptionResult> ModifyAccountDescriptionOutcome;
typedef std::future<ModifyAccountDescriptionOutcome> ModifyAccountDescriptionOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyAccountDescriptionRequest&, const ModifyAccountDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAccountDescriptionAsyncHandler;
@@ -258,6 +282,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RestartDBInstanceResult> RestartDBInstanceOutcome;
typedef std::future<RestartDBInstanceOutcome> RestartDBInstanceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::RestartDBInstanceRequest&, const RestartDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartDBInstanceAsyncHandler;
typedef Outcome<Error, Model::RetryPolarxOrderResult> RetryPolarxOrderOutcome;
typedef std::future<RetryPolarxOrderOutcome> RetryPolarxOrderOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::RetryPolarxOrderRequest&, const RetryPolarxOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetryPolarxOrderAsyncHandler;
typedef Outcome<Error, Model::UpdatePolarDBXInstanceNodeResult> UpdatePolarDBXInstanceNodeOutcome;
typedef std::future<UpdatePolarDBXInstanceNodeOutcome> UpdatePolarDBXInstanceNodeOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::UpdatePolarDBXInstanceNodeRequest&, const UpdatePolarDBXInstanceNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdatePolarDBXInstanceNodeAsyncHandler;
typedef Outcome<Error, Model::UpgradeDBInstanceKernelVersionResult> UpgradeDBInstanceKernelVersionOutcome;
typedef std::future<UpgradeDBInstanceKernelVersionOutcome> UpgradeDBInstanceKernelVersionOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::UpgradeDBInstanceKernelVersionRequest&, const UpgradeDBInstanceKernelVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeDBInstanceKernelVersionAsyncHandler;
@@ -269,6 +299,9 @@ namespace AlibabaCloud
AllocateInstancePublicConnectionOutcome allocateInstancePublicConnection(const Model::AllocateInstancePublicConnectionRequest &request)const;
void allocateInstancePublicConnectionAsync(const Model::AllocateInstancePublicConnectionRequest& request, const AllocateInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AllocateInstancePublicConnectionOutcomeCallable allocateInstancePublicConnectionCallable(const Model::AllocateInstancePublicConnectionRequest& request) const;
CancelPolarxOrderOutcome cancelPolarxOrder(const Model::CancelPolarxOrderRequest &request)const;
void cancelPolarxOrderAsync(const Model::CancelPolarxOrderRequest& request, const CancelPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelPolarxOrderOutcomeCallable cancelPolarxOrderCallable(const Model::CancelPolarxOrderRequest& request) const;
CheckHealthOutcome checkHealth(const Model::CheckHealthRequest &request)const;
void checkHealthAsync(const Model::CheckHealthRequest& request, const CheckHealthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckHealthOutcomeCallable checkHealthCallable(const Model::CheckHealthRequest& request) const;
@@ -284,6 +317,9 @@ namespace AlibabaCloud
CreatePolarxInstanceOutcome createPolarxInstance(const Model::CreatePolarxInstanceRequest &request)const;
void createPolarxInstanceAsync(const Model::CreatePolarxInstanceRequest& request, const CreatePolarxInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreatePolarxInstanceOutcomeCallable createPolarxInstanceCallable(const Model::CreatePolarxInstanceRequest& request) const;
CreatePolarxOrderOutcome createPolarxOrder(const Model::CreatePolarxOrderRequest &request)const;
void createPolarxOrderAsync(const Model::CreatePolarxOrderRequest& request, const CreatePolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreatePolarxOrderOutcomeCallable createPolarxOrderCallable(const Model::CreatePolarxOrderRequest& request) const;
CreateSuperAccountOutcome createSuperAccount(const Model::CreateSuperAccountRequest &request)const;
void createSuperAccountAsync(const Model::CreateSuperAccountRequest& request, const CreateSuperAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateSuperAccountOutcomeCallable createSuperAccountCallable(const Model::CreateSuperAccountRequest& request) const;
@@ -362,6 +398,12 @@ namespace AlibabaCloud
EnableSqlAuditOutcome enableSqlAudit(const Model::EnableSqlAuditRequest &request)const;
void enableSqlAuditAsync(const Model::EnableSqlAuditRequest& request, const EnableSqlAuditAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableSqlAuditOutcomeCallable enableSqlAuditCallable(const Model::EnableSqlAuditRequest& request) const;
GetPolarXPriceOutcome getPolarXPrice(const Model::GetPolarXPriceRequest &request)const;
void getPolarXPriceAsync(const Model::GetPolarXPriceRequest& request, const GetPolarXPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetPolarXPriceOutcomeCallable getPolarXPriceCallable(const Model::GetPolarXPriceRequest& request) const;
GetPolarxCommodityOutcome getPolarxCommodity(const Model::GetPolarxCommodityRequest &request)const;
void getPolarxCommodityAsync(const Model::GetPolarxCommodityRequest& request, const GetPolarxCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetPolarxCommodityOutcomeCallable getPolarxCommodityCallable(const Model::GetPolarxCommodityRequest& request) const;
ModifyAccountDescriptionOutcome modifyAccountDescription(const Model::ModifyAccountDescriptionRequest &request)const;
void modifyAccountDescriptionAsync(const Model::ModifyAccountDescriptionRequest& request, const ModifyAccountDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyAccountDescriptionOutcomeCallable modifyAccountDescriptionCallable(const Model::ModifyAccountDescriptionRequest& request) const;
@@ -401,6 +443,12 @@ namespace AlibabaCloud
RestartDBInstanceOutcome restartDBInstance(const Model::RestartDBInstanceRequest &request)const;
void restartDBInstanceAsync(const Model::RestartDBInstanceRequest& request, const RestartDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RestartDBInstanceOutcomeCallable restartDBInstanceCallable(const Model::RestartDBInstanceRequest& request) const;
RetryPolarxOrderOutcome retryPolarxOrder(const Model::RetryPolarxOrderRequest &request)const;
void retryPolarxOrderAsync(const Model::RetryPolarxOrderRequest& request, const RetryPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RetryPolarxOrderOutcomeCallable retryPolarxOrderCallable(const Model::RetryPolarxOrderRequest& request) const;
UpdatePolarDBXInstanceNodeOutcome updatePolarDBXInstanceNode(const Model::UpdatePolarDBXInstanceNodeRequest &request)const;
void updatePolarDBXInstanceNodeAsync(const Model::UpdatePolarDBXInstanceNodeRequest& request, const UpdatePolarDBXInstanceNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdatePolarDBXInstanceNodeOutcomeCallable updatePolarDBXInstanceNodeCallable(const Model::UpdatePolarDBXInstanceNodeRequest& request) const;
UpgradeDBInstanceKernelVersionOutcome upgradeDBInstanceKernelVersion(const Model::UpgradeDBInstanceKernelVersionRequest &request)const;
void upgradeDBInstanceKernelVersionAsync(const Model::UpgradeDBInstanceKernelVersionRequest& request, const UpgradeDBInstanceKernelVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpgradeDBInstanceKernelVersionOutcomeCallable upgradeDBInstanceKernelVersionCallable(const Model::UpgradeDBInstanceKernelVersionRequest& request) const;

54
polardbx/include/alibabacloud/polardbx/model/CancelPolarxOrderRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CancelPolarxOrderRequest : public RpcServiceRequest
{
public:
CancelPolarxOrderRequest();
~CancelPolarxOrderRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getScaleOutToken()const;
void setScaleOutToken(const std::string& scaleOutToken);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string scaleOutToken_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERREQUEST_H_

49
polardbx/include/alibabacloud/polardbx/model/CancelPolarxOrderResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CancelPolarxOrderResult : public ServiceResult
{
public:
CancelPolarxOrderResult();
explicit CancelPolarxOrderResult(const std::string &payload);
~CancelPolarxOrderResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERRESULT_H_

21
polardbx/include/alibabacloud/polardbx/model/CreateDBInstanceRequest.h
View File

@@ -35,24 +35,26 @@ namespace AlibabaCloud
CreateDBInstanceRequest();
~CreateDBInstanceRequest();
std::string getNetworkType()const;
void setNetworkType(const std::string& networkType);
std::string getEngineVersion()const;
void setEngineVersion(const std::string& engineVersion);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getDBNodeClass()const;
void setDBNodeClass(const std::string& dBNodeClass);
std::string getDBInstanceDescription()const;
void setDBInstanceDescription(const std::string& dBInstanceDescription);
std::string getPeriod()const;
void setPeriod(const std::string& period);
std::string getSecurityIPList()const;
void setSecurityIPList(const std::string& securityIPList);
bool getIsReadDBInstance()const;
void setIsReadDBInstance(bool isReadDBInstance);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
bool getAutoRenew()const;
void setAutoRenew(bool autoRenew);
std::string getZoneId()const;
void setZoneId(const std::string& zoneId);
std::string getInstanceNetworkType()const;
void setInstanceNetworkType(const std::string& instanceNetworkType);
std::string getPrimaryDBInstanceName()const;
void setPrimaryDBInstanceName(const std::string& primaryDBInstanceName);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegionId()const;
@@ -67,15 +69,16 @@ namespace AlibabaCloud
void setPayType(const std::string& payType);
private:
std::string networkType_;
std::string engineVersion_;
std::string resourceGroupId_;
std::string dBNodeClass_;
std::string dBInstanceDescription_;
std::string period_;
std::string securityIPList_;
bool isReadDBInstance_;
std::string vSwitchId_;
bool autoRenew_;
std::string zoneId_;
std::string instanceNetworkType_;
std::string primaryDBInstanceName_;
std::string clientToken_;
std::string regionId_;
int dBNodeCount_;

4
polardbx/include/alibabacloud/polardbx/model/CreateDBInstanceResult.h
View File

@@ -37,17 +37,13 @@ namespace AlibabaCloud
CreateDBInstanceResult();
explicit CreateDBInstanceResult(const std::string &payload);
~CreateDBInstanceResult();
int getPort()const;
std::string getOrderId()const;
std::string getConnectionString()const;
std::string getDBInstanceName()const;
protected:
void parse(const std::string &payload);
private:
int port_;
std::string orderId_;
std::string connectionString_;
std::string dBInstanceName_;
};

54
polardbx/include/alibabacloud/polardbx/model/CreatePolarxOrderRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreatePolarxOrderRequest : public RpcServiceRequest
{
public:
CreatePolarxOrderRequest();
~CreatePolarxOrderRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNodeCount()const;
void setNodeCount(const std::string& nodeCount);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string nodeCount_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERREQUEST_H_

56
polardbx/include/alibabacloud/polardbx/model/CreatePolarxOrderResult.h Normal file
View File

@@ -0,0 +1,56 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreatePolarxOrderResult : public ServiceResult
{
public:
struct OrderResult
{
long orderId;
std::string dBInstanceName;
};
CreatePolarxOrderResult();
explicit CreatePolarxOrderResult(const std::string &payload);
~CreatePolarxOrderResult();
std::vector<OrderResult> getOrderResultList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<OrderResult> orderResultList_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERRESULT_H_

3
polardbx/include/alibabacloud/polardbx/model/DescribeTasksResult.h
View File

@@ -34,13 +34,14 @@ namespace AlibabaCloud
public:
struct TaskProgressInfo
{
std::string expectedFinishTime;
std::string finishTime1;
std::string status;
std::string progress;
std::string taskId;
std::string finishTime;
std::string taskAction;
std::string progressInfo;
std::string scaleOutToken;
std::string dBName;
std::string beginTime;
std::string taskErrorCode;

54
polardbx/include/alibabacloud/polardbx/model/GetPolarXPriceRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT GetPolarXPriceRequest : public RpcServiceRequest
{
public:
GetPolarXPriceRequest();
~GetPolarXPriceRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNodeCount()const;
void setNodeCount(const std::string& nodeCount);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string nodeCount_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICEREQUEST_H_

67
polardbx/include/alibabacloud/polardbx/model/GetPolarXPriceResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT GetPolarXPriceResult : public ServiceResult
{
public:
struct OrderPrice
{
struct Rule
{
long ruleDescId;
std::string title;
std::string name;
};
std::string totalCostAmount;
std::string tradeAmount;
std::string payType;
std::vector<OrderPrice::Rule> rules;
std::string originalAmount;
std::string discountAmount;
std::string dBInstanceName;
};
GetPolarXPriceResult();
explicit GetPolarXPriceResult(const std::string &payload);
~GetPolarXPriceResult();
std::vector<OrderPrice> getOrderPriceList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<OrderPrice> orderPriceList_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICERESULT_H_

54
polardbx/include/alibabacloud/polardbx/model/GetPolarxCommodityRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT GetPolarxCommodityRequest : public RpcServiceRequest
{
public:
GetPolarxCommodityRequest();
~GetPolarxCommodityRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOrderType()const;
void setOrderType(const std::string& orderType);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string orderType_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYREQUEST_H_

108
polardbx/include/alibabacloud/polardbx/model/GetPolarxCommodityResult.h Normal file
View File

@@ -0,0 +1,108 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT GetPolarxCommodityResult : public ServiceResult
{
public:
struct DBInstance
{
struct DBNode
{
std::string nodeClass;
std::string zoneId;
std::string id;
std::string regionId;
};
struct ConnAddr
{
std::string type;
std::string vPCId;
std::string port;
std::string vSwitchId;
std::string connectionString;
};
std::string description;
std::string expireDate;
std::vector<std::string> readDBInstances;
std::vector<ConnAddr> connAddrs;
std::string port;
std::string dBInstanceType;
std::string dBType;
std::string dBVersion;
std::string maintainEndTime;
std::vector<DBNode> dBNodes;
std::string network;
int dBNodeCount;
std::string commodityCode;
std::string engine;
std::string maintainStartTime;
std::string status;
std::string zoneId;
std::string vPCId;
std::string createTime;
std::string vSwitchId;
std::string minorVersion;
std::string expired;
std::string latestMinorVersion;
std::string payType;
std::string lockMode;
long storageUsed;
std::string dBNodeClass;
std::string type;
std::string regionId;
std::string id;
std::string connectionString;
};
struct Component
{
std::string type;
std::vector<std::string> values;
std::string name;
};
GetPolarxCommodityResult();
explicit GetPolarxCommodityResult(const std::string &payload);
~GetPolarxCommodityResult();
DBInstance getDBInstance()const;
std::vector<Component> getComponentList()const;
protected:
void parse(const std::string &payload);
private:
DBInstance dBInstance_;
std::vector<Component> componentList_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYRESULT_H_

2
polardbx/include/alibabacloud/polardbx/model/ModifyDBInstanceClassResult.h
View File

@@ -37,10 +37,12 @@ namespace AlibabaCloud
ModifyDBInstanceClassResult();
explicit ModifyDBInstanceClassResult(const std::string &payload);
~ModifyDBInstanceClassResult();
std::string getOrderId()const;
protected:
void parse(const std::string &payload);
private:
std::string orderId_;
};
}

54
polardbx/include/alibabacloud/polardbx/model/RetryPolarxOrderRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_RETRYPOLARXORDERREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_RETRYPOLARXORDERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT RetryPolarxOrderRequest : public RpcServiceRequest
{
public:
RetryPolarxOrderRequest();
~RetryPolarxOrderRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getScaleOutToken()const;
void setScaleOutToken(const std::string& scaleOutToken);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string scaleOutToken_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_RETRYPOLARXORDERREQUEST_H_

49
polardbx/include/alibabacloud/polardbx/model/RetryPolarxOrderResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_RETRYPOLARXORDERRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_RETRYPOLARXORDERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT RetryPolarxOrderResult : public ServiceResult
{
public:
RetryPolarxOrderResult();
explicit RetryPolarxOrderResult(const std::string &payload);
~RetryPolarxOrderResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_RETRYPOLARXORDERRESULT_H_

57
polardbx/include/alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT UpdatePolarDBXInstanceNodeRequest : public RpcServiceRequest
{
public:
UpdatePolarDBXInstanceNodeRequest();
~UpdatePolarDBXInstanceNodeRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDbInstanceNodeCount()const;
void setDbInstanceNodeCount(const std::string& dbInstanceNodeCount);
private:
std::string dBInstanceName_;
std::string clientToken_;
std::string regionId_;
std::string dbInstanceNodeCount_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODEREQUEST_H_

51
polardbx/include/alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT UpdatePolarDBXInstanceNodeResult : public ServiceResult
{
public:
UpdatePolarDBXInstanceNodeResult();
explicit UpdatePolarDBXInstanceNodeResult(const std::string &payload);
~UpdatePolarDBXInstanceNodeResult();
std::string getOrderId()const;
protected:
void parse(const std::string &payload);
private:
std::string orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODERESULT_H_

216
polardbx/src/PolardbxClient.cc
View File

@@ -87,6 +87,42 @@ PolardbxClient::AllocateInstancePublicConnectionOutcomeCallable PolardbxClient::
return task->get_future();
}
PolardbxClient::CancelPolarxOrderOutcome PolardbxClient::cancelPolarxOrder(const CancelPolarxOrderRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CancelPolarxOrderOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CancelPolarxOrderOutcome(CancelPolarxOrderResult(outcome.result()));
else
return CancelPolarxOrderOutcome(outcome.error());
}
void PolardbxClient::cancelPolarxOrderAsync(const CancelPolarxOrderRequest& request, const CancelPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, cancelPolarxOrder(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbxClient::CancelPolarxOrderOutcomeCallable PolardbxClient::cancelPolarxOrderCallable(const CancelPolarxOrderRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CancelPolarxOrderOutcome()>>(
[this, request]()
{
return this->cancelPolarxOrder(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbxClient::CheckHealthOutcome PolardbxClient::checkHealth(const CheckHealthRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +303,42 @@ PolardbxClient::CreatePolarxInstanceOutcomeCallable PolardbxClient::createPolarx
return task->get_future();
}
PolardbxClient::CreatePolarxOrderOutcome PolardbxClient::createPolarxOrder(const CreatePolarxOrderRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreatePolarxOrderOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreatePolarxOrderOutcome(CreatePolarxOrderResult(outcome.result()));
else
return CreatePolarxOrderOutcome(outcome.error());
}
void PolardbxClient::createPolarxOrderAsync(const CreatePolarxOrderRequest& request, const CreatePolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createPolarxOrder(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbxClient::CreatePolarxOrderOutcomeCallable PolardbxClient::createPolarxOrderCallable(const CreatePolarxOrderRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreatePolarxOrderOutcome()>>(
[this, request]()
{
return this->createPolarxOrder(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbxClient::CreateSuperAccountOutcome PolardbxClient::createSuperAccount(const CreateSuperAccountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1203,6 +1275,78 @@ PolardbxClient::EnableSqlAuditOutcomeCallable PolardbxClient::enableSqlAuditCall
return task->get_future();
}
PolardbxClient::GetPolarXPriceOutcome PolardbxClient::getPolarXPrice(const GetPolarXPriceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetPolarXPriceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetPolarXPriceOutcome(GetPolarXPriceResult(outcome.result()));
else
return GetPolarXPriceOutcome(outcome.error());
}
void PolardbxClient::getPolarXPriceAsync(const GetPolarXPriceRequest& request, const GetPolarXPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getPolarXPrice(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbxClient::GetPolarXPriceOutcomeCallable PolardbxClient::getPolarXPriceCallable(const GetPolarXPriceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetPolarXPriceOutcome()>>(
[this, request]()
{
return this->getPolarXPrice(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbxClient::GetPolarxCommodityOutcome PolardbxClient::getPolarxCommodity(const GetPolarxCommodityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetPolarxCommodityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetPolarxCommodityOutcome(GetPolarxCommodityResult(outcome.result()));
else
return GetPolarxCommodityOutcome(outcome.error());
}
void PolardbxClient::getPolarxCommodityAsync(const GetPolarxCommodityRequest& request, const GetPolarxCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getPolarxCommodity(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbxClient::GetPolarxCommodityOutcomeCallable PolardbxClient::getPolarxCommodityCallable(const GetPolarxCommodityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetPolarxCommodityOutcome()>>(
[this, request]()
{
return this->getPolarxCommodity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbxClient::ModifyAccountDescriptionOutcome PolardbxClient::modifyAccountDescription(const ModifyAccountDescriptionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1671,6 +1815,78 @@ PolardbxClient::RestartDBInstanceOutcomeCallable PolardbxClient::restartDBInstan
return task->get_future();
}
PolardbxClient::RetryPolarxOrderOutcome PolardbxClient::retryPolarxOrder(const RetryPolarxOrderRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RetryPolarxOrderOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RetryPolarxOrderOutcome(RetryPolarxOrderResult(outcome.result()));
else
return RetryPolarxOrderOutcome(outcome.error());
}
void PolardbxClient::retryPolarxOrderAsync(const RetryPolarxOrderRequest& request, const RetryPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, retryPolarxOrder(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbxClient::RetryPolarxOrderOutcomeCallable PolardbxClient::retryPolarxOrderCallable(const RetryPolarxOrderRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RetryPolarxOrderOutcome()>>(
[this, request]()
{
return this->retryPolarxOrder(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbxClient::UpdatePolarDBXInstanceNodeOutcome PolardbxClient::updatePolarDBXInstanceNode(const UpdatePolarDBXInstanceNodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdatePolarDBXInstanceNodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdatePolarDBXInstanceNodeOutcome(UpdatePolarDBXInstanceNodeResult(outcome.result()));
else
return UpdatePolarDBXInstanceNodeOutcome(outcome.error());
}
void PolardbxClient::updatePolarDBXInstanceNodeAsync(const UpdatePolarDBXInstanceNodeRequest& request, const UpdatePolarDBXInstanceNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updatePolarDBXInstanceNode(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbxClient::UpdatePolarDBXInstanceNodeOutcomeCallable PolardbxClient::updatePolarDBXInstanceNodeCallable(const UpdatePolarDBXInstanceNodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdatePolarDBXInstanceNodeOutcome()>>(
[this, request]()
{
return this->updatePolarDBXInstanceNode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbxClient::UpgradeDBInstanceKernelVersionOutcome PolardbxClient::upgradeDBInstanceKernelVersion(const UpgradeDBInstanceKernelVersionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

62
polardbx/src/model/CancelPolarxOrderRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/CancelPolarxOrderRequest.h>
using AlibabaCloud::Polardbx::Model::CancelPolarxOrderRequest;
CancelPolarxOrderRequest::CancelPolarxOrderRequest() :
RpcServiceRequest("polardbx", "2020-02-02", "CancelPolarxOrder")
{
setMethod(HttpRequest::Method::Post);
}
CancelPolarxOrderRequest::~CancelPolarxOrderRequest()
{}
std::string CancelPolarxOrderRequest::getDBInstanceName()const
{
return dBInstanceName_;
}
void CancelPolarxOrderRequest::setDBInstanceName(const std::string& dBInstanceName)
{
dBInstanceName_ = dBInstanceName;
setParameter("DBInstanceName", dBInstanceName);
}
std::string CancelPolarxOrderRequest::getRegionId()const
{
return regionId_;
}
void CancelPolarxOrderRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CancelPolarxOrderRequest::getScaleOutToken()const
{
return scaleOutToken_;
}
void CancelPolarxOrderRequest::setScaleOutToken(const std::string& scaleOutToken)
{
scaleOutToken_ = scaleOutToken;
setParameter("ScaleOutToken", scaleOutToken);
}

44
polardbx/src/model/CancelPolarxOrderResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/CancelPolarxOrderResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardbx;
using namespace AlibabaCloud::Polardbx::Model;
CancelPolarxOrderResult::CancelPolarxOrderResult() :
ServiceResult()
{}
CancelPolarxOrderResult::CancelPolarxOrderResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CancelPolarxOrderResult::~CancelPolarxOrderResult()
{}
void CancelPolarxOrderResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

53
polardbx/src/model/CreateDBInstanceRequest.cc
View File

@@ -27,6 +27,28 @@ CreateDBInstanceRequest::CreateDBInstanceRequest() :
CreateDBInstanceRequest::~CreateDBInstanceRequest()
{}
std::string CreateDBInstanceRequest::getNetworkType()const
{
return networkType_;
}
void CreateDBInstanceRequest::setNetworkType(const std::string& networkType)
{
networkType_ = networkType;
setParameter("NetworkType", networkType);
}
std::string CreateDBInstanceRequest::getEngineVersion()const
{
return engineVersion_;
}
void CreateDBInstanceRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
std::string CreateDBInstanceRequest::getResourceGroupId()const
{
return resourceGroupId_;
@@ -49,17 +71,6 @@ void CreateDBInstanceRequest::setDBNodeClass(const std::string& dBNodeClass)
setParameter("DBNodeClass", dBNodeClass);
}
std::string CreateDBInstanceRequest::getDBInstanceDescription()const
{
return dBInstanceDescription_;
}
void CreateDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
{
dBInstanceDescription_ = dBInstanceDescription;
setParameter("DBInstanceDescription", dBInstanceDescription);
}
std::string CreateDBInstanceRequest::getPeriod()const
{
return period_;
@@ -71,15 +82,15 @@ void CreateDBInstanceRequest::setPeriod(const std::string& period)
setParameter("Period", period);
}
std::string CreateDBInstanceRequest::getSecurityIPList()const
bool CreateDBInstanceRequest::getIsReadDBInstance()const
{
return securityIPList_;
return isReadDBInstance_;
}
void CreateDBInstanceRequest::setSecurityIPList(const std::string& securityIPList)
void CreateDBInstanceRequest::setIsReadDBInstance(bool isReadDBInstance)
{
securityIPList_ = securityIPList;
setParameter("SecurityIPList", securityIPList);
isReadDBInstance_ = isReadDBInstance;
setParameter("IsReadDBInstance", isReadDBInstance ? "true" : "false");
}
std::string CreateDBInstanceRequest::getVSwitchId()const
@@ -115,15 +126,15 @@ void CreateDBInstanceRequest::setZoneId(const std::string& zoneId)
setParameter("ZoneId", zoneId);
}
std::string CreateDBInstanceRequest::getInstanceNetworkType()const
std::string CreateDBInstanceRequest::getPrimaryDBInstanceName()const
{
return instanceNetworkType_;
return primaryDBInstanceName_;
}
void CreateDBInstanceRequest::setInstanceNetworkType(const std::string& instanceNetworkType)
void CreateDBInstanceRequest::setPrimaryDBInstanceName(const std::string& primaryDBInstanceName)
{
instanceNetworkType_ = instanceNetworkType;
setParameter("InstanceNetworkType", instanceNetworkType);
primaryDBInstanceName_ = primaryDBInstanceName;
setParameter("PrimaryDBInstanceName", primaryDBInstanceName);
}
std::string CreateDBInstanceRequest::getClientToken()const

14
polardbx/src/model/CreateDBInstanceResult.cc
View File

@@ -43,28 +43,14 @@ void CreateDBInstanceResult::parse(const std::string &payload)
dBInstanceName_ = value["DBInstanceName"].asString();
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
if(!value["ConnectionString"].isNull())
connectionString_ = value["ConnectionString"].asString();
if(!value["Port"].isNull())
port_ = std::stoi(value["Port"].asString());
}
int CreateDBInstanceResult::getPort()const
{
return port_;
}
std::string CreateDBInstanceResult::getOrderId()const
{
return orderId_;
}
std::string CreateDBInstanceResult::getConnectionString()const
{
return connectionString_;
}
std::string CreateDBInstanceResult::getDBInstanceName()const
{
return dBInstanceName_;

62
polardbx/src/model/CreatePolarxOrderRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/CreatePolarxOrderRequest.h>
using AlibabaCloud::Polardbx::Model::CreatePolarxOrderRequest;
CreatePolarxOrderRequest::CreatePolarxOrderRequest() :
RpcServiceRequest("polardbx", "2020-02-02", "CreatePolarxOrder")
{
setMethod(HttpRequest::Method::Post);
}
CreatePolarxOrderRequest::~CreatePolarxOrderRequest()
{}
std::string CreatePolarxOrderRequest::getDBInstanceName()const
{
return dBInstanceName_;
}
void CreatePolarxOrderRequest::setDBInstanceName(const std::string& dBInstanceName)
{
dBInstanceName_ = dBInstanceName;
setParameter("DBInstanceName", dBInstanceName);
}
std::string CreatePolarxOrderRequest::getRegionId()const
{
return regionId_;
}
void CreatePolarxOrderRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreatePolarxOrderRequest::getNodeCount()const
{
return nodeCount_;
}
void CreatePolarxOrderRequest::setNodeCount(const std::string& nodeCount)
{
nodeCount_ = nodeCount;
setParameter("NodeCount", nodeCount);
}

59
polardbx/src/model/CreatePolarxOrderResult.cc Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/CreatePolarxOrderResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardbx;
using namespace AlibabaCloud::Polardbx::Model;
CreatePolarxOrderResult::CreatePolarxOrderResult() :
ServiceResult()
{}
CreatePolarxOrderResult::CreatePolarxOrderResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreatePolarxOrderResult::~CreatePolarxOrderResult()
{}
void CreatePolarxOrderResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allOrderResultListNode = value["OrderResultList"]["OrderResult"];
for (auto valueOrderResultListOrderResult : allOrderResultListNode)
{
OrderResult orderResultListObject;
if(!valueOrderResultListOrderResult["OrderId"].isNull())
orderResultListObject.orderId = std::stol(valueOrderResultListOrderResult["OrderId"].asString());
if(!valueOrderResultListOrderResult["DBInstanceName"].isNull())
orderResultListObject.dBInstanceName = valueOrderResultListOrderResult["DBInstanceName"].asString();
orderResultList_.push_back(orderResultListObject);
}
}
std::vector<CreatePolarxOrderResult::OrderResult> CreatePolarxOrderResult::getOrderResultList()const
{
return orderResultList_;
}

6
polardbx/src/model/DescribeTasksResult.cc
View File

@@ -57,14 +57,16 @@ void DescribeTasksResult::parse(const std::string &payload)
itemsObject.taskId = valueItemsTaskProgressInfo["TaskId"].asString();
if(!valueItemsTaskProgressInfo["Progress"].isNull())
itemsObject.progress = valueItemsTaskProgressInfo["Progress"].asString();
if(!valueItemsTaskProgressInfo["ExpectedFinishTime"].isNull())
itemsObject.expectedFinishTime = valueItemsTaskProgressInfo["ExpectedFinishTime"].asString();
if(!valueItemsTaskProgressInfo["FinishTime"].isNull())
itemsObject.finishTime1 = valueItemsTaskProgressInfo["FinishTime"].asString();
if(!valueItemsTaskProgressInfo["Status"].isNull())
itemsObject.status = valueItemsTaskProgressInfo["Status"].asString();
if(!valueItemsTaskProgressInfo["TaskErrorCode"].isNull())
itemsObject.taskErrorCode = valueItemsTaskProgressInfo["TaskErrorCode"].asString();
if(!valueItemsTaskProgressInfo["TaskErrorMessage"].isNull())
itemsObject.taskErrorMessage = valueItemsTaskProgressInfo["TaskErrorMessage"].asString();
if(!valueItemsTaskProgressInfo["ScaleOutToken"].isNull())
itemsObject.scaleOutToken = valueItemsTaskProgressInfo["ScaleOutToken"].asString();
items_.push_back(itemsObject);
}
if(!value["TotalRecordCount"].isNull())

62
polardbx/src/model/GetPolarXPriceRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/GetPolarXPriceRequest.h>
using AlibabaCloud::Polardbx::Model::GetPolarXPriceRequest;
GetPolarXPriceRequest::GetPolarXPriceRequest() :
RpcServiceRequest("polardbx", "2020-02-02", "GetPolarXPrice")
{
setMethod(HttpRequest::Method::Post);
}
GetPolarXPriceRequest::~GetPolarXPriceRequest()
{}
std::string GetPolarXPriceRequest::getDBInstanceName()const
{
return dBInstanceName_;
}
void GetPolarXPriceRequest::setDBInstanceName(const std::string& dBInstanceName)
{
dBInstanceName_ = dBInstanceName;
setParameter("DBInstanceName", dBInstanceName);
}
std::string GetPolarXPriceRequest::getRegionId()const
{
return regionId_;
}
void GetPolarXPriceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string GetPolarXPriceRequest::getNodeCount()const
{
return nodeCount_;
}
void GetPolarXPriceRequest::setNodeCount(const std::string& nodeCount)
{
nodeCount_ = nodeCount;
setParameter("NodeCount", nodeCount);
}

79
polardbx/src/model/GetPolarXPriceResult.cc Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/GetPolarXPriceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardbx;
using namespace AlibabaCloud::Polardbx::Model;
GetPolarXPriceResult::GetPolarXPriceResult() :
ServiceResult()
{}
GetPolarXPriceResult::GetPolarXPriceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetPolarXPriceResult::~GetPolarXPriceResult()
{}
void GetPolarXPriceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allOrderPriceListNode = value["OrderPriceList"]["OrderPrice"];
for (auto valueOrderPriceListOrderPrice : allOrderPriceListNode)
{
OrderPrice orderPriceListObject;
if(!valueOrderPriceListOrderPrice["DBInstanceName"].isNull())
orderPriceListObject.dBInstanceName = valueOrderPriceListOrderPrice["DBInstanceName"].asString();
if(!valueOrderPriceListOrderPrice["TotalCostAmount"].isNull())
orderPriceListObject.totalCostAmount = valueOrderPriceListOrderPrice["TotalCostAmount"].asString();
if(!valueOrderPriceListOrderPrice["DiscountAmount"].isNull())
orderPriceListObject.discountAmount = valueOrderPriceListOrderPrice["DiscountAmount"].asString();
if(!valueOrderPriceListOrderPrice["TradeAmount"].isNull())
orderPriceListObject.tradeAmount = valueOrderPriceListOrderPrice["TradeAmount"].asString();
if(!valueOrderPriceListOrderPrice["OriginalAmount"].isNull())
orderPriceListObject.originalAmount = valueOrderPriceListOrderPrice["OriginalAmount"].asString();
if(!valueOrderPriceListOrderPrice["PayType"].isNull())
orderPriceListObject.payType = valueOrderPriceListOrderPrice["PayType"].asString();
auto allRulesNode = valueOrderPriceListOrderPrice["Rules"]["Rule"];
for (auto valueOrderPriceListOrderPriceRulesRule : allRulesNode)
{
OrderPrice::Rule rulesObject;
if(!valueOrderPriceListOrderPriceRulesRule["RuleDescId"].isNull())
rulesObject.ruleDescId = std::stol(valueOrderPriceListOrderPriceRulesRule["RuleDescId"].asString());
if(!valueOrderPriceListOrderPriceRulesRule["Name"].isNull())
rulesObject.name = valueOrderPriceListOrderPriceRulesRule["Name"].asString();
if(!valueOrderPriceListOrderPriceRulesRule["Title"].isNull())
rulesObject.title = valueOrderPriceListOrderPriceRulesRule["Title"].asString();
orderPriceListObject.rules.push_back(rulesObject);
}
orderPriceList_.push_back(orderPriceListObject);
}
}
std::vector<GetPolarXPriceResult::OrderPrice> GetPolarXPriceResult::getOrderPriceList()const
{
return orderPriceList_;
}

62
polardbx/src/model/GetPolarxCommodityRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/GetPolarxCommodityRequest.h>
using AlibabaCloud::Polardbx::Model::GetPolarxCommodityRequest;
GetPolarxCommodityRequest::GetPolarxCommodityRequest() :
RpcServiceRequest("polardbx", "2020-02-02", "GetPolarxCommodity")
{
setMethod(HttpRequest::Method::Post);
}
GetPolarxCommodityRequest::~GetPolarxCommodityRequest()
{}
std::string GetPolarxCommodityRequest::getDBInstanceName()const
{
return dBInstanceName_;
}
void GetPolarxCommodityRequest::setDBInstanceName(const std::string& dBInstanceName)
{
dBInstanceName_ = dBInstanceName;
setParameter("DBInstanceName", dBInstanceName);
}
std::string GetPolarxCommodityRequest::getRegionId()const
{
return regionId_;
}
void GetPolarxCommodityRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string GetPolarxCommodityRequest::getOrderType()const
{
return orderType_;
}
void GetPolarxCommodityRequest::setOrderType(const std::string& orderType)
{
orderType_ = orderType;
setParameter("OrderType", orderType);
}

157
polardbx/src/model/GetPolarxCommodityResult.cc Normal file
View File

@@ -0,0 +1,157 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/GetPolarxCommodityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardbx;
using namespace AlibabaCloud::Polardbx::Model;
GetPolarxCommodityResult::GetPolarxCommodityResult() :
ServiceResult()
{}
GetPolarxCommodityResult::GetPolarxCommodityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetPolarxCommodityResult::~GetPolarxCommodityResult()
{}
void GetPolarxCommodityResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allComponentListNode = value["ComponentList"]["Component"];
for (auto valueComponentListComponent : allComponentListNode)
{
Component componentListObject;
if(!valueComponentListComponent["Name"].isNull())
componentListObject.name = valueComponentListComponent["Name"].asString();
if(!valueComponentListComponent["Type"].isNull())
componentListObject.type = valueComponentListComponent["Type"].asString();
auto allValues = value["Values"]["Value"];
for (auto value : allValues)
componentListObject.values.push_back(value.asString());
componentList_.push_back(componentListObject);
}
auto dBInstanceNode = value["DBInstance"];
if(!dBInstanceNode["Status"].isNull())
dBInstance_.status = dBInstanceNode["Status"].asString();
if(!dBInstanceNode["Description"].isNull())
dBInstance_.description = dBInstanceNode["Description"].asString();
if(!dBInstanceNode["ZoneId"].isNull())
dBInstance_.zoneId = dBInstanceNode["ZoneId"].asString();
if(!dBInstanceNode["VPCId"].isNull())
dBInstance_.vPCId = dBInstanceNode["VPCId"].asString();
if(!dBInstanceNode["CreateTime"].isNull())
dBInstance_.createTime = dBInstanceNode["CreateTime"].asString();
if(!dBInstanceNode["Expired"].isNull())
dBInstance_.expired = dBInstanceNode["Expired"].asString();
if(!dBInstanceNode["PayType"].isNull())
dBInstance_.payType = dBInstanceNode["PayType"].asString();
if(!dBInstanceNode["DBType"].isNull())
dBInstance_.dBType = dBInstanceNode["DBType"].asString();
if(!dBInstanceNode["LockMode"].isNull())
dBInstance_.lockMode = dBInstanceNode["LockMode"].asString();
if(!dBInstanceNode["StorageUsed"].isNull())
dBInstance_.storageUsed = std::stol(dBInstanceNode["StorageUsed"].asString());
if(!dBInstanceNode["DBVersion"].isNull())
dBInstance_.dBVersion = dBInstanceNode["DBVersion"].asString();
if(!dBInstanceNode["Network"].isNull())
dBInstance_.network = dBInstanceNode["Network"].asString();
if(!dBInstanceNode["RegionId"].isNull())
dBInstance_.regionId = dBInstanceNode["RegionId"].asString();
if(!dBInstanceNode["Engine"].isNull())
dBInstance_.engine = dBInstanceNode["Engine"].asString();
if(!dBInstanceNode["Id"].isNull())
dBInstance_.id = dBInstanceNode["Id"].asString();
if(!dBInstanceNode["ConnectionString"].isNull())
dBInstance_.connectionString = dBInstanceNode["ConnectionString"].asString();
if(!dBInstanceNode["Port"].isNull())
dBInstance_.port = dBInstanceNode["Port"].asString();
if(!dBInstanceNode["MinorVersion"].isNull())
dBInstance_.minorVersion = dBInstanceNode["MinorVersion"].asString();
if(!dBInstanceNode["LatestMinorVersion"].isNull())
dBInstance_.latestMinorVersion = dBInstanceNode["LatestMinorVersion"].asString();
if(!dBInstanceNode["DBNodeCount"].isNull())
dBInstance_.dBNodeCount = std::stoi(dBInstanceNode["DBNodeCount"].asString());
if(!dBInstanceNode["DBInstanceType"].isNull())
dBInstance_.dBInstanceType = dBInstanceNode["DBInstanceType"].asString();
if(!dBInstanceNode["MaintainStartTime"].isNull())
dBInstance_.maintainStartTime = dBInstanceNode["MaintainStartTime"].asString();
if(!dBInstanceNode["MaintainEndTime"].isNull())
dBInstance_.maintainEndTime = dBInstanceNode["MaintainEndTime"].asString();
if(!dBInstanceNode["VSwitchId"].isNull())
dBInstance_.vSwitchId = dBInstanceNode["VSwitchId"].asString();
if(!dBInstanceNode["CommodityCode"].isNull())
dBInstance_.commodityCode = dBInstanceNode["CommodityCode"].asString();
if(!dBInstanceNode["ExpireDate"].isNull())
dBInstance_.expireDate = dBInstanceNode["ExpireDate"].asString();
if(!dBInstanceNode["Type"].isNull())
dBInstance_.type = dBInstanceNode["Type"].asString();
if(!dBInstanceNode["DBNodeClass"].isNull())
dBInstance_.dBNodeClass = dBInstanceNode["DBNodeClass"].asString();
auto allDBNodesNode = dBInstanceNode["DBNodes"]["DBNode"];
for (auto dBInstanceNodeDBNodesDBNode : allDBNodesNode)
{
DBInstance::DBNode dBNodeObject;
if(!dBInstanceNodeDBNodesDBNode["Id"].isNull())
dBNodeObject.id = dBInstanceNodeDBNodesDBNode["Id"].asString();
if(!dBInstanceNodeDBNodesDBNode["NodeClass"].isNull())
dBNodeObject.nodeClass = dBInstanceNodeDBNodesDBNode["NodeClass"].asString();
if(!dBInstanceNodeDBNodesDBNode["RegionId"].isNull())
dBNodeObject.regionId = dBInstanceNodeDBNodesDBNode["RegionId"].asString();
if(!dBInstanceNodeDBNodesDBNode["ZoneId"].isNull())
dBNodeObject.zoneId = dBInstanceNodeDBNodesDBNode["ZoneId"].asString();
dBInstance_.dBNodes.push_back(dBNodeObject);
}
auto allConnAddrsNode = dBInstanceNode["ConnAddrs"]["ConnAddr"];
for (auto dBInstanceNodeConnAddrsConnAddr : allConnAddrsNode)
{
DBInstance::ConnAddr connAddrObject;
if(!dBInstanceNodeConnAddrsConnAddr["ConnectionString"].isNull())
connAddrObject.connectionString = dBInstanceNodeConnAddrsConnAddr["ConnectionString"].asString();
if(!dBInstanceNodeConnAddrsConnAddr["Port"].isNull())
connAddrObject.port = dBInstanceNodeConnAddrsConnAddr["Port"].asString();
if(!dBInstanceNodeConnAddrsConnAddr["Type"].isNull())
connAddrObject.type = dBInstanceNodeConnAddrsConnAddr["Type"].asString();
if(!dBInstanceNodeConnAddrsConnAddr["VPCId"].isNull())
connAddrObject.vPCId = dBInstanceNodeConnAddrsConnAddr["VPCId"].asString();
if(!dBInstanceNodeConnAddrsConnAddr["VSwitchId"].isNull())
connAddrObject.vSwitchId = dBInstanceNodeConnAddrsConnAddr["VSwitchId"].asString();
dBInstance_.connAddrs.push_back(connAddrObject);
}
auto allReadDBInstances = dBInstanceNode["ReadDBInstances"]["ReadDBInstance"];
for (auto value : allReadDBInstances)
dBInstance_.readDBInstances.push_back(value.asString());
}
GetPolarxCommodityResult::DBInstance GetPolarxCommodityResult::getDBInstance()const
{
return dBInstance_;
}
std::vector<GetPolarxCommodityResult::Component> GetPolarxCommodityResult::getComponentList()const
{
return componentList_;
}

7
polardbx/src/model/ModifyDBInstanceClassResult.cc
View File

@@ -39,6 +39,13 @@ void ModifyDBInstanceClassResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
}
std::string ModifyDBInstanceClassResult::getOrderId()const
{
return orderId_;
}

62
polardbx/src/model/RetryPolarxOrderRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/RetryPolarxOrderRequest.h>
using AlibabaCloud::Polardbx::Model::RetryPolarxOrderRequest;
RetryPolarxOrderRequest::RetryPolarxOrderRequest() :
RpcServiceRequest("polardbx", "2020-02-02", "RetryPolarxOrder")
{
setMethod(HttpRequest::Method::Post);
}
RetryPolarxOrderRequest::~RetryPolarxOrderRequest()
{}
std::string RetryPolarxOrderRequest::getDBInstanceName()const
{
return dBInstanceName_;
}
void RetryPolarxOrderRequest::setDBInstanceName(const std::string& dBInstanceName)
{
dBInstanceName_ = dBInstanceName;
setParameter("DBInstanceName", dBInstanceName);
}
std::string RetryPolarxOrderRequest::getRegionId()const
{
return regionId_;
}
void RetryPolarxOrderRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string RetryPolarxOrderRequest::getScaleOutToken()const
{
return scaleOutToken_;
}
void RetryPolarxOrderRequest::setScaleOutToken(const std::string& scaleOutToken)
{
scaleOutToken_ = scaleOutToken;
setParameter("ScaleOutToken", scaleOutToken);
}

44
polardbx/src/model/RetryPolarxOrderResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/RetryPolarxOrderResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardbx;
using namespace AlibabaCloud::Polardbx::Model;
RetryPolarxOrderResult::RetryPolarxOrderResult() :
ServiceResult()
{}
RetryPolarxOrderResult::RetryPolarxOrderResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RetryPolarxOrderResult::~RetryPolarxOrderResult()
{}
void RetryPolarxOrderResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

73
polardbx/src/model/UpdatePolarDBXInstanceNodeRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeRequest.h>
using AlibabaCloud::Polardbx::Model::UpdatePolarDBXInstanceNodeRequest;
UpdatePolarDBXInstanceNodeRequest::UpdatePolarDBXInstanceNodeRequest() :
RpcServiceRequest("polardbx", "2020-02-02", "UpdatePolarDBXInstanceNode")
{
setMethod(HttpRequest::Method::Post);
}
UpdatePolarDBXInstanceNodeRequest::~UpdatePolarDBXInstanceNodeRequest()
{}
std::string UpdatePolarDBXInstanceNodeRequest::getDBInstanceName()const
{
return dBInstanceName_;
}
void UpdatePolarDBXInstanceNodeRequest::setDBInstanceName(const std::string& dBInstanceName)
{
dBInstanceName_ = dBInstanceName;
setParameter("DBInstanceName", dBInstanceName);
}
std::string UpdatePolarDBXInstanceNodeRequest::getClientToken()const
{
return clientToken_;
}
void UpdatePolarDBXInstanceNodeRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string UpdatePolarDBXInstanceNodeRequest::getRegionId()const
{
return regionId_;
}
void UpdatePolarDBXInstanceNodeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string UpdatePolarDBXInstanceNodeRequest::getDbInstanceNodeCount()const
{
return dbInstanceNodeCount_;
}
void UpdatePolarDBXInstanceNodeRequest::setDbInstanceNodeCount(const std::string& dbInstanceNodeCount)
{
dbInstanceNodeCount_ = dbInstanceNodeCount;
setParameter("DbInstanceNodeCount", dbInstanceNodeCount);
}

51
polardbx/src/model/UpdatePolarDBXInstanceNodeResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardbx;
using namespace AlibabaCloud::Polardbx::Model;
UpdatePolarDBXInstanceNodeResult::UpdatePolarDBXInstanceNodeResult() :
ServiceResult()
{}
UpdatePolarDBXInstanceNodeResult::UpdatePolarDBXInstanceNodeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdatePolarDBXInstanceNodeResult::~UpdatePolarDBXInstanceNodeResult()
{}
void UpdatePolarDBXInstanceNodeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
}
std::string UpdatePolarDBXInstanceNodeResult::getOrderId()const
{
return orderId_;
}