diff --git a/VERSION b/VERSION index af0b6a995..d36bd8300 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.2043 \ No newline at end of file +1.36.2044 \ No newline at end of file diff --git a/resourcemanager/CMakeLists.txt b/resourcemanager/CMakeLists.txt index ef57fe57c..4e45d3765 100644 --- a/resourcemanager/CMakeLists.txt +++ b/resourcemanager/CMakeLists.txt @@ -41,6 +41,8 @@ set(resourcemanager_public_header_model include/alibabacloud/resourcemanager/model/ChangeAccountEmailResult.h include/alibabacloud/resourcemanager/model/CheckAccountDeleteRequest.h include/alibabacloud/resourcemanager/model/CheckAccountDeleteResult.h + include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleRequest.h + include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleResult.h include/alibabacloud/resourcemanager/model/CreateCloudAccountRequest.h include/alibabacloud/resourcemanager/model/CreateCloudAccountResult.h include/alibabacloud/resourcemanager/model/CreateControlPolicyRequest.h @@ -63,6 +65,8 @@ set(resourcemanager_public_header_model include/alibabacloud/resourcemanager/model/DeclineHandshakeResult.h include/alibabacloud/resourcemanager/model/DeleteAccountRequest.h include/alibabacloud/resourcemanager/model/DeleteAccountResult.h + include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleRequest.h + include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleResult.h include/alibabacloud/resourcemanager/model/DeleteControlPolicyRequest.h include/alibabacloud/resourcemanager/model/DeleteControlPolicyResult.h include/alibabacloud/resourcemanager/model/DeleteFolderRequest.h @@ -85,8 +89,16 @@ set(resourcemanager_public_header_model include/alibabacloud/resourcemanager/model/DetachControlPolicyResult.h include/alibabacloud/resourcemanager/model/DetachPolicyRequest.h include/alibabacloud/resourcemanager/model/DetachPolicyResult.h + include/alibabacloud/resourcemanager/model/DisableAssociatedTransferRequest.h + include/alibabacloud/resourcemanager/model/DisableAssociatedTransferResult.h + include/alibabacloud/resourcemanager/model/DisableAutoGroupingRequest.h + include/alibabacloud/resourcemanager/model/DisableAutoGroupingResult.h include/alibabacloud/resourcemanager/model/DisableControlPolicyRequest.h include/alibabacloud/resourcemanager/model/DisableControlPolicyResult.h + include/alibabacloud/resourcemanager/model/EnableAssociatedTransferRequest.h + include/alibabacloud/resourcemanager/model/EnableAssociatedTransferResult.h + include/alibabacloud/resourcemanager/model/EnableAutoGroupingRequest.h + include/alibabacloud/resourcemanager/model/EnableAutoGroupingResult.h include/alibabacloud/resourcemanager/model/EnableControlPolicyRequest.h include/alibabacloud/resourcemanager/model/EnableControlPolicyResult.h include/alibabacloud/resourcemanager/model/EnableResourceDirectoryRequest.h @@ -97,6 +109,10 @@ set(resourcemanager_public_header_model include/alibabacloud/resourcemanager/model/GetAccountDeletionCheckResultResult.h include/alibabacloud/resourcemanager/model/GetAccountDeletionStatusRequest.h include/alibabacloud/resourcemanager/model/GetAccountDeletionStatusResult.h + include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleRequest.h + include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleResult.h + include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusRequest.h + include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusResult.h include/alibabacloud/resourcemanager/model/GetControlPolicyRequest.h include/alibabacloud/resourcemanager/model/GetControlPolicyResult.h include/alibabacloud/resourcemanager/model/GetControlPolicyEnablementStatusRequest.h @@ -129,6 +145,10 @@ set(resourcemanager_public_header_model include/alibabacloud/resourcemanager/model/ListAccountsForParentResult.h include/alibabacloud/resourcemanager/model/ListAncestorsRequest.h include/alibabacloud/resourcemanager/model/ListAncestorsResult.h + include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingRequest.h + include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingResult.h + include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesRequest.h + include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesResult.h include/alibabacloud/resourcemanager/model/ListControlPoliciesRequest.h include/alibabacloud/resourcemanager/model/ListControlPoliciesResult.h include/alibabacloud/resourcemanager/model/ListControlPolicyAttachmentsForTargetRequest.h @@ -195,6 +215,12 @@ set(resourcemanager_public_header_model include/alibabacloud/resourcemanager/model/UntagResourcesResult.h include/alibabacloud/resourcemanager/model/UpdateAccountRequest.h include/alibabacloud/resourcemanager/model/UpdateAccountResult.h + include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingRequest.h + include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingResult.h + include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigRequest.h + include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigResult.h + include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleRequest.h + include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleResult.h include/alibabacloud/resourcemanager/model/UpdateControlPolicyRequest.h include/alibabacloud/resourcemanager/model/UpdateControlPolicyResult.h include/alibabacloud/resourcemanager/model/UpdateFolderRequest.h @@ -226,6 +252,8 @@ set(resourcemanager_src src/model/ChangeAccountEmailResult.cc src/model/CheckAccountDeleteRequest.cc src/model/CheckAccountDeleteResult.cc + src/model/CreateAutoGroupingRuleRequest.cc + src/model/CreateAutoGroupingRuleResult.cc src/model/CreateCloudAccountRequest.cc src/model/CreateCloudAccountResult.cc src/model/CreateControlPolicyRequest.cc @@ -248,6 +276,8 @@ set(resourcemanager_src src/model/DeclineHandshakeResult.cc src/model/DeleteAccountRequest.cc src/model/DeleteAccountResult.cc + src/model/DeleteAutoGroupingRuleRequest.cc + src/model/DeleteAutoGroupingRuleResult.cc src/model/DeleteControlPolicyRequest.cc src/model/DeleteControlPolicyResult.cc src/model/DeleteFolderRequest.cc @@ -270,8 +300,16 @@ set(resourcemanager_src src/model/DetachControlPolicyResult.cc src/model/DetachPolicyRequest.cc src/model/DetachPolicyResult.cc + src/model/DisableAssociatedTransferRequest.cc + src/model/DisableAssociatedTransferResult.cc + src/model/DisableAutoGroupingRequest.cc + src/model/DisableAutoGroupingResult.cc src/model/DisableControlPolicyRequest.cc src/model/DisableControlPolicyResult.cc + src/model/EnableAssociatedTransferRequest.cc + src/model/EnableAssociatedTransferResult.cc + src/model/EnableAutoGroupingRequest.cc + src/model/EnableAutoGroupingResult.cc src/model/EnableControlPolicyRequest.cc src/model/EnableControlPolicyResult.cc src/model/EnableResourceDirectoryRequest.cc @@ -282,6 +320,10 @@ set(resourcemanager_src src/model/GetAccountDeletionCheckResultResult.cc src/model/GetAccountDeletionStatusRequest.cc src/model/GetAccountDeletionStatusResult.cc + src/model/GetAutoGroupingRuleRequest.cc + src/model/GetAutoGroupingRuleResult.cc + src/model/GetAutoGroupingStatusRequest.cc + src/model/GetAutoGroupingStatusResult.cc src/model/GetControlPolicyRequest.cc src/model/GetControlPolicyResult.cc src/model/GetControlPolicyEnablementStatusRequest.cc @@ -314,6 +356,10 @@ set(resourcemanager_src src/model/ListAccountsForParentResult.cc src/model/ListAncestorsRequest.cc src/model/ListAncestorsResult.cc + src/model/ListAssociatedTransferSettingRequest.cc + src/model/ListAssociatedTransferSettingResult.cc + src/model/ListAutoGroupingRulesRequest.cc + src/model/ListAutoGroupingRulesResult.cc src/model/ListControlPoliciesRequest.cc src/model/ListControlPoliciesResult.cc src/model/ListControlPolicyAttachmentsForTargetRequest.cc @@ -380,6 +426,12 @@ set(resourcemanager_src src/model/UntagResourcesResult.cc src/model/UpdateAccountRequest.cc src/model/UpdateAccountResult.cc + src/model/UpdateAssociatedTransferSettingRequest.cc + src/model/UpdateAssociatedTransferSettingResult.cc + src/model/UpdateAutoGroupingConfigRequest.cc + src/model/UpdateAutoGroupingConfigResult.cc + src/model/UpdateAutoGroupingRuleRequest.cc + src/model/UpdateAutoGroupingRuleResult.cc src/model/UpdateControlPolicyRequest.cc src/model/UpdateControlPolicyResult.cc src/model/UpdateFolderRequest.cc diff --git a/resourcemanager/include/alibabacloud/resourcemanager/ResourceManagerClient.h b/resourcemanager/include/alibabacloud/resourcemanager/ResourceManagerClient.h index 4c198f51c..6d1b258b3 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/ResourceManagerClient.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/ResourceManagerClient.h @@ -42,6 +42,8 @@ #include "model/ChangeAccountEmailResult.h" #include "model/CheckAccountDeleteRequest.h" #include "model/CheckAccountDeleteResult.h" +#include "model/CreateAutoGroupingRuleRequest.h" +#include "model/CreateAutoGroupingRuleResult.h" #include "model/CreateCloudAccountRequest.h" #include "model/CreateCloudAccountResult.h" #include "model/CreateControlPolicyRequest.h" @@ -64,6 +66,8 @@ #include "model/DeclineHandshakeResult.h" #include "model/DeleteAccountRequest.h" #include "model/DeleteAccountResult.h" +#include "model/DeleteAutoGroupingRuleRequest.h" +#include "model/DeleteAutoGroupingRuleResult.h" #include "model/DeleteControlPolicyRequest.h" #include "model/DeleteControlPolicyResult.h" #include "model/DeleteFolderRequest.h" @@ -86,8 +90,16 @@ #include "model/DetachControlPolicyResult.h" #include "model/DetachPolicyRequest.h" #include "model/DetachPolicyResult.h" +#include "model/DisableAssociatedTransferRequest.h" +#include "model/DisableAssociatedTransferResult.h" +#include "model/DisableAutoGroupingRequest.h" +#include "model/DisableAutoGroupingResult.h" #include "model/DisableControlPolicyRequest.h" #include "model/DisableControlPolicyResult.h" +#include "model/EnableAssociatedTransferRequest.h" +#include "model/EnableAssociatedTransferResult.h" +#include "model/EnableAutoGroupingRequest.h" +#include "model/EnableAutoGroupingResult.h" #include "model/EnableControlPolicyRequest.h" #include "model/EnableControlPolicyResult.h" #include "model/EnableResourceDirectoryRequest.h" @@ -98,6 +110,10 @@ #include "model/GetAccountDeletionCheckResultResult.h" #include "model/GetAccountDeletionStatusRequest.h" #include "model/GetAccountDeletionStatusResult.h" +#include "model/GetAutoGroupingRuleRequest.h" +#include "model/GetAutoGroupingRuleResult.h" +#include "model/GetAutoGroupingStatusRequest.h" +#include "model/GetAutoGroupingStatusResult.h" #include "model/GetControlPolicyRequest.h" #include "model/GetControlPolicyResult.h" #include "model/GetControlPolicyEnablementStatusRequest.h" @@ -130,6 +146,10 @@ #include "model/ListAccountsForParentResult.h" #include "model/ListAncestorsRequest.h" #include "model/ListAncestorsResult.h" +#include "model/ListAssociatedTransferSettingRequest.h" +#include "model/ListAssociatedTransferSettingResult.h" +#include "model/ListAutoGroupingRulesRequest.h" +#include "model/ListAutoGroupingRulesResult.h" #include "model/ListControlPoliciesRequest.h" #include "model/ListControlPoliciesResult.h" #include "model/ListControlPolicyAttachmentsForTargetRequest.h" @@ -196,6 +216,12 @@ #include "model/UntagResourcesResult.h" #include "model/UpdateAccountRequest.h" #include "model/UpdateAccountResult.h" +#include "model/UpdateAssociatedTransferSettingRequest.h" +#include "model/UpdateAssociatedTransferSettingResult.h" +#include "model/UpdateAutoGroupingConfigRequest.h" +#include "model/UpdateAutoGroupingConfigResult.h" +#include "model/UpdateAutoGroupingRuleRequest.h" +#include "model/UpdateAutoGroupingRuleResult.h" #include "model/UpdateControlPolicyRequest.h" #include "model/UpdateControlPolicyResult.h" #include "model/UpdateFolderRequest.h" @@ -243,6 +269,9 @@ namespace AlibabaCloud typedef Outcome CheckAccountDeleteOutcome; typedef std::future CheckAccountDeleteOutcomeCallable; typedef std::function&)> CheckAccountDeleteAsyncHandler; + typedef Outcome CreateAutoGroupingRuleOutcome; + typedef std::future CreateAutoGroupingRuleOutcomeCallable; + typedef std::function&)> CreateAutoGroupingRuleAsyncHandler; typedef Outcome CreateCloudAccountOutcome; typedef std::future CreateCloudAccountOutcomeCallable; typedef std::function&)> CreateCloudAccountAsyncHandler; @@ -276,6 +305,9 @@ namespace AlibabaCloud typedef Outcome DeleteAccountOutcome; typedef std::future DeleteAccountOutcomeCallable; typedef std::function&)> DeleteAccountAsyncHandler; + typedef Outcome DeleteAutoGroupingRuleOutcome; + typedef std::future DeleteAutoGroupingRuleOutcomeCallable; + typedef std::function&)> DeleteAutoGroupingRuleAsyncHandler; typedef Outcome DeleteControlPolicyOutcome; typedef std::future DeleteControlPolicyOutcomeCallable; typedef std::function&)> DeleteControlPolicyAsyncHandler; @@ -309,9 +341,21 @@ namespace AlibabaCloud typedef Outcome DetachPolicyOutcome; typedef std::future DetachPolicyOutcomeCallable; typedef std::function&)> DetachPolicyAsyncHandler; + typedef Outcome DisableAssociatedTransferOutcome; + typedef std::future DisableAssociatedTransferOutcomeCallable; + typedef std::function&)> DisableAssociatedTransferAsyncHandler; + typedef Outcome DisableAutoGroupingOutcome; + typedef std::future DisableAutoGroupingOutcomeCallable; + typedef std::function&)> DisableAutoGroupingAsyncHandler; typedef Outcome DisableControlPolicyOutcome; typedef std::future DisableControlPolicyOutcomeCallable; typedef std::function&)> DisableControlPolicyAsyncHandler; + typedef Outcome EnableAssociatedTransferOutcome; + typedef std::future EnableAssociatedTransferOutcomeCallable; + typedef std::function&)> EnableAssociatedTransferAsyncHandler; + typedef Outcome EnableAutoGroupingOutcome; + typedef std::future EnableAutoGroupingOutcomeCallable; + typedef std::function&)> EnableAutoGroupingAsyncHandler; typedef Outcome EnableControlPolicyOutcome; typedef std::future EnableControlPolicyOutcomeCallable; typedef std::function&)> EnableControlPolicyAsyncHandler; @@ -327,6 +371,12 @@ namespace AlibabaCloud typedef Outcome GetAccountDeletionStatusOutcome; typedef std::future GetAccountDeletionStatusOutcomeCallable; typedef std::function&)> GetAccountDeletionStatusAsyncHandler; + typedef Outcome GetAutoGroupingRuleOutcome; + typedef std::future GetAutoGroupingRuleOutcomeCallable; + typedef std::function&)> GetAutoGroupingRuleAsyncHandler; + typedef Outcome GetAutoGroupingStatusOutcome; + typedef std::future GetAutoGroupingStatusOutcomeCallable; + typedef std::function&)> GetAutoGroupingStatusAsyncHandler; typedef Outcome GetControlPolicyOutcome; typedef std::future GetControlPolicyOutcomeCallable; typedef std::function&)> GetControlPolicyAsyncHandler; @@ -375,6 +425,12 @@ namespace AlibabaCloud typedef Outcome ListAncestorsOutcome; typedef std::future ListAncestorsOutcomeCallable; typedef std::function&)> ListAncestorsAsyncHandler; + typedef Outcome ListAssociatedTransferSettingOutcome; + typedef std::future ListAssociatedTransferSettingOutcomeCallable; + typedef std::function&)> ListAssociatedTransferSettingAsyncHandler; + typedef Outcome ListAutoGroupingRulesOutcome; + typedef std::future ListAutoGroupingRulesOutcomeCallable; + typedef std::function&)> ListAutoGroupingRulesAsyncHandler; typedef Outcome ListControlPoliciesOutcome; typedef std::future ListControlPoliciesOutcomeCallable; typedef std::function&)> ListControlPoliciesAsyncHandler; @@ -474,6 +530,15 @@ namespace AlibabaCloud typedef Outcome UpdateAccountOutcome; typedef std::future UpdateAccountOutcomeCallable; typedef std::function&)> UpdateAccountAsyncHandler; + typedef Outcome UpdateAssociatedTransferSettingOutcome; + typedef std::future UpdateAssociatedTransferSettingOutcomeCallable; + typedef std::function&)> UpdateAssociatedTransferSettingAsyncHandler; + typedef Outcome UpdateAutoGroupingConfigOutcome; + typedef std::future UpdateAutoGroupingConfigOutcomeCallable; + typedef std::function&)> UpdateAutoGroupingConfigAsyncHandler; + typedef Outcome UpdateAutoGroupingRuleOutcome; + typedef std::future UpdateAutoGroupingRuleOutcomeCallable; + typedef std::function&)> UpdateAutoGroupingRuleAsyncHandler; typedef Outcome UpdateControlPolicyOutcome; typedef std::future UpdateControlPolicyOutcomeCallable; typedef std::function&)> UpdateControlPolicyAsyncHandler; @@ -521,6 +586,9 @@ namespace AlibabaCloud CheckAccountDeleteOutcome checkAccountDelete(const Model::CheckAccountDeleteRequest &request)const; void checkAccountDeleteAsync(const Model::CheckAccountDeleteRequest& request, const CheckAccountDeleteAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CheckAccountDeleteOutcomeCallable checkAccountDeleteCallable(const Model::CheckAccountDeleteRequest& request) const; + CreateAutoGroupingRuleOutcome createAutoGroupingRule(const Model::CreateAutoGroupingRuleRequest &request)const; + void createAutoGroupingRuleAsync(const Model::CreateAutoGroupingRuleRequest& request, const CreateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateAutoGroupingRuleOutcomeCallable createAutoGroupingRuleCallable(const Model::CreateAutoGroupingRuleRequest& request) const; CreateCloudAccountOutcome createCloudAccount(const Model::CreateCloudAccountRequest &request)const; void createCloudAccountAsync(const Model::CreateCloudAccountRequest& request, const CreateCloudAccountAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateCloudAccountOutcomeCallable createCloudAccountCallable(const Model::CreateCloudAccountRequest& request) const; @@ -554,6 +622,9 @@ namespace AlibabaCloud DeleteAccountOutcome deleteAccount(const Model::DeleteAccountRequest &request)const; void deleteAccountAsync(const Model::DeleteAccountRequest& request, const DeleteAccountAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DeleteAccountOutcomeCallable deleteAccountCallable(const Model::DeleteAccountRequest& request) const; + DeleteAutoGroupingRuleOutcome deleteAutoGroupingRule(const Model::DeleteAutoGroupingRuleRequest &request)const; + void deleteAutoGroupingRuleAsync(const Model::DeleteAutoGroupingRuleRequest& request, const DeleteAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteAutoGroupingRuleOutcomeCallable deleteAutoGroupingRuleCallable(const Model::DeleteAutoGroupingRuleRequest& request) const; DeleteControlPolicyOutcome deleteControlPolicy(const Model::DeleteControlPolicyRequest &request)const; void deleteControlPolicyAsync(const Model::DeleteControlPolicyRequest& request, const DeleteControlPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DeleteControlPolicyOutcomeCallable deleteControlPolicyCallable(const Model::DeleteControlPolicyRequest& request) const; @@ -587,9 +658,21 @@ namespace AlibabaCloud DetachPolicyOutcome detachPolicy(const Model::DetachPolicyRequest &request)const; void detachPolicyAsync(const Model::DetachPolicyRequest& request, const DetachPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DetachPolicyOutcomeCallable detachPolicyCallable(const Model::DetachPolicyRequest& request) const; + DisableAssociatedTransferOutcome disableAssociatedTransfer(const Model::DisableAssociatedTransferRequest &request)const; + void disableAssociatedTransferAsync(const Model::DisableAssociatedTransferRequest& request, const DisableAssociatedTransferAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DisableAssociatedTransferOutcomeCallable disableAssociatedTransferCallable(const Model::DisableAssociatedTransferRequest& request) const; + DisableAutoGroupingOutcome disableAutoGrouping(const Model::DisableAutoGroupingRequest &request)const; + void disableAutoGroupingAsync(const Model::DisableAutoGroupingRequest& request, const DisableAutoGroupingAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DisableAutoGroupingOutcomeCallable disableAutoGroupingCallable(const Model::DisableAutoGroupingRequest& request) const; DisableControlPolicyOutcome disableControlPolicy(const Model::DisableControlPolicyRequest &request)const; void disableControlPolicyAsync(const Model::DisableControlPolicyRequest& request, const DisableControlPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DisableControlPolicyOutcomeCallable disableControlPolicyCallable(const Model::DisableControlPolicyRequest& request) const; + EnableAssociatedTransferOutcome enableAssociatedTransfer(const Model::EnableAssociatedTransferRequest &request)const; + void enableAssociatedTransferAsync(const Model::EnableAssociatedTransferRequest& request, const EnableAssociatedTransferAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + EnableAssociatedTransferOutcomeCallable enableAssociatedTransferCallable(const Model::EnableAssociatedTransferRequest& request) const; + EnableAutoGroupingOutcome enableAutoGrouping(const Model::EnableAutoGroupingRequest &request)const; + void enableAutoGroupingAsync(const Model::EnableAutoGroupingRequest& request, const EnableAutoGroupingAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + EnableAutoGroupingOutcomeCallable enableAutoGroupingCallable(const Model::EnableAutoGroupingRequest& request) const; EnableControlPolicyOutcome enableControlPolicy(const Model::EnableControlPolicyRequest &request)const; void enableControlPolicyAsync(const Model::EnableControlPolicyRequest& request, const EnableControlPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; EnableControlPolicyOutcomeCallable enableControlPolicyCallable(const Model::EnableControlPolicyRequest& request) const; @@ -605,6 +688,12 @@ namespace AlibabaCloud GetAccountDeletionStatusOutcome getAccountDeletionStatus(const Model::GetAccountDeletionStatusRequest &request)const; void getAccountDeletionStatusAsync(const Model::GetAccountDeletionStatusRequest& request, const GetAccountDeletionStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetAccountDeletionStatusOutcomeCallable getAccountDeletionStatusCallable(const Model::GetAccountDeletionStatusRequest& request) const; + GetAutoGroupingRuleOutcome getAutoGroupingRule(const Model::GetAutoGroupingRuleRequest &request)const; + void getAutoGroupingRuleAsync(const Model::GetAutoGroupingRuleRequest& request, const GetAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetAutoGroupingRuleOutcomeCallable getAutoGroupingRuleCallable(const Model::GetAutoGroupingRuleRequest& request) const; + GetAutoGroupingStatusOutcome getAutoGroupingStatus(const Model::GetAutoGroupingStatusRequest &request)const; + void getAutoGroupingStatusAsync(const Model::GetAutoGroupingStatusRequest& request, const GetAutoGroupingStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetAutoGroupingStatusOutcomeCallable getAutoGroupingStatusCallable(const Model::GetAutoGroupingStatusRequest& request) const; GetControlPolicyOutcome getControlPolicy(const Model::GetControlPolicyRequest &request)const; void getControlPolicyAsync(const Model::GetControlPolicyRequest& request, const GetControlPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetControlPolicyOutcomeCallable getControlPolicyCallable(const Model::GetControlPolicyRequest& request) const; @@ -653,6 +742,12 @@ namespace AlibabaCloud ListAncestorsOutcome listAncestors(const Model::ListAncestorsRequest &request)const; void listAncestorsAsync(const Model::ListAncestorsRequest& request, const ListAncestorsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListAncestorsOutcomeCallable listAncestorsCallable(const Model::ListAncestorsRequest& request) const; + ListAssociatedTransferSettingOutcome listAssociatedTransferSetting(const Model::ListAssociatedTransferSettingRequest &request)const; + void listAssociatedTransferSettingAsync(const Model::ListAssociatedTransferSettingRequest& request, const ListAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAssociatedTransferSettingOutcomeCallable listAssociatedTransferSettingCallable(const Model::ListAssociatedTransferSettingRequest& request) const; + ListAutoGroupingRulesOutcome listAutoGroupingRules(const Model::ListAutoGroupingRulesRequest &request)const; + void listAutoGroupingRulesAsync(const Model::ListAutoGroupingRulesRequest& request, const ListAutoGroupingRulesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAutoGroupingRulesOutcomeCallable listAutoGroupingRulesCallable(const Model::ListAutoGroupingRulesRequest& request) const; ListControlPoliciesOutcome listControlPolicies(const Model::ListControlPoliciesRequest &request)const; void listControlPoliciesAsync(const Model::ListControlPoliciesRequest& request, const ListControlPoliciesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListControlPoliciesOutcomeCallable listControlPoliciesCallable(const Model::ListControlPoliciesRequest& request) const; @@ -752,6 +847,15 @@ namespace AlibabaCloud UpdateAccountOutcome updateAccount(const Model::UpdateAccountRequest &request)const; void updateAccountAsync(const Model::UpdateAccountRequest& request, const UpdateAccountAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UpdateAccountOutcomeCallable updateAccountCallable(const Model::UpdateAccountRequest& request) const; + UpdateAssociatedTransferSettingOutcome updateAssociatedTransferSetting(const Model::UpdateAssociatedTransferSettingRequest &request)const; + void updateAssociatedTransferSettingAsync(const Model::UpdateAssociatedTransferSettingRequest& request, const UpdateAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateAssociatedTransferSettingOutcomeCallable updateAssociatedTransferSettingCallable(const Model::UpdateAssociatedTransferSettingRequest& request) const; + UpdateAutoGroupingConfigOutcome updateAutoGroupingConfig(const Model::UpdateAutoGroupingConfigRequest &request)const; + void updateAutoGroupingConfigAsync(const Model::UpdateAutoGroupingConfigRequest& request, const UpdateAutoGroupingConfigAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateAutoGroupingConfigOutcomeCallable updateAutoGroupingConfigCallable(const Model::UpdateAutoGroupingConfigRequest& request) const; + UpdateAutoGroupingRuleOutcome updateAutoGroupingRule(const Model::UpdateAutoGroupingRuleRequest &request)const; + void updateAutoGroupingRuleAsync(const Model::UpdateAutoGroupingRuleRequest& request, const UpdateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateAutoGroupingRuleOutcomeCallable updateAutoGroupingRuleCallable(const Model::UpdateAutoGroupingRuleRequest& request) const; UpdateControlPolicyOutcome updateControlPolicy(const Model::UpdateControlPolicyRequest &request)const; void updateControlPolicyAsync(const Model::UpdateControlPolicyRequest& request, const UpdateControlPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UpdateControlPolicyOutcomeCallable updateControlPolicyCallable(const Model::UpdateControlPolicyRequest& request) const; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/AttachPolicyRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/AttachPolicyRequest.h index f0454d4b8..653d2fd30 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/AttachPolicyRequest.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/AttachPolicyRequest.h @@ -30,21 +30,21 @@ class ALIBABACLOUD_RESOURCEMANAGER_EXPORT AttachPolicyRequest : public RpcServic public: AttachPolicyRequest(); ~AttachPolicyRequest(); + std::string getResourceGroupId() const; + void setResourceGroupId(const std::string &resourceGroupId); std::string getPolicyType() const; void setPolicyType(const std::string &policyType); std::string getPrincipalType() const; void setPrincipalType(const std::string &principalType); - std::string getResourceGroupId() const; - void setResourceGroupId(const std::string &resourceGroupId); std::string getPolicyName() const; void setPolicyName(const std::string &policyName); std::string getPrincipalName() const; void setPrincipalName(const std::string &principalName); private: + std::string resourceGroupId_; std::string policyType_; std::string principalType_; - std::string resourceGroupId_; std::string policyName_; std::string principalName_; }; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleRequest.h new file mode 100644 index 000000000..d1b8a41a6 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleRequest.h @@ -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. + */ + +#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULEREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT CreateAutoGroupingRuleRequest : public RpcServiceRequest { +public: + struct RuleContents { + std::string targetResourceGroupCondition; + std::string autoGroupingScopeCondition; + }; + CreateAutoGroupingRuleRequest(); + ~CreateAutoGroupingRuleRequest(); + std::string getRuleDesc() const; + void setRuleDesc(const std::string &ruleDesc); + std::string getResourceTypesScope() const; + void setResourceTypesScope(const std::string &resourceTypesScope); + std::string getRuleName() const; + void setRuleName(const std::string &ruleName); + std::string getExcludeResourceGroupIdsScope() const; + void setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope); + std::string getRegionIdsScope() const; + void setRegionIdsScope(const std::string ®ionIdsScope); + std::string getResourceIdsScope() const; + void setResourceIdsScope(const std::string &resourceIdsScope); + std::vector getRuleContents() const; + void setRuleContents(const std::vector &ruleContents); + std::string getExcludeResourceTypesScope() const; + void setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope); + std::string getRuleType() const; + void setRuleType(const std::string &ruleType); + std::string getResourceGroupIdsScope() const; + void setResourceGroupIdsScope(const std::string &resourceGroupIdsScope); + std::string getExcludeRegionIdsScope() const; + void setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope); + std::string getExcludeResourceIdsScope() const; + void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope); + +private: + std::string ruleDesc_; + std::string resourceTypesScope_; + std::string ruleName_; + std::string excludeResourceGroupIdsScope_; + std::string regionIdsScope_; + std::string resourceIdsScope_; + std::vector ruleContents_; + std::string excludeResourceTypesScope_; + std::string ruleType_; + std::string resourceGroupIdsScope_; + std::string excludeRegionIdsScope_; + std::string excludeResourceIdsScope_; +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULEREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleResult.h new file mode 100644 index 000000000..966b3c00b --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleResult.h @@ -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_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULERESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT CreateAutoGroupingRuleResult : public ServiceResult + { + public: + + + CreateAutoGroupingRuleResult(); + explicit CreateAutoGroupingRuleResult(const std::string &payload); + ~CreateAutoGroupingRuleResult(); + std::string getRuleId()const; + + protected: + void parse(const std::string &payload); + private: + std::string ruleId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULERESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/CreateCloudAccountResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/CreateCloudAccountResult.h index aca29638a..70ed3d4a1 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/CreateCloudAccountResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/CreateCloudAccountResult.h @@ -37,8 +37,8 @@ namespace AlibabaCloud std::string status; std::string joinMethod; std::string modifyTime; - std::string type; std::string resourceDirectoryId; + std::string type; std::string accountId; std::string displayName; std::string folderId; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/CreateResourceGroupRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/CreateResourceGroupRequest.h index 84eb96e3e..86ebf5ace 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/CreateResourceGroupRequest.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/CreateResourceGroupRequest.h @@ -28,16 +28,23 @@ namespace ResourceManager { namespace Model { class ALIBABACLOUD_RESOURCEMANAGER_EXPORT CreateResourceGroupRequest : public RpcServiceRequest { public: + struct Tag { + std::string value; + std::string key; + }; CreateResourceGroupRequest(); ~CreateResourceGroupRequest(); std::string getDisplayName() const; void setDisplayName(const std::string &displayName); std::string getName() const; void setName(const std::string &name); + std::vector getTag() const; + void setTag(const std::vector &tag); private: std::string displayName_; std::string name_; + std::vector tag_; }; } // namespace Model } // namespace ResourceManager diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleRequest.h new file mode 100644 index 000000000..792d8c101 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleRequest.h @@ -0,0 +1,42 @@ +/* + * 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_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULEREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DeleteAutoGroupingRuleRequest : public RpcServiceRequest { +public: + DeleteAutoGroupingRuleRequest(); + ~DeleteAutoGroupingRuleRequest(); + std::string getRuleId() const; + void setRuleId(const std::string &ruleId); + +private: + std::string ruleId_; +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULEREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleResult.h new file mode 100644 index 000000000..2f448a01b --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleResult.h @@ -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_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULERESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DeleteAutoGroupingRuleResult : public ServiceResult + { + public: + + + DeleteAutoGroupingRuleResult(); + explicit DeleteAutoGroupingRuleResult(const std::string &payload); + ~DeleteAutoGroupingRuleResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULERESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/DetachPolicyRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/DetachPolicyRequest.h index 749298d48..8ab1860ea 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/DetachPolicyRequest.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/DetachPolicyRequest.h @@ -30,21 +30,21 @@ class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DetachPolicyRequest : public RpcServic public: DetachPolicyRequest(); ~DetachPolicyRequest(); + std::string getResourceGroupId() const; + void setResourceGroupId(const std::string &resourceGroupId); std::string getPolicyType() const; void setPolicyType(const std::string &policyType); std::string getPrincipalType() const; void setPrincipalType(const std::string &principalType); - std::string getResourceGroupId() const; - void setResourceGroupId(const std::string &resourceGroupId); std::string getPolicyName() const; void setPolicyName(const std::string &policyName); std::string getPrincipalName() const; void setPrincipalName(const std::string &principalName); private: + std::string resourceGroupId_; std::string policyType_; std::string principalType_; - std::string resourceGroupId_; std::string policyName_; std::string principalName_; }; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAssociatedTransferRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAssociatedTransferRequest.h new file mode 100644 index 000000000..aa71991b3 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAssociatedTransferRequest.h @@ -0,0 +1,39 @@ +/* + * 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_RESOURCEMANAGER_MODEL_DISABLEASSOCIATEDTRANSFERREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEASSOCIATEDTRANSFERREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DisableAssociatedTransferRequest : public RpcServiceRequest { +public: + DisableAssociatedTransferRequest(); + ~DisableAssociatedTransferRequest(); + +private: +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEASSOCIATEDTRANSFERREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAssociatedTransferResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAssociatedTransferResult.h new file mode 100644 index 000000000..0073f0c55 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAssociatedTransferResult.h @@ -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_RESOURCEMANAGER_MODEL_DISABLEASSOCIATEDTRANSFERRESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEASSOCIATEDTRANSFERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DisableAssociatedTransferResult : public ServiceResult + { + public: + + + DisableAssociatedTransferResult(); + explicit DisableAssociatedTransferResult(const std::string &payload); + ~DisableAssociatedTransferResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEASSOCIATEDTRANSFERRESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAutoGroupingRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAutoGroupingRequest.h new file mode 100644 index 000000000..166d7004e --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAutoGroupingRequest.h @@ -0,0 +1,39 @@ +/* + * 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_RESOURCEMANAGER_MODEL_DISABLEAUTOGROUPINGREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEAUTOGROUPINGREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DisableAutoGroupingRequest : public RpcServiceRequest { +public: + DisableAutoGroupingRequest(); + ~DisableAutoGroupingRequest(); + +private: +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEAUTOGROUPINGREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAutoGroupingResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAutoGroupingResult.h new file mode 100644 index 000000000..a8d63f131 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/DisableAutoGroupingResult.h @@ -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_RESOURCEMANAGER_MODEL_DISABLEAUTOGROUPINGRESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEAUTOGROUPINGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DisableAutoGroupingResult : public ServiceResult + { + public: + + + DisableAutoGroupingResult(); + explicit DisableAutoGroupingResult(const std::string &payload); + ~DisableAutoGroupingResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEAUTOGROUPINGRESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAssociatedTransferRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAssociatedTransferRequest.h new file mode 100644 index 000000000..1de0b0e74 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAssociatedTransferRequest.h @@ -0,0 +1,39 @@ +/* + * 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_RESOURCEMANAGER_MODEL_ENABLEASSOCIATEDTRANSFERREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEASSOCIATEDTRANSFERREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT EnableAssociatedTransferRequest : public RpcServiceRequest { +public: + EnableAssociatedTransferRequest(); + ~EnableAssociatedTransferRequest(); + +private: +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEASSOCIATEDTRANSFERREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAssociatedTransferResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAssociatedTransferResult.h new file mode 100644 index 000000000..e4f45a9e8 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAssociatedTransferResult.h @@ -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_RESOURCEMANAGER_MODEL_ENABLEASSOCIATEDTRANSFERRESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEASSOCIATEDTRANSFERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT EnableAssociatedTransferResult : public ServiceResult + { + public: + + + EnableAssociatedTransferResult(); + explicit EnableAssociatedTransferResult(const std::string &payload); + ~EnableAssociatedTransferResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEASSOCIATEDTRANSFERRESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAutoGroupingRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAutoGroupingRequest.h new file mode 100644 index 000000000..b3e579a4b --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAutoGroupingRequest.h @@ -0,0 +1,39 @@ +/* + * 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_RESOURCEMANAGER_MODEL_ENABLEAUTOGROUPINGREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEAUTOGROUPINGREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT EnableAutoGroupingRequest : public RpcServiceRequest { +public: + EnableAutoGroupingRequest(); + ~EnableAutoGroupingRequest(); + +private: +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEAUTOGROUPINGREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAutoGroupingResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAutoGroupingResult.h new file mode 100644 index 000000000..574df5934 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/EnableAutoGroupingResult.h @@ -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_RESOURCEMANAGER_MODEL_ENABLEAUTOGROUPINGRESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEAUTOGROUPINGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT EnableAutoGroupingResult : public ServiceResult + { + public: + + + EnableAutoGroupingResult(); + explicit EnableAutoGroupingResult(const std::string &payload); + ~EnableAutoGroupingResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEAUTOGROUPINGRESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleRequest.h new file mode 100644 index 000000000..25c90b09e --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleRequest.h @@ -0,0 +1,42 @@ +/* + * 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_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULEREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT GetAutoGroupingRuleRequest : public RpcServiceRequest { +public: + GetAutoGroupingRuleRequest(); + ~GetAutoGroupingRuleRequest(); + std::string getRuleId() const; + void setRuleId(const std::string &ruleId); + +private: + std::string ruleId_; +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULEREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleResult.h new file mode 100644 index 000000000..d0832ed9c --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleResult.h @@ -0,0 +1,75 @@ +/* + * 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_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULERESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT GetAutoGroupingRuleResult : public ServiceResult + { + public: + struct Rule + { + struct RuleContent + { + std::string autoGroupingScopeCondition; + std::string ruleContentId; + std::string targetResourceGroupCondition; + }; + std::string modifyTime; + std::string excludeResourceGroupIdsScope; + std::string excludeResourceIdsScope; + std::string excludeResourceTypesScope; + std::string resourceIdsScope; + std::vector ruleContents; + std::string createTime; + std::string ruleId; + std::string ruleType; + std::string excludeRegionIdsScope; + std::string regionIdsScope; + std::string resourceGroupIdsScope; + std::string ruleDesc; + std::string resourceTypesScope; + std::string ruleName; + }; + + + GetAutoGroupingRuleResult(); + explicit GetAutoGroupingRuleResult(const std::string &payload); + ~GetAutoGroupingRuleResult(); + Rule getRule()const; + + protected: + void parse(const std::string &payload); + private: + Rule rule_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULERESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusRequest.h new file mode 100644 index 000000000..9e7660643 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusRequest.h @@ -0,0 +1,39 @@ +/* + * 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_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGSTATUSREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGSTATUSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT GetAutoGroupingStatusRequest : public RpcServiceRequest { +public: + GetAutoGroupingStatusRequest(); + ~GetAutoGroupingStatusRequest(); + +private: +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGSTATUSREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusResult.h new file mode 100644 index 000000000..0d7f89efe --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusResult.h @@ -0,0 +1,53 @@ +/* + * 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_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGSTATUSRESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGSTATUSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT GetAutoGroupingStatusResult : public ServiceResult + { + public: + + + GetAutoGroupingStatusResult(); + explicit GetAutoGroupingStatusResult(const std::string &payload); + ~GetAutoGroupingStatusResult(); + std::string getEnableStatus()const; + bool getEnableExistedResourcesTransfer()const; + + protected: + void parse(const std::string &payload); + private: + std::string enableStatus_; + bool enableExistedResourcesTransfer_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGSTATUSRESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/GetPolicyResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/GetPolicyResult.h index d752e76d4..17ddaa9b7 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/GetPolicyResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/GetPolicyResult.h @@ -34,8 +34,8 @@ namespace AlibabaCloud public: struct Policy { - std::string updateDate; std::string policyType; + std::string updateDate; std::string description; int attachmentCount; std::string defaultVersion; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/GetResourceDirectoryResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/GetResourceDirectoryResult.h index be93c42eb..61b3e06d5 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/GetResourceDirectoryResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/GetResourceDirectoryResult.h @@ -38,9 +38,9 @@ namespace AlibabaCloud std::string resourceDirectoryId; std::string scpStatus; std::string memberDeletionStatus; - std::string rootFolderId; std::string createTime; std::string masterAccountName; + std::string rootFolderId; std::string controlPolicyStatus; std::string masterAccountId; }; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/GetRoleResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/GetRoleResult.h index d8b57af10..4bad218b4 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/GetRoleResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/GetRoleResult.h @@ -36,11 +36,11 @@ namespace AlibabaCloud { struct LatestDeletionTask { - std::string deletionTaskId; std::string createDate; + std::string deletionTaskId; }; - std::string updateDate; long maxSessionDuration; + std::string updateDate; std::string roleName; std::string description; std::string assumeRolePolicyDocument; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/InitResourceDirectoryResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/InitResourceDirectoryResult.h index 9c27886d0..d61331062 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/InitResourceDirectoryResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/InitResourceDirectoryResult.h @@ -35,9 +35,9 @@ namespace AlibabaCloud struct ResourceDirectory { std::string resourceDirectoryId; - std::string rootFolderId; std::string createTime; std::string masterAccountName; + std::string rootFolderId; std::string masterAccountId; }; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/ListAccountsForParentRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/ListAccountsForParentRequest.h index c6f2d1c09..8dd5a6549 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/ListAccountsForParentRequest.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/ListAccountsForParentRequest.h @@ -34,26 +34,26 @@ public: }; ListAccountsForParentRequest(); ~ListAccountsForParentRequest(); - std::string getQueryKeyword() const; - void setQueryKeyword(const std::string &queryKeyword); int getPageNumber() const; void setPageNumber(int pageNumber); - std::string getParentFolderId() const; - void setParentFolderId(const std::string &parentFolderId); - bool getIncludeTags() const; - void setIncludeTags(bool includeTags); int getPageSize() const; void setPageSize(int pageSize); std::vector getTag() const; void setTag(const std::vector &tag); + std::string getQueryKeyword() const; + void setQueryKeyword(const std::string &queryKeyword); + std::string getParentFolderId() const; + void setParentFolderId(const std::string &parentFolderId); + bool getIncludeTags() const; + void setIncludeTags(bool includeTags); private: - std::string queryKeyword_; int pageNumber_; - std::string parentFolderId_; - bool includeTags_; int pageSize_; std::vector tag_; + std::string queryKeyword_; + std::string parentFolderId_; + bool includeTags_; }; } // namespace Model } // namespace ResourceManager diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingRequest.h new file mode 100644 index 000000000..e9abf59a5 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingRequest.h @@ -0,0 +1,39 @@ +/* + * 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_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT ListAssociatedTransferSettingRequest : public RpcServiceRequest { +public: + ListAssociatedTransferSettingRequest(); + ~ListAssociatedTransferSettingRequest(); + +private: +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingResult.h new file mode 100644 index 000000000..47f27e101 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingResult.h @@ -0,0 +1,69 @@ +/* + * 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_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGRESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT ListAssociatedTransferSettingResult : public ServiceResult + { + public: + struct AssociatedTransferSetting + { + struct RuleSetting + { + std::string status; + std::string triggerType; + std::string associatedService; + std::string masterResourceType; + std::string ruleId; + std::string associatedResourceType; + std::string masterService; + }; + std::string status; + std::string enablePartialRule; + std::string accountId; + std::string enableExistingResourcesTransfer; + std::vector ruleSettings; + }; + + + ListAssociatedTransferSettingResult(); + explicit ListAssociatedTransferSettingResult(const std::string &payload); + ~ListAssociatedTransferSettingResult(); + AssociatedTransferSetting getAssociatedTransferSetting()const; + + protected: + void parse(const std::string &payload); + private: + AssociatedTransferSetting associatedTransferSetting_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGRESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesRequest.h new file mode 100644 index 000000000..f3632096c --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesRequest.h @@ -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_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT ListAutoGroupingRulesRequest : public RpcServiceRequest { +public: + ListAutoGroupingRulesRequest(); + ~ListAutoGroupingRulesRequest(); + std::string getRuleName() const; + void setRuleName(const std::string &ruleName); + std::string getNextToken() const; + void setNextToken(const std::string &nextToken); + std::string getRuleType() const; + void setRuleType(const std::string &ruleType); + int getMaxResults() const; + void setMaxResults(int maxResults); + std::string getRuleId() const; + void setRuleId(const std::string &ruleId); + +private: + std::string ruleName_; + std::string nextToken_; + std::string ruleType_; + int maxResults_; + std::string ruleId_; +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesResult.h new file mode 100644 index 000000000..279281e7b --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESRESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT ListAutoGroupingRulesResult : public ServiceResult + { + public: + struct Rule + { + struct RuleContent + { + std::string autoGroupingScopeCondition; + std::string ruleContentId; + std::string targetResourceGroupCondition; + }; + std::string modifyTime; + std::string excludeResourceGroupIdsScope; + std::string excludeResourceIdsScope; + std::string excludeResourceTypesScope; + std::string resourceIdsScope; + std::vector ruleContents; + std::string createTime; + std::string ruleId; + std::string ruleType; + std::string excludeRegionIdsScope; + std::string regionIdsScope; + std::string resourceGroupIdsScope; + std::string ruleDesc; + std::string resourceTypesScope; + std::string ruleName; + }; + + + ListAutoGroupingRulesResult(); + explicit ListAutoGroupingRulesResult(const std::string &payload); + ~ListAutoGroupingRulesResult(); + std::string getNextToken()const; + int getMaxResults()const; + std::vector getRules()const; + + protected: + void parse(const std::string &payload); + private: + std::string nextToken_; + int maxResults_; + std::vector rules_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESRESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/ListPoliciesResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/ListPoliciesResult.h index a1624a744..d5f7b2875 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/ListPoliciesResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/ListPoliciesResult.h @@ -34,8 +34,8 @@ namespace AlibabaCloud public: struct Policy { - std::string updateDate; std::string policyType; + std::string updateDate; std::string description; int attachmentCount; std::string defaultVersion; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/ListRolesResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/ListRolesResult.h index 1e16ed467..d4573692e 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/ListRolesResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/ListRolesResult.h @@ -36,11 +36,11 @@ namespace AlibabaCloud { struct LatestDeletionTask { - std::string deletionTaskId; std::string createDate; + std::string deletionTaskId; }; - std::string updateDate; long maxSessionDuration; + std::string updateDate; std::string roleName; std::string description; LatestDeletionTask latestDeletionTask; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/ListTagResourcesRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/ListTagResourcesRequest.h index aef21af1f..8cae006aa 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/ListTagResourcesRequest.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/ListTagResourcesRequest.h @@ -34,23 +34,23 @@ public: }; ListTagResourcesRequest(); ~ListTagResourcesRequest(); + std::string getNextToken() const; + void setNextToken(const std::string &nextToken); + std::vector getTag() const; + void setTag(const std::vector &tag); std::vector getResourceId() const; void setResourceId(const std::vector &resourceId); std::string getResourceType() const; void setResourceType(const std::string &resourceType); - std::string getNextToken() const; - void setNextToken(const std::string &nextToken); int getMaxResults() const; void setMaxResults(int maxResults); - std::vector getTag() const; - void setTag(const std::vector &tag); private: + std::string nextToken_; + std::vector tag_; std::vector resourceId_; std::string resourceType_; - std::string nextToken_; int maxResults_; - std::vector tag_; }; } // namespace Model } // namespace ResourceManager diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/PromoteResourceAccountResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/PromoteResourceAccountResult.h index 517461bfe..b204f6630 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/PromoteResourceAccountResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/PromoteResourceAccountResult.h @@ -37,8 +37,8 @@ namespace AlibabaCloud std::string status; std::string joinMethod; std::string modifyTime; - std::string type; std::string resourceDirectoryId; + std::string type; std::string accountId; std::string displayName; std::string joinTime; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/ResendCreateCloudAccountEmailResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/ResendCreateCloudAccountEmailResult.h index b683c422b..bb92ae886 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/ResendCreateCloudAccountEmailResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/ResendCreateCloudAccountEmailResult.h @@ -37,8 +37,8 @@ namespace AlibabaCloud std::string status; std::string joinMethod; std::string modifyTime; - std::string type; std::string resourceDirectoryId; + std::string type; std::string accountId; std::string displayName; std::string joinTime; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/ResendPromoteResourceAccountEmailResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/ResendPromoteResourceAccountEmailResult.h index fdf51fe8a..ff206e1f6 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/ResendPromoteResourceAccountEmailResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/ResendPromoteResourceAccountEmailResult.h @@ -37,8 +37,8 @@ namespace AlibabaCloud std::string status; std::string joinMethod; std::string modifyTime; - std::string type; std::string resourceDirectoryId; + std::string type; std::string accountId; std::string displayName; std::string joinTime; diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingRequest.h new file mode 100644 index 000000000..733c04485 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingRequest.h @@ -0,0 +1,53 @@ +/* + * 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_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAssociatedTransferSettingRequest : public RpcServiceRequest { +public: + struct RuleSettings { + std::string associatedService; + std::string masterService; + std::string masterResourceType; + std::string associatedResourceType; + std::string ruleId; + std::string status; + }; + UpdateAssociatedTransferSettingRequest(); + ~UpdateAssociatedTransferSettingRequest(); + std::vector getRuleSettings() const; + void setRuleSettings(const std::vector &ruleSettings); + std::string getEnableExistingResourcesTransfer() const; + void setEnableExistingResourcesTransfer(const std::string &enableExistingResourcesTransfer); + +private: + std::vector ruleSettings_; + std::string enableExistingResourcesTransfer_; +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingResult.h new file mode 100644 index 000000000..205ea5272 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingResult.h @@ -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_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGRESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAssociatedTransferSettingResult : public ServiceResult + { + public: + + + UpdateAssociatedTransferSettingResult(); + explicit UpdateAssociatedTransferSettingResult(const std::string &payload); + ~UpdateAssociatedTransferSettingResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGRESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigRequest.h new file mode 100644 index 000000000..719568ae6 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigRequest.h @@ -0,0 +1,42 @@ +/* + * 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_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAutoGroupingConfigRequest : public RpcServiceRequest { +public: + UpdateAutoGroupingConfigRequest(); + ~UpdateAutoGroupingConfigRequest(); + bool getEnableExistingResourcesTransfer() const; + void setEnableExistingResourcesTransfer(bool enableExistingResourcesTransfer); + +private: + bool enableExistingResourcesTransfer_; +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigResult.h new file mode 100644 index 000000000..009bea262 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigResult.h @@ -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_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGRESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAutoGroupingConfigResult : public ServiceResult + { + public: + + + UpdateAutoGroupingConfigResult(); + explicit UpdateAutoGroupingConfigResult(const std::string &payload); + ~UpdateAutoGroupingConfigResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGRESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleRequest.h b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleRequest.h new file mode 100644 index 000000000..68f532395 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleRequest.h @@ -0,0 +1,80 @@ +/* + * 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_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULEREQUEST_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ResourceManager { +namespace Model { +class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAutoGroupingRuleRequest : public RpcServiceRequest { +public: + struct RuleContents { + std::string ruleContentId; + std::string targetResourceGroupCondition; + std::string autoGroupingScopeCondition; + }; + UpdateAutoGroupingRuleRequest(); + ~UpdateAutoGroupingRuleRequest(); + std::string getRuleDesc() const; + void setRuleDesc(const std::string &ruleDesc); + std::string getResourceTypesScope() const; + void setResourceTypesScope(const std::string &resourceTypesScope); + std::string getRuleName() const; + void setRuleName(const std::string &ruleName); + std::string getExcludeResourceGroupIdsScope() const; + void setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope); + std::string getRegionIdsScope() const; + void setRegionIdsScope(const std::string ®ionIdsScope); + std::string getResourceIdsScope() const; + void setResourceIdsScope(const std::string &resourceIdsScope); + std::vector getRuleContents() const; + void setRuleContents(const std::vector &ruleContents); + std::string getExcludeResourceTypesScope() const; + void setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope); + std::string getResourceGroupIdsScope() const; + void setResourceGroupIdsScope(const std::string &resourceGroupIdsScope); + std::string getExcludeRegionIdsScope() const; + void setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope); + std::string getExcludeResourceIdsScope() const; + void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope); + std::string getRuleId() const; + void setRuleId(const std::string &ruleId); + +private: + std::string ruleDesc_; + std::string resourceTypesScope_; + std::string ruleName_; + std::string excludeResourceGroupIdsScope_; + std::string regionIdsScope_; + std::string resourceIdsScope_; + std::vector ruleContents_; + std::string excludeResourceTypesScope_; + std::string resourceGroupIdsScope_; + std::string excludeRegionIdsScope_; + std::string excludeResourceIdsScope_; + std::string ruleId_; +}; +} // namespace Model +} // namespace ResourceManager +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULEREQUEST_H_ diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleResult.h new file mode 100644 index 000000000..c8f8ae453 --- /dev/null +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleResult.h @@ -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_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULERESULT_H_ +#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ResourceManager + { + namespace Model + { + class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAutoGroupingRuleResult : public ServiceResult + { + public: + + + UpdateAutoGroupingRuleResult(); + explicit UpdateAutoGroupingRuleResult(const std::string &payload); + ~UpdateAutoGroupingRuleResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULERESULT_H_ \ No newline at end of file diff --git a/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateRoleResult.h b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateRoleResult.h index 5cfb265f1..492518ce6 100644 --- a/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateRoleResult.h +++ b/resourcemanager/include/alibabacloud/resourcemanager/model/UpdateRoleResult.h @@ -34,8 +34,8 @@ namespace AlibabaCloud public: struct Role { - std::string updateDate; long maxSessionDuration; + std::string updateDate; std::string roleName; std::string description; std::string assumeRolePolicyDocument; diff --git a/resourcemanager/src/ResourceManagerClient.cc b/resourcemanager/src/ResourceManagerClient.cc index 7abda8d71..781daaa1e 100644 --- a/resourcemanager/src/ResourceManagerClient.cc +++ b/resourcemanager/src/ResourceManagerClient.cc @@ -31,21 +31,21 @@ ResourceManagerClient::ResourceManagerClient(const Credentials &credentials, con RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) { auto locationClient = std::make_shared(credentials, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "resourcemanager"); } ResourceManagerClient::ResourceManagerClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) { auto locationClient = std::make_shared(credentialsProvider, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "resourcemanager"); } ResourceManagerClient::ResourceManagerClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) { auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "resourcemanager"); } ResourceManagerClient::~ResourceManagerClient() @@ -411,6 +411,42 @@ ResourceManagerClient::CheckAccountDeleteOutcomeCallable ResourceManagerClient:: return task->get_future(); } +ResourceManagerClient::CreateAutoGroupingRuleOutcome ResourceManagerClient::createAutoGroupingRule(const CreateAutoGroupingRuleRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateAutoGroupingRuleOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateAutoGroupingRuleOutcome(CreateAutoGroupingRuleResult(outcome.result())); + else + return CreateAutoGroupingRuleOutcome(outcome.error()); +} + +void ResourceManagerClient::createAutoGroupingRuleAsync(const CreateAutoGroupingRuleRequest& request, const CreateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createAutoGroupingRule(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::CreateAutoGroupingRuleOutcomeCallable ResourceManagerClient::createAutoGroupingRuleCallable(const CreateAutoGroupingRuleRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createAutoGroupingRule(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + ResourceManagerClient::CreateCloudAccountOutcome ResourceManagerClient::createCloudAccount(const CreateCloudAccountRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -807,6 +843,42 @@ ResourceManagerClient::DeleteAccountOutcomeCallable ResourceManagerClient::delet return task->get_future(); } +ResourceManagerClient::DeleteAutoGroupingRuleOutcome ResourceManagerClient::deleteAutoGroupingRule(const DeleteAutoGroupingRuleRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteAutoGroupingRuleOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteAutoGroupingRuleOutcome(DeleteAutoGroupingRuleResult(outcome.result())); + else + return DeleteAutoGroupingRuleOutcome(outcome.error()); +} + +void ResourceManagerClient::deleteAutoGroupingRuleAsync(const DeleteAutoGroupingRuleRequest& request, const DeleteAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteAutoGroupingRule(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::DeleteAutoGroupingRuleOutcomeCallable ResourceManagerClient::deleteAutoGroupingRuleCallable(const DeleteAutoGroupingRuleRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteAutoGroupingRule(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + ResourceManagerClient::DeleteControlPolicyOutcome ResourceManagerClient::deleteControlPolicy(const DeleteControlPolicyRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1203,6 +1275,78 @@ ResourceManagerClient::DetachPolicyOutcomeCallable ResourceManagerClient::detach return task->get_future(); } +ResourceManagerClient::DisableAssociatedTransferOutcome ResourceManagerClient::disableAssociatedTransfer(const DisableAssociatedTransferRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DisableAssociatedTransferOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DisableAssociatedTransferOutcome(DisableAssociatedTransferResult(outcome.result())); + else + return DisableAssociatedTransferOutcome(outcome.error()); +} + +void ResourceManagerClient::disableAssociatedTransferAsync(const DisableAssociatedTransferRequest& request, const DisableAssociatedTransferAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, disableAssociatedTransfer(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::DisableAssociatedTransferOutcomeCallable ResourceManagerClient::disableAssociatedTransferCallable(const DisableAssociatedTransferRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->disableAssociatedTransfer(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ResourceManagerClient::DisableAutoGroupingOutcome ResourceManagerClient::disableAutoGrouping(const DisableAutoGroupingRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DisableAutoGroupingOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DisableAutoGroupingOutcome(DisableAutoGroupingResult(outcome.result())); + else + return DisableAutoGroupingOutcome(outcome.error()); +} + +void ResourceManagerClient::disableAutoGroupingAsync(const DisableAutoGroupingRequest& request, const DisableAutoGroupingAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, disableAutoGrouping(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::DisableAutoGroupingOutcomeCallable ResourceManagerClient::disableAutoGroupingCallable(const DisableAutoGroupingRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->disableAutoGrouping(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + ResourceManagerClient::DisableControlPolicyOutcome ResourceManagerClient::disableControlPolicy(const DisableControlPolicyRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1239,6 +1383,78 @@ ResourceManagerClient::DisableControlPolicyOutcomeCallable ResourceManagerClient return task->get_future(); } +ResourceManagerClient::EnableAssociatedTransferOutcome ResourceManagerClient::enableAssociatedTransfer(const EnableAssociatedTransferRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return EnableAssociatedTransferOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return EnableAssociatedTransferOutcome(EnableAssociatedTransferResult(outcome.result())); + else + return EnableAssociatedTransferOutcome(outcome.error()); +} + +void ResourceManagerClient::enableAssociatedTransferAsync(const EnableAssociatedTransferRequest& request, const EnableAssociatedTransferAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, enableAssociatedTransfer(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::EnableAssociatedTransferOutcomeCallable ResourceManagerClient::enableAssociatedTransferCallable(const EnableAssociatedTransferRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->enableAssociatedTransfer(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ResourceManagerClient::EnableAutoGroupingOutcome ResourceManagerClient::enableAutoGrouping(const EnableAutoGroupingRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return EnableAutoGroupingOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return EnableAutoGroupingOutcome(EnableAutoGroupingResult(outcome.result())); + else + return EnableAutoGroupingOutcome(outcome.error()); +} + +void ResourceManagerClient::enableAutoGroupingAsync(const EnableAutoGroupingRequest& request, const EnableAutoGroupingAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, enableAutoGrouping(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::EnableAutoGroupingOutcomeCallable ResourceManagerClient::enableAutoGroupingCallable(const EnableAutoGroupingRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->enableAutoGrouping(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + ResourceManagerClient::EnableControlPolicyOutcome ResourceManagerClient::enableControlPolicy(const EnableControlPolicyRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1419,6 +1635,78 @@ ResourceManagerClient::GetAccountDeletionStatusOutcomeCallable ResourceManagerCl return task->get_future(); } +ResourceManagerClient::GetAutoGroupingRuleOutcome ResourceManagerClient::getAutoGroupingRule(const GetAutoGroupingRuleRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetAutoGroupingRuleOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetAutoGroupingRuleOutcome(GetAutoGroupingRuleResult(outcome.result())); + else + return GetAutoGroupingRuleOutcome(outcome.error()); +} + +void ResourceManagerClient::getAutoGroupingRuleAsync(const GetAutoGroupingRuleRequest& request, const GetAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getAutoGroupingRule(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::GetAutoGroupingRuleOutcomeCallable ResourceManagerClient::getAutoGroupingRuleCallable(const GetAutoGroupingRuleRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getAutoGroupingRule(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ResourceManagerClient::GetAutoGroupingStatusOutcome ResourceManagerClient::getAutoGroupingStatus(const GetAutoGroupingStatusRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetAutoGroupingStatusOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetAutoGroupingStatusOutcome(GetAutoGroupingStatusResult(outcome.result())); + else + return GetAutoGroupingStatusOutcome(outcome.error()); +} + +void ResourceManagerClient::getAutoGroupingStatusAsync(const GetAutoGroupingStatusRequest& request, const GetAutoGroupingStatusAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getAutoGroupingStatus(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::GetAutoGroupingStatusOutcomeCallable ResourceManagerClient::getAutoGroupingStatusCallable(const GetAutoGroupingStatusRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getAutoGroupingStatus(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + ResourceManagerClient::GetControlPolicyOutcome ResourceManagerClient::getControlPolicy(const GetControlPolicyRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1995,6 +2283,78 @@ ResourceManagerClient::ListAncestorsOutcomeCallable ResourceManagerClient::listA return task->get_future(); } +ResourceManagerClient::ListAssociatedTransferSettingOutcome ResourceManagerClient::listAssociatedTransferSetting(const ListAssociatedTransferSettingRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAssociatedTransferSettingOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAssociatedTransferSettingOutcome(ListAssociatedTransferSettingResult(outcome.result())); + else + return ListAssociatedTransferSettingOutcome(outcome.error()); +} + +void ResourceManagerClient::listAssociatedTransferSettingAsync(const ListAssociatedTransferSettingRequest& request, const ListAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAssociatedTransferSetting(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::ListAssociatedTransferSettingOutcomeCallable ResourceManagerClient::listAssociatedTransferSettingCallable(const ListAssociatedTransferSettingRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAssociatedTransferSetting(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ResourceManagerClient::ListAutoGroupingRulesOutcome ResourceManagerClient::listAutoGroupingRules(const ListAutoGroupingRulesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAutoGroupingRulesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAutoGroupingRulesOutcome(ListAutoGroupingRulesResult(outcome.result())); + else + return ListAutoGroupingRulesOutcome(outcome.error()); +} + +void ResourceManagerClient::listAutoGroupingRulesAsync(const ListAutoGroupingRulesRequest& request, const ListAutoGroupingRulesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAutoGroupingRules(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::ListAutoGroupingRulesOutcomeCallable ResourceManagerClient::listAutoGroupingRulesCallable(const ListAutoGroupingRulesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAutoGroupingRules(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + ResourceManagerClient::ListControlPoliciesOutcome ResourceManagerClient::listControlPolicies(const ListControlPoliciesRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -3183,6 +3543,114 @@ ResourceManagerClient::UpdateAccountOutcomeCallable ResourceManagerClient::updat return task->get_future(); } +ResourceManagerClient::UpdateAssociatedTransferSettingOutcome ResourceManagerClient::updateAssociatedTransferSetting(const UpdateAssociatedTransferSettingRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateAssociatedTransferSettingOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateAssociatedTransferSettingOutcome(UpdateAssociatedTransferSettingResult(outcome.result())); + else + return UpdateAssociatedTransferSettingOutcome(outcome.error()); +} + +void ResourceManagerClient::updateAssociatedTransferSettingAsync(const UpdateAssociatedTransferSettingRequest& request, const UpdateAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateAssociatedTransferSetting(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::UpdateAssociatedTransferSettingOutcomeCallable ResourceManagerClient::updateAssociatedTransferSettingCallable(const UpdateAssociatedTransferSettingRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateAssociatedTransferSetting(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ResourceManagerClient::UpdateAutoGroupingConfigOutcome ResourceManagerClient::updateAutoGroupingConfig(const UpdateAutoGroupingConfigRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateAutoGroupingConfigOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateAutoGroupingConfigOutcome(UpdateAutoGroupingConfigResult(outcome.result())); + else + return UpdateAutoGroupingConfigOutcome(outcome.error()); +} + +void ResourceManagerClient::updateAutoGroupingConfigAsync(const UpdateAutoGroupingConfigRequest& request, const UpdateAutoGroupingConfigAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateAutoGroupingConfig(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::UpdateAutoGroupingConfigOutcomeCallable ResourceManagerClient::updateAutoGroupingConfigCallable(const UpdateAutoGroupingConfigRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateAutoGroupingConfig(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ResourceManagerClient::UpdateAutoGroupingRuleOutcome ResourceManagerClient::updateAutoGroupingRule(const UpdateAutoGroupingRuleRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateAutoGroupingRuleOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateAutoGroupingRuleOutcome(UpdateAutoGroupingRuleResult(outcome.result())); + else + return UpdateAutoGroupingRuleOutcome(outcome.error()); +} + +void ResourceManagerClient::updateAutoGroupingRuleAsync(const UpdateAutoGroupingRuleRequest& request, const UpdateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateAutoGroupingRule(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ResourceManagerClient::UpdateAutoGroupingRuleOutcomeCallable ResourceManagerClient::updateAutoGroupingRuleCallable(const UpdateAutoGroupingRuleRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateAutoGroupingRule(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + ResourceManagerClient::UpdateControlPolicyOutcome ResourceManagerClient::updateControlPolicy(const UpdateControlPolicyRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/resourcemanager/src/model/AttachPolicyRequest.cc b/resourcemanager/src/model/AttachPolicyRequest.cc index c53394f06..65f2748bc 100644 --- a/resourcemanager/src/model/AttachPolicyRequest.cc +++ b/resourcemanager/src/model/AttachPolicyRequest.cc @@ -25,6 +25,15 @@ AttachPolicyRequest::AttachPolicyRequest() AttachPolicyRequest::~AttachPolicyRequest() {} +std::string AttachPolicyRequest::getResourceGroupId() const { + return resourceGroupId_; +} + +void AttachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) { + resourceGroupId_ = resourceGroupId; + setParameter(std::string("ResourceGroupId"), resourceGroupId); +} + std::string AttachPolicyRequest::getPolicyType() const { return policyType_; } @@ -43,15 +52,6 @@ void AttachPolicyRequest::setPrincipalType(const std::string &principalType) { setParameter(std::string("PrincipalType"), principalType); } -std::string AttachPolicyRequest::getResourceGroupId() const { - return resourceGroupId_; -} - -void AttachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) { - resourceGroupId_ = resourceGroupId; - setParameter(std::string("ResourceGroupId"), resourceGroupId); -} - std::string AttachPolicyRequest::getPolicyName() const { return policyName_; } diff --git a/resourcemanager/src/model/CreateAutoGroupingRuleRequest.cc b/resourcemanager/src/model/CreateAutoGroupingRuleRequest.cc new file mode 100644 index 000000000..dace1361c --- /dev/null +++ b/resourcemanager/src/model/CreateAutoGroupingRuleRequest.cc @@ -0,0 +1,140 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::CreateAutoGroupingRuleRequest; + +CreateAutoGroupingRuleRequest::CreateAutoGroupingRuleRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "CreateAutoGroupingRule") { + setMethod(HttpRequest::Method::Post); +} + +CreateAutoGroupingRuleRequest::~CreateAutoGroupingRuleRequest() {} + +std::string CreateAutoGroupingRuleRequest::getRuleDesc() const { + return ruleDesc_; +} + +void CreateAutoGroupingRuleRequest::setRuleDesc(const std::string &ruleDesc) { + ruleDesc_ = ruleDesc; + setParameter(std::string("RuleDesc"), ruleDesc); +} + +std::string CreateAutoGroupingRuleRequest::getResourceTypesScope() const { + return resourceTypesScope_; +} + +void CreateAutoGroupingRuleRequest::setResourceTypesScope(const std::string &resourceTypesScope) { + resourceTypesScope_ = resourceTypesScope; + setParameter(std::string("ResourceTypesScope"), resourceTypesScope); +} + +std::string CreateAutoGroupingRuleRequest::getRuleName() const { + return ruleName_; +} + +void CreateAutoGroupingRuleRequest::setRuleName(const std::string &ruleName) { + ruleName_ = ruleName; + setParameter(std::string("RuleName"), ruleName); +} + +std::string CreateAutoGroupingRuleRequest::getExcludeResourceGroupIdsScope() const { + return excludeResourceGroupIdsScope_; +} + +void CreateAutoGroupingRuleRequest::setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope) { + excludeResourceGroupIdsScope_ = excludeResourceGroupIdsScope; + setParameter(std::string("ExcludeResourceGroupIdsScope"), excludeResourceGroupIdsScope); +} + +std::string CreateAutoGroupingRuleRequest::getRegionIdsScope() const { + return regionIdsScope_; +} + +void CreateAutoGroupingRuleRequest::setRegionIdsScope(const std::string ®ionIdsScope) { + regionIdsScope_ = regionIdsScope; + setParameter(std::string("RegionIdsScope"), regionIdsScope); +} + +std::string CreateAutoGroupingRuleRequest::getResourceIdsScope() const { + return resourceIdsScope_; +} + +void CreateAutoGroupingRuleRequest::setResourceIdsScope(const std::string &resourceIdsScope) { + resourceIdsScope_ = resourceIdsScope; + setParameter(std::string("ResourceIdsScope"), resourceIdsScope); +} + +std::vector CreateAutoGroupingRuleRequest::getRuleContents() const { + return ruleContents_; +} + +void CreateAutoGroupingRuleRequest::setRuleContents(const std::vector &ruleContents) { + ruleContents_ = ruleContents; + for(int dep1 = 0; dep1 != ruleContents.size(); dep1++) { + auto ruleContentsObj = ruleContents.at(dep1); + std::string ruleContentsObjStr = std::string("RuleContents") + "." + std::to_string(dep1 + 1); + setParameter(ruleContentsObjStr + ".TargetResourceGroupCondition", ruleContentsObj.targetResourceGroupCondition); + setParameter(ruleContentsObjStr + ".AutoGroupingScopeCondition", ruleContentsObj.autoGroupingScopeCondition); + } +} + +std::string CreateAutoGroupingRuleRequest::getExcludeResourceTypesScope() const { + return excludeResourceTypesScope_; +} + +void CreateAutoGroupingRuleRequest::setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope) { + excludeResourceTypesScope_ = excludeResourceTypesScope; + setParameter(std::string("ExcludeResourceTypesScope"), excludeResourceTypesScope); +} + +std::string CreateAutoGroupingRuleRequest::getRuleType() const { + return ruleType_; +} + +void CreateAutoGroupingRuleRequest::setRuleType(const std::string &ruleType) { + ruleType_ = ruleType; + setParameter(std::string("RuleType"), ruleType); +} + +std::string CreateAutoGroupingRuleRequest::getResourceGroupIdsScope() const { + return resourceGroupIdsScope_; +} + +void CreateAutoGroupingRuleRequest::setResourceGroupIdsScope(const std::string &resourceGroupIdsScope) { + resourceGroupIdsScope_ = resourceGroupIdsScope; + setParameter(std::string("ResourceGroupIdsScope"), resourceGroupIdsScope); +} + +std::string CreateAutoGroupingRuleRequest::getExcludeRegionIdsScope() const { + return excludeRegionIdsScope_; +} + +void CreateAutoGroupingRuleRequest::setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope) { + excludeRegionIdsScope_ = excludeRegionIdsScope; + setParameter(std::string("ExcludeRegionIdsScope"), excludeRegionIdsScope); +} + +std::string CreateAutoGroupingRuleRequest::getExcludeResourceIdsScope() const { + return excludeResourceIdsScope_; +} + +void CreateAutoGroupingRuleRequest::setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope) { + excludeResourceIdsScope_ = excludeResourceIdsScope; + setParameter(std::string("ExcludeResourceIdsScope"), excludeResourceIdsScope); +} + diff --git a/resourcemanager/src/model/CreateAutoGroupingRuleResult.cc b/resourcemanager/src/model/CreateAutoGroupingRuleResult.cc new file mode 100644 index 000000000..3db196336 --- /dev/null +++ b/resourcemanager/src/model/CreateAutoGroupingRuleResult.cc @@ -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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +CreateAutoGroupingRuleResult::CreateAutoGroupingRuleResult() : + ServiceResult() +{} + +CreateAutoGroupingRuleResult::CreateAutoGroupingRuleResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateAutoGroupingRuleResult::~CreateAutoGroupingRuleResult() +{} + +void CreateAutoGroupingRuleResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["RuleId"].isNull()) + ruleId_ = value["RuleId"].asString(); + +} + +std::string CreateAutoGroupingRuleResult::getRuleId()const +{ + return ruleId_; +} + diff --git a/resourcemanager/src/model/CreateCloudAccountResult.cc b/resourcemanager/src/model/CreateCloudAccountResult.cc index d48e295d8..6c66662dc 100644 --- a/resourcemanager/src/model/CreateCloudAccountResult.cc +++ b/resourcemanager/src/model/CreateCloudAccountResult.cc @@ -40,26 +40,26 @@ void CreateCloudAccountResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto accountNode = value["Account"]; - if(!accountNode["Status"].isNull()) - account_.status = accountNode["Status"].asString(); - if(!accountNode["Type"].isNull()) - account_.type = accountNode["Type"].asString(); + if(!accountNode["AccountId"].isNull()) + account_.accountId = accountNode["AccountId"].asString(); + if(!accountNode["AccountName"].isNull()) + account_.accountName = accountNode["AccountName"].asString(); if(!accountNode["DisplayName"].isNull()) account_.displayName = accountNode["DisplayName"].asString(); if(!accountNode["FolderId"].isNull()) account_.folderId = accountNode["FolderId"].asString(); - if(!accountNode["ResourceDirectoryId"].isNull()) - account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString(); - if(!accountNode["RecordId"].isNull()) - account_.recordId = accountNode["RecordId"].asString(); - if(!accountNode["AccountId"].isNull()) - account_.accountId = accountNode["AccountId"].asString(); if(!accountNode["JoinMethod"].isNull()) account_.joinMethod = accountNode["JoinMethod"].asString(); if(!accountNode["ModifyTime"].isNull()) account_.modifyTime = accountNode["ModifyTime"].asString(); - if(!accountNode["AccountName"].isNull()) - account_.accountName = accountNode["AccountName"].asString(); + if(!accountNode["RecordId"].isNull()) + account_.recordId = accountNode["RecordId"].asString(); + if(!accountNode["ResourceDirectoryId"].isNull()) + account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString(); + if(!accountNode["Status"].isNull()) + account_.status = accountNode["Status"].asString(); + if(!accountNode["Type"].isNull()) + account_.type = accountNode["Type"].asString(); } diff --git a/resourcemanager/src/model/CreatePolicyResult.cc b/resourcemanager/src/model/CreatePolicyResult.cc index 171c5ef0c..cb72b8cb5 100644 --- a/resourcemanager/src/model/CreatePolicyResult.cc +++ b/resourcemanager/src/model/CreatePolicyResult.cc @@ -40,14 +40,14 @@ void CreatePolicyResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto policyNode = value["Policy"]; + if(!policyNode["CreateDate"].isNull()) + policy_.createDate = policyNode["CreateDate"].asString(); if(!policyNode["DefaultVersion"].isNull()) policy_.defaultVersion = policyNode["DefaultVersion"].asString(); if(!policyNode["Description"].isNull()) policy_.description = policyNode["Description"].asString(); if(!policyNode["PolicyName"].isNull()) policy_.policyName = policyNode["PolicyName"].asString(); - if(!policyNode["CreateDate"].isNull()) - policy_.createDate = policyNode["CreateDate"].asString(); if(!policyNode["PolicyType"].isNull()) policy_.policyType = policyNode["PolicyType"].asString(); diff --git a/resourcemanager/src/model/CreatePolicyVersionResult.cc b/resourcemanager/src/model/CreatePolicyVersionResult.cc index 29eb724c7..725668707 100644 --- a/resourcemanager/src/model/CreatePolicyVersionResult.cc +++ b/resourcemanager/src/model/CreatePolicyVersionResult.cc @@ -40,12 +40,12 @@ void CreatePolicyVersionResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto policyVersionNode = value["PolicyVersion"]; + if(!policyVersionNode["CreateDate"].isNull()) + policyVersion_.createDate = policyVersionNode["CreateDate"].asString(); if(!policyVersionNode["IsDefaultVersion"].isNull()) policyVersion_.isDefaultVersion = policyVersionNode["IsDefaultVersion"].asString() == "true"; if(!policyVersionNode["VersionId"].isNull()) policyVersion_.versionId = policyVersionNode["VersionId"].asString(); - if(!policyVersionNode["CreateDate"].isNull()) - policyVersion_.createDate = policyVersionNode["CreateDate"].asString(); } diff --git a/resourcemanager/src/model/CreateResourceGroupRequest.cc b/resourcemanager/src/model/CreateResourceGroupRequest.cc index 680b7e358..235bc8bcf 100644 --- a/resourcemanager/src/model/CreateResourceGroupRequest.cc +++ b/resourcemanager/src/model/CreateResourceGroupRequest.cc @@ -43,3 +43,15 @@ void CreateResourceGroupRequest::setName(const std::string &name) { setParameter(std::string("Name"), name); } +std::vector CreateResourceGroupRequest::getTag() const { + return tag_; +} + +void CreateResourceGroupRequest::setTag(const std::vector &tag) { + tag_ = tag; + for(int dep1 = 0; dep1 != tag.size(); dep1++) { + setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Value", tag[dep1].value); + setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Key", tag[dep1].key); + } +} + diff --git a/resourcemanager/src/model/CreateResourceGroupResult.cc b/resourcemanager/src/model/CreateResourceGroupResult.cc index 883fcc772..19eaac68f 100644 --- a/resourcemanager/src/model/CreateResourceGroupResult.cc +++ b/resourcemanager/src/model/CreateResourceGroupResult.cc @@ -40,26 +40,26 @@ void CreateResourceGroupResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto resourceGroupNode = value["ResourceGroup"]; - if(!resourceGroupNode["DisplayName"].isNull()) - resourceGroup_.displayName = resourceGroupNode["DisplayName"].asString(); - if(!resourceGroupNode["Status"].isNull()) - resourceGroup_.status = resourceGroupNode["Status"].asString(); if(!resourceGroupNode["AccountId"].isNull()) resourceGroup_.accountId = resourceGroupNode["AccountId"].asString(); - if(!resourceGroupNode["Name"].isNull()) - resourceGroup_.name = resourceGroupNode["Name"].asString(); if(!resourceGroupNode["CreateDate"].isNull()) resourceGroup_.createDate = resourceGroupNode["CreateDate"].asString(); + if(!resourceGroupNode["DisplayName"].isNull()) + resourceGroup_.displayName = resourceGroupNode["DisplayName"].asString(); if(!resourceGroupNode["Id"].isNull()) resourceGroup_.id = resourceGroupNode["Id"].asString(); + if(!resourceGroupNode["Name"].isNull()) + resourceGroup_.name = resourceGroupNode["Name"].asString(); + if(!resourceGroupNode["Status"].isNull()) + resourceGroup_.status = resourceGroupNode["Status"].asString(); auto allRegionStatusesNode = resourceGroupNode["RegionStatuses"]["RegionStatus"]; for (auto resourceGroupNodeRegionStatusesRegionStatus : allRegionStatusesNode) { ResourceGroup::RegionStatus regionStatusObject; - if(!resourceGroupNodeRegionStatusesRegionStatus["Status"].isNull()) - regionStatusObject.status = resourceGroupNodeRegionStatusesRegionStatus["Status"].asString(); if(!resourceGroupNodeRegionStatusesRegionStatus["RegionId"].isNull()) regionStatusObject.regionId = resourceGroupNodeRegionStatusesRegionStatus["RegionId"].asString(); + if(!resourceGroupNodeRegionStatusesRegionStatus["Status"].isNull()) + regionStatusObject.status = resourceGroupNodeRegionStatusesRegionStatus["Status"].asString(); resourceGroup_.regionStatuses.push_back(regionStatusObject); } diff --git a/resourcemanager/src/model/CreateRoleResult.cc b/resourcemanager/src/model/CreateRoleResult.cc index be434ba39..59186d7a7 100644 --- a/resourcemanager/src/model/CreateRoleResult.cc +++ b/resourcemanager/src/model/CreateRoleResult.cc @@ -40,22 +40,22 @@ void CreateRoleResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto roleNode = value["Role"]; + if(!roleNode["Arn"].isNull()) + role_.arn = roleNode["Arn"].asString(); if(!roleNode["AssumeRolePolicyDocument"].isNull()) role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString(); - if(!roleNode["RolePrincipalName"].isNull()) - role_.rolePrincipalName = roleNode["RolePrincipalName"].asString(); + if(!roleNode["CreateDate"].isNull()) + role_.createDate = roleNode["CreateDate"].asString(); if(!roleNode["Description"].isNull()) role_.description = roleNode["Description"].asString(); if(!roleNode["MaxSessionDuration"].isNull()) role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString()); - if(!roleNode["RoleName"].isNull()) - role_.roleName = roleNode["RoleName"].asString(); - if(!roleNode["CreateDate"].isNull()) - role_.createDate = roleNode["CreateDate"].asString(); - if(!roleNode["Arn"].isNull()) - role_.arn = roleNode["Arn"].asString(); if(!roleNode["RoleId"].isNull()) role_.roleId = roleNode["RoleId"].asString(); + if(!roleNode["RoleName"].isNull()) + role_.roleName = roleNode["RoleName"].asString(); + if(!roleNode["RolePrincipalName"].isNull()) + role_.rolePrincipalName = roleNode["RolePrincipalName"].asString(); } diff --git a/resourcemanager/src/model/CreateServiceLinkedRoleResult.cc b/resourcemanager/src/model/CreateServiceLinkedRoleResult.cc index 3d3556397..655fd0e0d 100644 --- a/resourcemanager/src/model/CreateServiceLinkedRoleResult.cc +++ b/resourcemanager/src/model/CreateServiceLinkedRoleResult.cc @@ -40,22 +40,22 @@ void CreateServiceLinkedRoleResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto roleNode = value["Role"]; - if(!roleNode["AssumeRolePolicyDocument"].isNull()) - role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString(); - if(!roleNode["RolePrincipalName"].isNull()) - role_.rolePrincipalName = roleNode["RolePrincipalName"].asString(); - if(!roleNode["Description"].isNull()) - role_.description = roleNode["Description"].asString(); - if(!roleNode["RoleName"].isNull()) - role_.roleName = roleNode["RoleName"].asString(); - if(!roleNode["CreateDate"].isNull()) - role_.createDate = roleNode["CreateDate"].asString(); if(!roleNode["Arn"].isNull()) role_.arn = roleNode["Arn"].asString(); - if(!roleNode["RoleId"].isNull()) - role_.roleId = roleNode["RoleId"].asString(); + if(!roleNode["AssumeRolePolicyDocument"].isNull()) + role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString(); + if(!roleNode["CreateDate"].isNull()) + role_.createDate = roleNode["CreateDate"].asString(); + if(!roleNode["Description"].isNull()) + role_.description = roleNode["Description"].asString(); if(!roleNode["IsServiceLinkedRole"].isNull()) role_.isServiceLinkedRole = roleNode["IsServiceLinkedRole"].asString() == "true"; + if(!roleNode["RoleId"].isNull()) + role_.roleId = roleNode["RoleId"].asString(); + if(!roleNode["RoleName"].isNull()) + role_.roleName = roleNode["RoleName"].asString(); + if(!roleNode["RolePrincipalName"].isNull()) + role_.rolePrincipalName = roleNode["RolePrincipalName"].asString(); } diff --git a/resourcemanager/src/model/DeleteAutoGroupingRuleRequest.cc b/resourcemanager/src/model/DeleteAutoGroupingRuleRequest.cc new file mode 100644 index 000000000..efc2e81ae --- /dev/null +++ b/resourcemanager/src/model/DeleteAutoGroupingRuleRequest.cc @@ -0,0 +1,36 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::DeleteAutoGroupingRuleRequest; + +DeleteAutoGroupingRuleRequest::DeleteAutoGroupingRuleRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "DeleteAutoGroupingRule") { + setMethod(HttpRequest::Method::Post); +} + +DeleteAutoGroupingRuleRequest::~DeleteAutoGroupingRuleRequest() {} + +std::string DeleteAutoGroupingRuleRequest::getRuleId() const { + return ruleId_; +} + +void DeleteAutoGroupingRuleRequest::setRuleId(const std::string &ruleId) { + ruleId_ = ruleId; + setParameter(std::string("RuleId"), ruleId); +} + diff --git a/resourcemanager/src/model/DeleteAutoGroupingRuleResult.cc b/resourcemanager/src/model/DeleteAutoGroupingRuleResult.cc new file mode 100644 index 000000000..e4d07444c --- /dev/null +++ b/resourcemanager/src/model/DeleteAutoGroupingRuleResult.cc @@ -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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +DeleteAutoGroupingRuleResult::DeleteAutoGroupingRuleResult() : + ServiceResult() +{} + +DeleteAutoGroupingRuleResult::DeleteAutoGroupingRuleResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteAutoGroupingRuleResult::~DeleteAutoGroupingRuleResult() +{} + +void DeleteAutoGroupingRuleResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/resourcemanager/src/model/DetachPolicyRequest.cc b/resourcemanager/src/model/DetachPolicyRequest.cc index 03a0d7dca..a9c9535b5 100644 --- a/resourcemanager/src/model/DetachPolicyRequest.cc +++ b/resourcemanager/src/model/DetachPolicyRequest.cc @@ -25,6 +25,15 @@ DetachPolicyRequest::DetachPolicyRequest() DetachPolicyRequest::~DetachPolicyRequest() {} +std::string DetachPolicyRequest::getResourceGroupId() const { + return resourceGroupId_; +} + +void DetachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) { + resourceGroupId_ = resourceGroupId; + setParameter(std::string("ResourceGroupId"), resourceGroupId); +} + std::string DetachPolicyRequest::getPolicyType() const { return policyType_; } @@ -43,15 +52,6 @@ void DetachPolicyRequest::setPrincipalType(const std::string &principalType) { setParameter(std::string("PrincipalType"), principalType); } -std::string DetachPolicyRequest::getResourceGroupId() const { - return resourceGroupId_; -} - -void DetachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) { - resourceGroupId_ = resourceGroupId; - setParameter(std::string("ResourceGroupId"), resourceGroupId); -} - std::string DetachPolicyRequest::getPolicyName() const { return policyName_; } diff --git a/resourcemanager/src/model/DisableAssociatedTransferRequest.cc b/resourcemanager/src/model/DisableAssociatedTransferRequest.cc new file mode 100644 index 000000000..a02948985 --- /dev/null +++ b/resourcemanager/src/model/DisableAssociatedTransferRequest.cc @@ -0,0 +1,27 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::DisableAssociatedTransferRequest; + +DisableAssociatedTransferRequest::DisableAssociatedTransferRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "DisableAssociatedTransfer") { + setMethod(HttpRequest::Method::Post); +} + +DisableAssociatedTransferRequest::~DisableAssociatedTransferRequest() {} + diff --git a/resourcemanager/src/model/DisableAssociatedTransferResult.cc b/resourcemanager/src/model/DisableAssociatedTransferResult.cc new file mode 100644 index 000000000..3a4c17c2d --- /dev/null +++ b/resourcemanager/src/model/DisableAssociatedTransferResult.cc @@ -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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +DisableAssociatedTransferResult::DisableAssociatedTransferResult() : + ServiceResult() +{} + +DisableAssociatedTransferResult::DisableAssociatedTransferResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DisableAssociatedTransferResult::~DisableAssociatedTransferResult() +{} + +void DisableAssociatedTransferResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/resourcemanager/src/model/DisableAutoGroupingRequest.cc b/resourcemanager/src/model/DisableAutoGroupingRequest.cc new file mode 100644 index 000000000..0a985b73f --- /dev/null +++ b/resourcemanager/src/model/DisableAutoGroupingRequest.cc @@ -0,0 +1,27 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::DisableAutoGroupingRequest; + +DisableAutoGroupingRequest::DisableAutoGroupingRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "DisableAutoGrouping") { + setMethod(HttpRequest::Method::Post); +} + +DisableAutoGroupingRequest::~DisableAutoGroupingRequest() {} + diff --git a/resourcemanager/src/model/DisableAutoGroupingResult.cc b/resourcemanager/src/model/DisableAutoGroupingResult.cc new file mode 100644 index 000000000..daf6f81fc --- /dev/null +++ b/resourcemanager/src/model/DisableAutoGroupingResult.cc @@ -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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +DisableAutoGroupingResult::DisableAutoGroupingResult() : + ServiceResult() +{} + +DisableAutoGroupingResult::DisableAutoGroupingResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DisableAutoGroupingResult::~DisableAutoGroupingResult() +{} + +void DisableAutoGroupingResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/resourcemanager/src/model/EnableAssociatedTransferRequest.cc b/resourcemanager/src/model/EnableAssociatedTransferRequest.cc new file mode 100644 index 000000000..026eb701b --- /dev/null +++ b/resourcemanager/src/model/EnableAssociatedTransferRequest.cc @@ -0,0 +1,27 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::EnableAssociatedTransferRequest; + +EnableAssociatedTransferRequest::EnableAssociatedTransferRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "EnableAssociatedTransfer") { + setMethod(HttpRequest::Method::Post); +} + +EnableAssociatedTransferRequest::~EnableAssociatedTransferRequest() {} + diff --git a/resourcemanager/src/model/EnableAssociatedTransferResult.cc b/resourcemanager/src/model/EnableAssociatedTransferResult.cc new file mode 100644 index 000000000..62d75e036 --- /dev/null +++ b/resourcemanager/src/model/EnableAssociatedTransferResult.cc @@ -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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +EnableAssociatedTransferResult::EnableAssociatedTransferResult() : + ServiceResult() +{} + +EnableAssociatedTransferResult::EnableAssociatedTransferResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +EnableAssociatedTransferResult::~EnableAssociatedTransferResult() +{} + +void EnableAssociatedTransferResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/resourcemanager/src/model/EnableAutoGroupingRequest.cc b/resourcemanager/src/model/EnableAutoGroupingRequest.cc new file mode 100644 index 000000000..8ab8a8e91 --- /dev/null +++ b/resourcemanager/src/model/EnableAutoGroupingRequest.cc @@ -0,0 +1,27 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::EnableAutoGroupingRequest; + +EnableAutoGroupingRequest::EnableAutoGroupingRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "EnableAutoGrouping") { + setMethod(HttpRequest::Method::Post); +} + +EnableAutoGroupingRequest::~EnableAutoGroupingRequest() {} + diff --git a/resourcemanager/src/model/EnableAutoGroupingResult.cc b/resourcemanager/src/model/EnableAutoGroupingResult.cc new file mode 100644 index 000000000..1bba00545 --- /dev/null +++ b/resourcemanager/src/model/EnableAutoGroupingResult.cc @@ -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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +EnableAutoGroupingResult::EnableAutoGroupingResult() : + ServiceResult() +{} + +EnableAutoGroupingResult::EnableAutoGroupingResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +EnableAutoGroupingResult::~EnableAutoGroupingResult() +{} + +void EnableAutoGroupingResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/resourcemanager/src/model/GetAutoGroupingRuleRequest.cc b/resourcemanager/src/model/GetAutoGroupingRuleRequest.cc new file mode 100644 index 000000000..4e76f19dd --- /dev/null +++ b/resourcemanager/src/model/GetAutoGroupingRuleRequest.cc @@ -0,0 +1,36 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::GetAutoGroupingRuleRequest; + +GetAutoGroupingRuleRequest::GetAutoGroupingRuleRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "GetAutoGroupingRule") { + setMethod(HttpRequest::Method::Post); +} + +GetAutoGroupingRuleRequest::~GetAutoGroupingRuleRequest() {} + +std::string GetAutoGroupingRuleRequest::getRuleId() const { + return ruleId_; +} + +void GetAutoGroupingRuleRequest::setRuleId(const std::string &ruleId) { + ruleId_ = ruleId; + setParameter(std::string("RuleId"), ruleId); +} + diff --git a/resourcemanager/src/model/GetAutoGroupingRuleResult.cc b/resourcemanager/src/model/GetAutoGroupingRuleResult.cc new file mode 100644 index 000000000..556afe706 --- /dev/null +++ b/resourcemanager/src/model/GetAutoGroupingRuleResult.cc @@ -0,0 +1,90 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +GetAutoGroupingRuleResult::GetAutoGroupingRuleResult() : + ServiceResult() +{} + +GetAutoGroupingRuleResult::GetAutoGroupingRuleResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetAutoGroupingRuleResult::~GetAutoGroupingRuleResult() +{} + +void GetAutoGroupingRuleResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto ruleNode = value["Rule"]; + if(!ruleNode["CreateTime"].isNull()) + rule_.createTime = ruleNode["CreateTime"].asString(); + if(!ruleNode["ExcludeRegionIdsScope"].isNull()) + rule_.excludeRegionIdsScope = ruleNode["ExcludeRegionIdsScope"].asString(); + if(!ruleNode["ExcludeResourceGroupIdsScope"].isNull()) + rule_.excludeResourceGroupIdsScope = ruleNode["ExcludeResourceGroupIdsScope"].asString(); + if(!ruleNode["ExcludeResourceIdsScope"].isNull()) + rule_.excludeResourceIdsScope = ruleNode["ExcludeResourceIdsScope"].asString(); + if(!ruleNode["ExcludeResourceTypesScope"].isNull()) + rule_.excludeResourceTypesScope = ruleNode["ExcludeResourceTypesScope"].asString(); + if(!ruleNode["ModifyTime"].isNull()) + rule_.modifyTime = ruleNode["ModifyTime"].asString(); + if(!ruleNode["RegionIdsScope"].isNull()) + rule_.regionIdsScope = ruleNode["RegionIdsScope"].asString(); + if(!ruleNode["ResourceGroupIdsScope"].isNull()) + rule_.resourceGroupIdsScope = ruleNode["ResourceGroupIdsScope"].asString(); + if(!ruleNode["ResourceIdsScope"].isNull()) + rule_.resourceIdsScope = ruleNode["ResourceIdsScope"].asString(); + if(!ruleNode["ResourceTypesScope"].isNull()) + rule_.resourceTypesScope = ruleNode["ResourceTypesScope"].asString(); + if(!ruleNode["RuleDesc"].isNull()) + rule_.ruleDesc = ruleNode["RuleDesc"].asString(); + if(!ruleNode["RuleId"].isNull()) + rule_.ruleId = ruleNode["RuleId"].asString(); + if(!ruleNode["RuleName"].isNull()) + rule_.ruleName = ruleNode["RuleName"].asString(); + if(!ruleNode["RuleType"].isNull()) + rule_.ruleType = ruleNode["RuleType"].asString(); + auto allRuleContentsNode = ruleNode["RuleContents"]["RuleContent"]; + for (auto ruleNodeRuleContentsRuleContent : allRuleContentsNode) + { + Rule::RuleContent ruleContentObject; + if(!ruleNodeRuleContentsRuleContent["AutoGroupingScopeCondition"].isNull()) + ruleContentObject.autoGroupingScopeCondition = ruleNodeRuleContentsRuleContent["AutoGroupingScopeCondition"].asString(); + if(!ruleNodeRuleContentsRuleContent["RuleContentId"].isNull()) + ruleContentObject.ruleContentId = ruleNodeRuleContentsRuleContent["RuleContentId"].asString(); + if(!ruleNodeRuleContentsRuleContent["TargetResourceGroupCondition"].isNull()) + ruleContentObject.targetResourceGroupCondition = ruleNodeRuleContentsRuleContent["TargetResourceGroupCondition"].asString(); + rule_.ruleContents.push_back(ruleContentObject); + } + +} + +GetAutoGroupingRuleResult::Rule GetAutoGroupingRuleResult::getRule()const +{ + return rule_; +} + diff --git a/resourcemanager/src/model/GetAutoGroupingStatusRequest.cc b/resourcemanager/src/model/GetAutoGroupingStatusRequest.cc new file mode 100644 index 000000000..5e5a4a399 --- /dev/null +++ b/resourcemanager/src/model/GetAutoGroupingStatusRequest.cc @@ -0,0 +1,27 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::GetAutoGroupingStatusRequest; + +GetAutoGroupingStatusRequest::GetAutoGroupingStatusRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "GetAutoGroupingStatus") { + setMethod(HttpRequest::Method::Post); +} + +GetAutoGroupingStatusRequest::~GetAutoGroupingStatusRequest() {} + diff --git a/resourcemanager/src/model/GetAutoGroupingStatusResult.cc b/resourcemanager/src/model/GetAutoGroupingStatusResult.cc new file mode 100644 index 000000000..b712b168d --- /dev/null +++ b/resourcemanager/src/model/GetAutoGroupingStatusResult.cc @@ -0,0 +1,58 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +GetAutoGroupingStatusResult::GetAutoGroupingStatusResult() : + ServiceResult() +{} + +GetAutoGroupingStatusResult::GetAutoGroupingStatusResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetAutoGroupingStatusResult::~GetAutoGroupingStatusResult() +{} + +void GetAutoGroupingStatusResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["EnableExistedResourcesTransfer"].isNull()) + enableExistedResourcesTransfer_ = value["EnableExistedResourcesTransfer"].asString() == "true"; + if(!value["EnableStatus"].isNull()) + enableStatus_ = value["EnableStatus"].asString(); + +} + +std::string GetAutoGroupingStatusResult::getEnableStatus()const +{ + return enableStatus_; +} + +bool GetAutoGroupingStatusResult::getEnableExistedResourcesTransfer()const +{ + return enableExistedResourcesTransfer_; +} + diff --git a/resourcemanager/src/model/GetPolicyResult.cc b/resourcemanager/src/model/GetPolicyResult.cc index abed45478..13594a235 100644 --- a/resourcemanager/src/model/GetPolicyResult.cc +++ b/resourcemanager/src/model/GetPolicyResult.cc @@ -40,22 +40,22 @@ void GetPolicyResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto policyNode = value["Policy"]; + if(!policyNode["AttachmentCount"].isNull()) + policy_.attachmentCount = std::stoi(policyNode["AttachmentCount"].asString()); + if(!policyNode["CreateDate"].isNull()) + policy_.createDate = policyNode["CreateDate"].asString(); if(!policyNode["DefaultVersion"].isNull()) policy_.defaultVersion = policyNode["DefaultVersion"].asString(); - if(!policyNode["UpdateDate"].isNull()) - policy_.updateDate = policyNode["UpdateDate"].asString(); if(!policyNode["Description"].isNull()) policy_.description = policyNode["Description"].asString(); if(!policyNode["PolicyDocument"].isNull()) policy_.policyDocument = policyNode["PolicyDocument"].asString(); - if(!policyNode["AttachmentCount"].isNull()) - policy_.attachmentCount = std::stoi(policyNode["AttachmentCount"].asString()); if(!policyNode["PolicyName"].isNull()) policy_.policyName = policyNode["PolicyName"].asString(); - if(!policyNode["CreateDate"].isNull()) - policy_.createDate = policyNode["CreateDate"].asString(); if(!policyNode["PolicyType"].isNull()) policy_.policyType = policyNode["PolicyType"].asString(); + if(!policyNode["UpdateDate"].isNull()) + policy_.updateDate = policyNode["UpdateDate"].asString(); } diff --git a/resourcemanager/src/model/GetPolicyVersionResult.cc b/resourcemanager/src/model/GetPolicyVersionResult.cc index ff3aaade8..29f5f147c 100644 --- a/resourcemanager/src/model/GetPolicyVersionResult.cc +++ b/resourcemanager/src/model/GetPolicyVersionResult.cc @@ -40,14 +40,14 @@ void GetPolicyVersionResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto policyVersionNode = value["PolicyVersion"]; + if(!policyVersionNode["CreateDate"].isNull()) + policyVersion_.createDate = policyVersionNode["CreateDate"].asString(); if(!policyVersionNode["IsDefaultVersion"].isNull()) policyVersion_.isDefaultVersion = policyVersionNode["IsDefaultVersion"].asString() == "true"; if(!policyVersionNode["PolicyDocument"].isNull()) policyVersion_.policyDocument = policyVersionNode["PolicyDocument"].asString(); if(!policyVersionNode["VersionId"].isNull()) policyVersion_.versionId = policyVersionNode["VersionId"].asString(); - if(!policyVersionNode["CreateDate"].isNull()) - policyVersion_.createDate = policyVersionNode["CreateDate"].asString(); } diff --git a/resourcemanager/src/model/GetResourceDirectoryResult.cc b/resourcemanager/src/model/GetResourceDirectoryResult.cc index dfce3aa48..cd821d184 100644 --- a/resourcemanager/src/model/GetResourceDirectoryResult.cc +++ b/resourcemanager/src/model/GetResourceDirectoryResult.cc @@ -40,24 +40,24 @@ void GetResourceDirectoryResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto resourceDirectoryNode = value["ResourceDirectory"]; - if(!resourceDirectoryNode["RootFolderId"].isNull()) - resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString(); - if(!resourceDirectoryNode["ResourceDirectoryId"].isNull()) - resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString(); + if(!resourceDirectoryNode["ControlPolicyStatus"].isNull()) + resourceDirectory_.controlPolicyStatus = resourceDirectoryNode["ControlPolicyStatus"].asString(); if(!resourceDirectoryNode["CreateTime"].isNull()) resourceDirectory_.createTime = resourceDirectoryNode["CreateTime"].asString(); + if(!resourceDirectoryNode["IdentityInformation"].isNull()) + resourceDirectory_.identityInformation = resourceDirectoryNode["IdentityInformation"].asString(); if(!resourceDirectoryNode["MasterAccountId"].isNull()) resourceDirectory_.masterAccountId = resourceDirectoryNode["MasterAccountId"].asString(); if(!resourceDirectoryNode["MasterAccountName"].isNull()) resourceDirectory_.masterAccountName = resourceDirectoryNode["MasterAccountName"].asString(); - if(!resourceDirectoryNode["ScpStatus"].isNull()) - resourceDirectory_.scpStatus = resourceDirectoryNode["ScpStatus"].asString(); - if(!resourceDirectoryNode["ControlPolicyStatus"].isNull()) - resourceDirectory_.controlPolicyStatus = resourceDirectoryNode["ControlPolicyStatus"].asString(); if(!resourceDirectoryNode["MemberDeletionStatus"].isNull()) resourceDirectory_.memberDeletionStatus = resourceDirectoryNode["MemberDeletionStatus"].asString(); - if(!resourceDirectoryNode["IdentityInformation"].isNull()) - resourceDirectory_.identityInformation = resourceDirectoryNode["IdentityInformation"].asString(); + if(!resourceDirectoryNode["ResourceDirectoryId"].isNull()) + resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString(); + if(!resourceDirectoryNode["RootFolderId"].isNull()) + resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString(); + if(!resourceDirectoryNode["ScpStatus"].isNull()) + resourceDirectory_.scpStatus = resourceDirectoryNode["ScpStatus"].asString(); } diff --git a/resourcemanager/src/model/GetRoleResult.cc b/resourcemanager/src/model/GetRoleResult.cc index 4f741181b..ddd2e3600 100644 --- a/resourcemanager/src/model/GetRoleResult.cc +++ b/resourcemanager/src/model/GetRoleResult.cc @@ -40,31 +40,31 @@ void GetRoleResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto roleNode = value["Role"]; + if(!roleNode["Arn"].isNull()) + role_.arn = roleNode["Arn"].asString(); if(!roleNode["AssumeRolePolicyDocument"].isNull()) role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString(); + if(!roleNode["CreateDate"].isNull()) + role_.createDate = roleNode["CreateDate"].asString(); + if(!roleNode["Description"].isNull()) + role_.description = roleNode["Description"].asString(); + if(!roleNode["IsServiceLinkedRole"].isNull()) + role_.isServiceLinkedRole = roleNode["IsServiceLinkedRole"].asString() == "true"; + if(!roleNode["MaxSessionDuration"].isNull()) + role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString()); + if(!roleNode["RoleId"].isNull()) + role_.roleId = roleNode["RoleId"].asString(); + if(!roleNode["RoleName"].isNull()) + role_.roleName = roleNode["RoleName"].asString(); if(!roleNode["RolePrincipalName"].isNull()) role_.rolePrincipalName = roleNode["RolePrincipalName"].asString(); if(!roleNode["UpdateDate"].isNull()) role_.updateDate = roleNode["UpdateDate"].asString(); - if(!roleNode["Description"].isNull()) - role_.description = roleNode["Description"].asString(); - if(!roleNode["MaxSessionDuration"].isNull()) - role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString()); - if(!roleNode["RoleName"].isNull()) - role_.roleName = roleNode["RoleName"].asString(); - if(!roleNode["CreateDate"].isNull()) - role_.createDate = roleNode["CreateDate"].asString(); - if(!roleNode["RoleId"].isNull()) - role_.roleId = roleNode["RoleId"].asString(); - if(!roleNode["Arn"].isNull()) - role_.arn = roleNode["Arn"].asString(); - if(!roleNode["IsServiceLinkedRole"].isNull()) - role_.isServiceLinkedRole = roleNode["IsServiceLinkedRole"].asString() == "true"; auto latestDeletionTaskNode = roleNode["LatestDeletionTask"]; - if(!latestDeletionTaskNode["DeletionTaskId"].isNull()) - role_.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString(); if(!latestDeletionTaskNode["CreateDate"].isNull()) role_.latestDeletionTask.createDate = latestDeletionTaskNode["CreateDate"].asString(); + if(!latestDeletionTaskNode["DeletionTaskId"].isNull()) + role_.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString(); } diff --git a/resourcemanager/src/model/InitResourceDirectoryResult.cc b/resourcemanager/src/model/InitResourceDirectoryResult.cc index 6a727b821..1d188af1e 100644 --- a/resourcemanager/src/model/InitResourceDirectoryResult.cc +++ b/resourcemanager/src/model/InitResourceDirectoryResult.cc @@ -40,16 +40,16 @@ void InitResourceDirectoryResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto resourceDirectoryNode = value["ResourceDirectory"]; - if(!resourceDirectoryNode["RootFolderId"].isNull()) - resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString(); - if(!resourceDirectoryNode["ResourceDirectoryId"].isNull()) - resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString(); if(!resourceDirectoryNode["CreateTime"].isNull()) resourceDirectory_.createTime = resourceDirectoryNode["CreateTime"].asString(); if(!resourceDirectoryNode["MasterAccountId"].isNull()) resourceDirectory_.masterAccountId = resourceDirectoryNode["MasterAccountId"].asString(); if(!resourceDirectoryNode["MasterAccountName"].isNull()) resourceDirectory_.masterAccountName = resourceDirectoryNode["MasterAccountName"].asString(); + if(!resourceDirectoryNode["ResourceDirectoryId"].isNull()) + resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString(); + if(!resourceDirectoryNode["RootFolderId"].isNull()) + resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString(); } diff --git a/resourcemanager/src/model/ListAccountsForParentRequest.cc b/resourcemanager/src/model/ListAccountsForParentRequest.cc index 5bfbed0b5..e3e343d77 100644 --- a/resourcemanager/src/model/ListAccountsForParentRequest.cc +++ b/resourcemanager/src/model/ListAccountsForParentRequest.cc @@ -25,15 +25,6 @@ ListAccountsForParentRequest::ListAccountsForParentRequest() ListAccountsForParentRequest::~ListAccountsForParentRequest() {} -std::string ListAccountsForParentRequest::getQueryKeyword() const { - return queryKeyword_; -} - -void ListAccountsForParentRequest::setQueryKeyword(const std::string &queryKeyword) { - queryKeyword_ = queryKeyword; - setParameter(std::string("QueryKeyword"), queryKeyword); -} - int ListAccountsForParentRequest::getPageNumber() const { return pageNumber_; } @@ -43,24 +34,6 @@ void ListAccountsForParentRequest::setPageNumber(int pageNumber) { setParameter(std::string("PageNumber"), std::to_string(pageNumber)); } -std::string ListAccountsForParentRequest::getParentFolderId() const { - return parentFolderId_; -} - -void ListAccountsForParentRequest::setParentFolderId(const std::string &parentFolderId) { - parentFolderId_ = parentFolderId; - setParameter(std::string("ParentFolderId"), parentFolderId); -} - -bool ListAccountsForParentRequest::getIncludeTags() const { - return includeTags_; -} - -void ListAccountsForParentRequest::setIncludeTags(bool includeTags) { - includeTags_ = includeTags; - setParameter(std::string("IncludeTags"), includeTags ? "true" : "false"); -} - int ListAccountsForParentRequest::getPageSize() const { return pageSize_; } @@ -82,3 +55,30 @@ void ListAccountsForParentRequest::setTag(const std::vector + +using AlibabaCloud::ResourceManager::Model::ListAssociatedTransferSettingRequest; + +ListAssociatedTransferSettingRequest::ListAssociatedTransferSettingRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "ListAssociatedTransferSetting") { + setMethod(HttpRequest::Method::Post); +} + +ListAssociatedTransferSettingRequest::~ListAssociatedTransferSettingRequest() {} + diff --git a/resourcemanager/src/model/ListAssociatedTransferSettingResult.cc b/resourcemanager/src/model/ListAssociatedTransferSettingResult.cc new file mode 100644 index 000000000..471b6a77b --- /dev/null +++ b/resourcemanager/src/model/ListAssociatedTransferSettingResult.cc @@ -0,0 +1,78 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +ListAssociatedTransferSettingResult::ListAssociatedTransferSettingResult() : + ServiceResult() +{} + +ListAssociatedTransferSettingResult::ListAssociatedTransferSettingResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAssociatedTransferSettingResult::~ListAssociatedTransferSettingResult() +{} + +void ListAssociatedTransferSettingResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto associatedTransferSettingNode = value["AssociatedTransferSetting"]; + if(!associatedTransferSettingNode["AccountId"].isNull()) + associatedTransferSetting_.accountId = associatedTransferSettingNode["AccountId"].asString(); + if(!associatedTransferSettingNode["Status"].isNull()) + associatedTransferSetting_.status = associatedTransferSettingNode["Status"].asString(); + if(!associatedTransferSettingNode["EnablePartialRule"].isNull()) + associatedTransferSetting_.enablePartialRule = associatedTransferSettingNode["EnablePartialRule"].asString(); + if(!associatedTransferSettingNode["EnableExistingResourcesTransfer"].isNull()) + associatedTransferSetting_.enableExistingResourcesTransfer = associatedTransferSettingNode["EnableExistingResourcesTransfer"].asString(); + auto allRuleSettingsNode = associatedTransferSettingNode["RuleSettings"]["RuleSetting"]; + for (auto associatedTransferSettingNodeRuleSettingsRuleSetting : allRuleSettingsNode) + { + AssociatedTransferSetting::RuleSetting ruleSettingObject; + if(!associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedResourceType"].isNull()) + ruleSettingObject.associatedResourceType = associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedResourceType"].asString(); + if(!associatedTransferSettingNodeRuleSettingsRuleSetting["MasterResourceType"].isNull()) + ruleSettingObject.masterResourceType = associatedTransferSettingNodeRuleSettingsRuleSetting["MasterResourceType"].asString(); + if(!associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedService"].isNull()) + ruleSettingObject.associatedService = associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedService"].asString(); + if(!associatedTransferSettingNodeRuleSettingsRuleSetting["MasterService"].isNull()) + ruleSettingObject.masterService = associatedTransferSettingNodeRuleSettingsRuleSetting["MasterService"].asString(); + if(!associatedTransferSettingNodeRuleSettingsRuleSetting["TriggerType"].isNull()) + ruleSettingObject.triggerType = associatedTransferSettingNodeRuleSettingsRuleSetting["TriggerType"].asString(); + if(!associatedTransferSettingNodeRuleSettingsRuleSetting["RuleId"].isNull()) + ruleSettingObject.ruleId = associatedTransferSettingNodeRuleSettingsRuleSetting["RuleId"].asString(); + if(!associatedTransferSettingNodeRuleSettingsRuleSetting["Status"].isNull()) + ruleSettingObject.status = associatedTransferSettingNodeRuleSettingsRuleSetting["Status"].asString(); + associatedTransferSetting_.ruleSettings.push_back(ruleSettingObject); + } + +} + +ListAssociatedTransferSettingResult::AssociatedTransferSetting ListAssociatedTransferSettingResult::getAssociatedTransferSetting()const +{ + return associatedTransferSetting_; +} + diff --git a/resourcemanager/src/model/ListAutoGroupingRulesRequest.cc b/resourcemanager/src/model/ListAutoGroupingRulesRequest.cc new file mode 100644 index 000000000..09eda61e3 --- /dev/null +++ b/resourcemanager/src/model/ListAutoGroupingRulesRequest.cc @@ -0,0 +1,72 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::ListAutoGroupingRulesRequest; + +ListAutoGroupingRulesRequest::ListAutoGroupingRulesRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "ListAutoGroupingRules") { + setMethod(HttpRequest::Method::Post); +} + +ListAutoGroupingRulesRequest::~ListAutoGroupingRulesRequest() {} + +std::string ListAutoGroupingRulesRequest::getRuleName() const { + return ruleName_; +} + +void ListAutoGroupingRulesRequest::setRuleName(const std::string &ruleName) { + ruleName_ = ruleName; + setParameter(std::string("RuleName"), ruleName); +} + +std::string ListAutoGroupingRulesRequest::getNextToken() const { + return nextToken_; +} + +void ListAutoGroupingRulesRequest::setNextToken(const std::string &nextToken) { + nextToken_ = nextToken; + setParameter(std::string("NextToken"), nextToken); +} + +std::string ListAutoGroupingRulesRequest::getRuleType() const { + return ruleType_; +} + +void ListAutoGroupingRulesRequest::setRuleType(const std::string &ruleType) { + ruleType_ = ruleType; + setParameter(std::string("RuleType"), ruleType); +} + +int ListAutoGroupingRulesRequest::getMaxResults() const { + return maxResults_; +} + +void ListAutoGroupingRulesRequest::setMaxResults(int maxResults) { + maxResults_ = maxResults; + setParameter(std::string("MaxResults"), std::to_string(maxResults)); +} + +std::string ListAutoGroupingRulesRequest::getRuleId() const { + return ruleId_; +} + +void ListAutoGroupingRulesRequest::setRuleId(const std::string &ruleId) { + ruleId_ = ruleId; + setParameter(std::string("RuleId"), ruleId); +} + diff --git a/resourcemanager/src/model/ListAutoGroupingRulesResult.cc b/resourcemanager/src/model/ListAutoGroupingRulesResult.cc new file mode 100644 index 000000000..573a1f7e5 --- /dev/null +++ b/resourcemanager/src/model/ListAutoGroupingRulesResult.cc @@ -0,0 +1,109 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +ListAutoGroupingRulesResult::ListAutoGroupingRulesResult() : + ServiceResult() +{} + +ListAutoGroupingRulesResult::ListAutoGroupingRulesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAutoGroupingRulesResult::~ListAutoGroupingRulesResult() +{} + +void ListAutoGroupingRulesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allRulesNode = value["Rules"]["Rule"]; + for (auto valueRulesRule : allRulesNode) + { + Rule rulesObject; + if(!valueRulesRule["CreateTime"].isNull()) + rulesObject.createTime = valueRulesRule["CreateTime"].asString(); + if(!valueRulesRule["ExcludeRegionIdsScope"].isNull()) + rulesObject.excludeRegionIdsScope = valueRulesRule["ExcludeRegionIdsScope"].asString(); + if(!valueRulesRule["ExcludeResourceGroupIdsScope"].isNull()) + rulesObject.excludeResourceGroupIdsScope = valueRulesRule["ExcludeResourceGroupIdsScope"].asString(); + if(!valueRulesRule["ExcludeResourceIdsScope"].isNull()) + rulesObject.excludeResourceIdsScope = valueRulesRule["ExcludeResourceIdsScope"].asString(); + if(!valueRulesRule["ExcludeResourceTypesScope"].isNull()) + rulesObject.excludeResourceTypesScope = valueRulesRule["ExcludeResourceTypesScope"].asString(); + if(!valueRulesRule["ModifyTime"].isNull()) + rulesObject.modifyTime = valueRulesRule["ModifyTime"].asString(); + if(!valueRulesRule["RegionIdsScope"].isNull()) + rulesObject.regionIdsScope = valueRulesRule["RegionIdsScope"].asString(); + if(!valueRulesRule["ResourceGroupIdsScope"].isNull()) + rulesObject.resourceGroupIdsScope = valueRulesRule["ResourceGroupIdsScope"].asString(); + if(!valueRulesRule["ResourceIdsScope"].isNull()) + rulesObject.resourceIdsScope = valueRulesRule["ResourceIdsScope"].asString(); + if(!valueRulesRule["ResourceTypesScope"].isNull()) + rulesObject.resourceTypesScope = valueRulesRule["ResourceTypesScope"].asString(); + if(!valueRulesRule["RuleDesc"].isNull()) + rulesObject.ruleDesc = valueRulesRule["RuleDesc"].asString(); + if(!valueRulesRule["RuleId"].isNull()) + rulesObject.ruleId = valueRulesRule["RuleId"].asString(); + if(!valueRulesRule["RuleName"].isNull()) + rulesObject.ruleName = valueRulesRule["RuleName"].asString(); + if(!valueRulesRule["RuleType"].isNull()) + rulesObject.ruleType = valueRulesRule["RuleType"].asString(); + auto allRuleContentsNode = valueRulesRule["RuleContents"]["RuleContent"]; + for (auto valueRulesRuleRuleContentsRuleContent : allRuleContentsNode) + { + Rule::RuleContent ruleContentsObject; + if(!valueRulesRuleRuleContentsRuleContent["AutoGroupingScopeCondition"].isNull()) + ruleContentsObject.autoGroupingScopeCondition = valueRulesRuleRuleContentsRuleContent["AutoGroupingScopeCondition"].asString(); + if(!valueRulesRuleRuleContentsRuleContent["RuleContentId"].isNull()) + ruleContentsObject.ruleContentId = valueRulesRuleRuleContentsRuleContent["RuleContentId"].asString(); + if(!valueRulesRuleRuleContentsRuleContent["TargetResourceGroupCondition"].isNull()) + ruleContentsObject.targetResourceGroupCondition = valueRulesRuleRuleContentsRuleContent["TargetResourceGroupCondition"].asString(); + rulesObject.ruleContents.push_back(ruleContentsObject); + } + rules_.push_back(rulesObject); + } + if(!value["NextToken"].isNull()) + nextToken_ = value["NextToken"].asString(); + if(!value["MaxResults"].isNull()) + maxResults_ = std::stoi(value["MaxResults"].asString()); + +} + +std::string ListAutoGroupingRulesResult::getNextToken()const +{ + return nextToken_; +} + +int ListAutoGroupingRulesResult::getMaxResults()const +{ + return maxResults_; +} + +std::vector ListAutoGroupingRulesResult::getRules()const +{ + return rules_; +} + diff --git a/resourcemanager/src/model/ListPoliciesResult.cc b/resourcemanager/src/model/ListPoliciesResult.cc index ff1da025e..51212e7bb 100644 --- a/resourcemanager/src/model/ListPoliciesResult.cc +++ b/resourcemanager/src/model/ListPoliciesResult.cc @@ -43,28 +43,28 @@ void ListPoliciesResult::parse(const std::string &payload) for (auto valuePoliciesPolicy : allPoliciesNode) { Policy policiesObject; + if(!valuePoliciesPolicy["AttachmentCount"].isNull()) + policiesObject.attachmentCount = std::stoi(valuePoliciesPolicy["AttachmentCount"].asString()); + if(!valuePoliciesPolicy["CreateDate"].isNull()) + policiesObject.createDate = valuePoliciesPolicy["CreateDate"].asString(); if(!valuePoliciesPolicy["DefaultVersion"].isNull()) policiesObject.defaultVersion = valuePoliciesPolicy["DefaultVersion"].asString(); if(!valuePoliciesPolicy["Description"].isNull()) policiesObject.description = valuePoliciesPolicy["Description"].asString(); - if(!valuePoliciesPolicy["UpdateDate"].isNull()) - policiesObject.updateDate = valuePoliciesPolicy["UpdateDate"].asString(); - if(!valuePoliciesPolicy["AttachmentCount"].isNull()) - policiesObject.attachmentCount = std::stoi(valuePoliciesPolicy["AttachmentCount"].asString()); if(!valuePoliciesPolicy["PolicyName"].isNull()) policiesObject.policyName = valuePoliciesPolicy["PolicyName"].asString(); - if(!valuePoliciesPolicy["CreateDate"].isNull()) - policiesObject.createDate = valuePoliciesPolicy["CreateDate"].asString(); if(!valuePoliciesPolicy["PolicyType"].isNull()) policiesObject.policyType = valuePoliciesPolicy["PolicyType"].asString(); + if(!valuePoliciesPolicy["UpdateDate"].isNull()) + policiesObject.updateDate = valuePoliciesPolicy["UpdateDate"].asString(); policies_.push_back(policiesObject); } - if(!value["TotalCount"].isNull()) - totalCount_ = std::stoi(value["TotalCount"].asString()); - if(!value["PageSize"].isNull()) - pageSize_ = std::stoi(value["PageSize"].asString()); if(!value["PageNumber"].isNull()) pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); } diff --git a/resourcemanager/src/model/ListPolicyAttachmentsResult.cc b/resourcemanager/src/model/ListPolicyAttachmentsResult.cc index 3a03e8554..b430fbeef 100644 --- a/resourcemanager/src/model/ListPolicyAttachmentsResult.cc +++ b/resourcemanager/src/model/ListPolicyAttachmentsResult.cc @@ -43,28 +43,28 @@ void ListPolicyAttachmentsResult::parse(const std::string &payload) for (auto valuePolicyAttachmentsPolicyAttachment : allPolicyAttachmentsNode) { PolicyAttachment policyAttachmentsObject; - if(!valuePolicyAttachmentsPolicyAttachment["Description"].isNull()) - policyAttachmentsObject.description = valuePolicyAttachmentsPolicyAttachment["Description"].asString(); - if(!valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].isNull()) - policyAttachmentsObject.resourceGroupId = valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].asString(); - if(!valuePolicyAttachmentsPolicyAttachment["PolicyName"].isNull()) - policyAttachmentsObject.policyName = valuePolicyAttachmentsPolicyAttachment["PolicyName"].asString(); - if(!valuePolicyAttachmentsPolicyAttachment["PrincipalName"].isNull()) - policyAttachmentsObject.principalName = valuePolicyAttachmentsPolicyAttachment["PrincipalName"].asString(); if(!valuePolicyAttachmentsPolicyAttachment["AttachDate"].isNull()) policyAttachmentsObject.attachDate = valuePolicyAttachmentsPolicyAttachment["AttachDate"].asString(); + if(!valuePolicyAttachmentsPolicyAttachment["Description"].isNull()) + policyAttachmentsObject.description = valuePolicyAttachmentsPolicyAttachment["Description"].asString(); + if(!valuePolicyAttachmentsPolicyAttachment["PolicyName"].isNull()) + policyAttachmentsObject.policyName = valuePolicyAttachmentsPolicyAttachment["PolicyName"].asString(); if(!valuePolicyAttachmentsPolicyAttachment["PolicyType"].isNull()) policyAttachmentsObject.policyType = valuePolicyAttachmentsPolicyAttachment["PolicyType"].asString(); + if(!valuePolicyAttachmentsPolicyAttachment["PrincipalName"].isNull()) + policyAttachmentsObject.principalName = valuePolicyAttachmentsPolicyAttachment["PrincipalName"].asString(); if(!valuePolicyAttachmentsPolicyAttachment["PrincipalType"].isNull()) policyAttachmentsObject.principalType = valuePolicyAttachmentsPolicyAttachment["PrincipalType"].asString(); + if(!valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].isNull()) + policyAttachmentsObject.resourceGroupId = valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].asString(); policyAttachments_.push_back(policyAttachmentsObject); } - if(!value["TotalCount"].isNull()) - totalCount_ = std::stoi(value["TotalCount"].asString()); - if(!value["PageSize"].isNull()) - pageSize_ = std::stoi(value["PageSize"].asString()); if(!value["PageNumber"].isNull()) pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); } diff --git a/resourcemanager/src/model/ListPolicyVersionsResult.cc b/resourcemanager/src/model/ListPolicyVersionsResult.cc index 5040ada4c..d1be86119 100644 --- a/resourcemanager/src/model/ListPolicyVersionsResult.cc +++ b/resourcemanager/src/model/ListPolicyVersionsResult.cc @@ -43,12 +43,12 @@ void ListPolicyVersionsResult::parse(const std::string &payload) for (auto valuePolicyVersionsPolicyVersion : allPolicyVersionsNode) { PolicyVersion policyVersionsObject; + if(!valuePolicyVersionsPolicyVersion["CreateDate"].isNull()) + policyVersionsObject.createDate = valuePolicyVersionsPolicyVersion["CreateDate"].asString(); if(!valuePolicyVersionsPolicyVersion["IsDefaultVersion"].isNull()) policyVersionsObject.isDefaultVersion = valuePolicyVersionsPolicyVersion["IsDefaultVersion"].asString() == "true"; if(!valuePolicyVersionsPolicyVersion["VersionId"].isNull()) policyVersionsObject.versionId = valuePolicyVersionsPolicyVersion["VersionId"].asString(); - if(!valuePolicyVersionsPolicyVersion["CreateDate"].isNull()) - policyVersionsObject.createDate = valuePolicyVersionsPolicyVersion["CreateDate"].asString(); policyVersions_.push_back(policyVersionsObject); } diff --git a/resourcemanager/src/model/ListRolesResult.cc b/resourcemanager/src/model/ListRolesResult.cc index 2bc6b9134..ee7b78f20 100644 --- a/resourcemanager/src/model/ListRolesResult.cc +++ b/resourcemanager/src/model/ListRolesResult.cc @@ -43,37 +43,37 @@ void ListRolesResult::parse(const std::string &payload) for (auto valueRolesRole : allRolesNode) { Role rolesObject; + if(!valueRolesRole["Arn"].isNull()) + rolesObject.arn = valueRolesRole["Arn"].asString(); + if(!valueRolesRole["CreateDate"].isNull()) + rolesObject.createDate = valueRolesRole["CreateDate"].asString(); + if(!valueRolesRole["Description"].isNull()) + rolesObject.description = valueRolesRole["Description"].asString(); + if(!valueRolesRole["IsServiceLinkedRole"].isNull()) + rolesObject.isServiceLinkedRole = valueRolesRole["IsServiceLinkedRole"].asString() == "true"; + if(!valueRolesRole["MaxSessionDuration"].isNull()) + rolesObject.maxSessionDuration = std::stol(valueRolesRole["MaxSessionDuration"].asString()); + if(!valueRolesRole["RoleId"].isNull()) + rolesObject.roleId = valueRolesRole["RoleId"].asString(); + if(!valueRolesRole["RoleName"].isNull()) + rolesObject.roleName = valueRolesRole["RoleName"].asString(); if(!valueRolesRole["RolePrincipalName"].isNull()) rolesObject.rolePrincipalName = valueRolesRole["RolePrincipalName"].asString(); if(!valueRolesRole["UpdateDate"].isNull()) rolesObject.updateDate = valueRolesRole["UpdateDate"].asString(); - if(!valueRolesRole["Description"].isNull()) - rolesObject.description = valueRolesRole["Description"].asString(); - if(!valueRolesRole["MaxSessionDuration"].isNull()) - rolesObject.maxSessionDuration = std::stol(valueRolesRole["MaxSessionDuration"].asString()); - if(!valueRolesRole["RoleName"].isNull()) - rolesObject.roleName = valueRolesRole["RoleName"].asString(); - if(!valueRolesRole["CreateDate"].isNull()) - rolesObject.createDate = valueRolesRole["CreateDate"].asString(); - if(!valueRolesRole["RoleId"].isNull()) - rolesObject.roleId = valueRolesRole["RoleId"].asString(); - if(!valueRolesRole["Arn"].isNull()) - rolesObject.arn = valueRolesRole["Arn"].asString(); - if(!valueRolesRole["IsServiceLinkedRole"].isNull()) - rolesObject.isServiceLinkedRole = valueRolesRole["IsServiceLinkedRole"].asString() == "true"; auto latestDeletionTaskNode = value["LatestDeletionTask"]; - if(!latestDeletionTaskNode["DeletionTaskId"].isNull()) - rolesObject.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString(); if(!latestDeletionTaskNode["CreateDate"].isNull()) rolesObject.latestDeletionTask.createDate = latestDeletionTaskNode["CreateDate"].asString(); + if(!latestDeletionTaskNode["DeletionTaskId"].isNull()) + rolesObject.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString(); roles_.push_back(rolesObject); } - if(!value["TotalCount"].isNull()) - totalCount_ = std::stoi(value["TotalCount"].asString()); - if(!value["PageSize"].isNull()) - pageSize_ = std::stoi(value["PageSize"].asString()); if(!value["PageNumber"].isNull()) pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); } diff --git a/resourcemanager/src/model/ListTagResourcesRequest.cc b/resourcemanager/src/model/ListTagResourcesRequest.cc index 3eef235a0..7e939da5b 100644 --- a/resourcemanager/src/model/ListTagResourcesRequest.cc +++ b/resourcemanager/src/model/ListTagResourcesRequest.cc @@ -25,6 +25,27 @@ ListTagResourcesRequest::ListTagResourcesRequest() ListTagResourcesRequest::~ListTagResourcesRequest() {} +std::string ListTagResourcesRequest::getNextToken() const { + return nextToken_; +} + +void ListTagResourcesRequest::setNextToken(const std::string &nextToken) { + nextToken_ = nextToken; + setParameter(std::string("NextToken"), nextToken); +} + +std::vector ListTagResourcesRequest::getTag() const { + return tag_; +} + +void ListTagResourcesRequest::setTag(const std::vector &tag) { + tag_ = tag; + for(int dep1 = 0; dep1 != tag.size(); dep1++) { + setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Value", tag[dep1].value); + setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Key", tag[dep1].key); + } +} + std::vector ListTagResourcesRequest::getResourceId() const { return resourceId_; } @@ -45,15 +66,6 @@ void ListTagResourcesRequest::setResourceType(const std::string &resourceType) { setParameter(std::string("ResourceType"), resourceType); } -std::string ListTagResourcesRequest::getNextToken() const { - return nextToken_; -} - -void ListTagResourcesRequest::setNextToken(const std::string &nextToken) { - nextToken_ = nextToken; - setParameter(std::string("NextToken"), nextToken); -} - int ListTagResourcesRequest::getMaxResults() const { return maxResults_; } @@ -63,15 +75,3 @@ void ListTagResourcesRequest::setMaxResults(int maxResults) { setParameter(std::string("MaxResults"), std::to_string(maxResults)); } -std::vector ListTagResourcesRequest::getTag() const { - return tag_; -} - -void ListTagResourcesRequest::setTag(const std::vector &tag) { - tag_ = tag; - for(int dep1 = 0; dep1 != tag.size(); dep1++) { - setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Value", tag[dep1].value); - setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Key", tag[dep1].key); - } -} - diff --git a/resourcemanager/src/model/PromoteResourceAccountResult.cc b/resourcemanager/src/model/PromoteResourceAccountResult.cc index cc51958b0..ae4849b22 100644 --- a/resourcemanager/src/model/PromoteResourceAccountResult.cc +++ b/resourcemanager/src/model/PromoteResourceAccountResult.cc @@ -40,28 +40,28 @@ void PromoteResourceAccountResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto accountNode = value["Account"]; - if(!accountNode["Status"].isNull()) - account_.status = accountNode["Status"].asString(); - if(!accountNode["Type"].isNull()) - account_.type = accountNode["Type"].asString(); + if(!accountNode["AccountId"].isNull()) + account_.accountId = accountNode["AccountId"].asString(); + if(!accountNode["AccountName"].isNull()) + account_.accountName = accountNode["AccountName"].asString(); if(!accountNode["DisplayName"].isNull()) account_.displayName = accountNode["DisplayName"].asString(); if(!accountNode["FolderId"].isNull()) account_.folderId = accountNode["FolderId"].asString(); - if(!accountNode["ResourceDirectoryId"].isNull()) - account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString(); - if(!accountNode["RecordId"].isNull()) - account_.recordId = accountNode["RecordId"].asString(); - if(!accountNode["JoinTime"].isNull()) - account_.joinTime = accountNode["JoinTime"].asString(); - if(!accountNode["AccountId"].isNull()) - account_.accountId = accountNode["AccountId"].asString(); if(!accountNode["JoinMethod"].isNull()) account_.joinMethod = accountNode["JoinMethod"].asString(); - if(!accountNode["AccountName"].isNull()) - account_.accountName = accountNode["AccountName"].asString(); + if(!accountNode["JoinTime"].isNull()) + account_.joinTime = accountNode["JoinTime"].asString(); if(!accountNode["ModifyTime"].isNull()) account_.modifyTime = accountNode["ModifyTime"].asString(); + if(!accountNode["RecordId"].isNull()) + account_.recordId = accountNode["RecordId"].asString(); + if(!accountNode["ResourceDirectoryId"].isNull()) + account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString(); + if(!accountNode["Status"].isNull()) + account_.status = accountNode["Status"].asString(); + if(!accountNode["Type"].isNull()) + account_.type = accountNode["Type"].asString(); } diff --git a/resourcemanager/src/model/ResendCreateCloudAccountEmailResult.cc b/resourcemanager/src/model/ResendCreateCloudAccountEmailResult.cc index 122acf373..03d308fdb 100644 --- a/resourcemanager/src/model/ResendCreateCloudAccountEmailResult.cc +++ b/resourcemanager/src/model/ResendCreateCloudAccountEmailResult.cc @@ -40,28 +40,28 @@ void ResendCreateCloudAccountEmailResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto accountNode = value["Account"]; - if(!accountNode["Status"].isNull()) - account_.status = accountNode["Status"].asString(); - if(!accountNode["Type"].isNull()) - account_.type = accountNode["Type"].asString(); + if(!accountNode["AccountId"].isNull()) + account_.accountId = accountNode["AccountId"].asString(); + if(!accountNode["AccountName"].isNull()) + account_.accountName = accountNode["AccountName"].asString(); if(!accountNode["DisplayName"].isNull()) account_.displayName = accountNode["DisplayName"].asString(); if(!accountNode["FolderId"].isNull()) account_.folderId = accountNode["FolderId"].asString(); - if(!accountNode["ResourceDirectoryId"].isNull()) - account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString(); - if(!accountNode["RecordId"].isNull()) - account_.recordId = accountNode["RecordId"].asString(); - if(!accountNode["JoinTime"].isNull()) - account_.joinTime = accountNode["JoinTime"].asString(); - if(!accountNode["AccountId"].isNull()) - account_.accountId = accountNode["AccountId"].asString(); if(!accountNode["JoinMethod"].isNull()) account_.joinMethod = accountNode["JoinMethod"].asString(); - if(!accountNode["AccountName"].isNull()) - account_.accountName = accountNode["AccountName"].asString(); + if(!accountNode["JoinTime"].isNull()) + account_.joinTime = accountNode["JoinTime"].asString(); if(!accountNode["ModifyTime"].isNull()) account_.modifyTime = accountNode["ModifyTime"].asString(); + if(!accountNode["RecordId"].isNull()) + account_.recordId = accountNode["RecordId"].asString(); + if(!accountNode["ResourceDirectoryId"].isNull()) + account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString(); + if(!accountNode["Status"].isNull()) + account_.status = accountNode["Status"].asString(); + if(!accountNode["Type"].isNull()) + account_.type = accountNode["Type"].asString(); } diff --git a/resourcemanager/src/model/ResendPromoteResourceAccountEmailResult.cc b/resourcemanager/src/model/ResendPromoteResourceAccountEmailResult.cc index a5306353c..34c040177 100644 --- a/resourcemanager/src/model/ResendPromoteResourceAccountEmailResult.cc +++ b/resourcemanager/src/model/ResendPromoteResourceAccountEmailResult.cc @@ -40,28 +40,28 @@ void ResendPromoteResourceAccountEmailResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto accountNode = value["Account"]; - if(!accountNode["Status"].isNull()) - account_.status = accountNode["Status"].asString(); - if(!accountNode["Type"].isNull()) - account_.type = accountNode["Type"].asString(); + if(!accountNode["AccountId"].isNull()) + account_.accountId = accountNode["AccountId"].asString(); + if(!accountNode["AccountName"].isNull()) + account_.accountName = accountNode["AccountName"].asString(); if(!accountNode["DisplayName"].isNull()) account_.displayName = accountNode["DisplayName"].asString(); if(!accountNode["FolderId"].isNull()) account_.folderId = accountNode["FolderId"].asString(); - if(!accountNode["ResourceDirectoryId"].isNull()) - account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString(); - if(!accountNode["RecordId"].isNull()) - account_.recordId = accountNode["RecordId"].asString(); - if(!accountNode["JoinTime"].isNull()) - account_.joinTime = accountNode["JoinTime"].asString(); - if(!accountNode["AccountId"].isNull()) - account_.accountId = accountNode["AccountId"].asString(); if(!accountNode["JoinMethod"].isNull()) account_.joinMethod = accountNode["JoinMethod"].asString(); - if(!accountNode["AccountName"].isNull()) - account_.accountName = accountNode["AccountName"].asString(); + if(!accountNode["JoinTime"].isNull()) + account_.joinTime = accountNode["JoinTime"].asString(); if(!accountNode["ModifyTime"].isNull()) account_.modifyTime = accountNode["ModifyTime"].asString(); + if(!accountNode["RecordId"].isNull()) + account_.recordId = accountNode["RecordId"].asString(); + if(!accountNode["ResourceDirectoryId"].isNull()) + account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString(); + if(!accountNode["Status"].isNull()) + account_.status = accountNode["Status"].asString(); + if(!accountNode["Type"].isNull()) + account_.type = accountNode["Type"].asString(); } diff --git a/resourcemanager/src/model/UpdateAssociatedTransferSettingRequest.cc b/resourcemanager/src/model/UpdateAssociatedTransferSettingRequest.cc new file mode 100644 index 000000000..8156548d5 --- /dev/null +++ b/resourcemanager/src/model/UpdateAssociatedTransferSettingRequest.cc @@ -0,0 +1,52 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::UpdateAssociatedTransferSettingRequest; + +UpdateAssociatedTransferSettingRequest::UpdateAssociatedTransferSettingRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "UpdateAssociatedTransferSetting") { + setMethod(HttpRequest::Method::Post); +} + +UpdateAssociatedTransferSettingRequest::~UpdateAssociatedTransferSettingRequest() {} + +std::vector UpdateAssociatedTransferSettingRequest::getRuleSettings() const { + return ruleSettings_; +} + +void UpdateAssociatedTransferSettingRequest::setRuleSettings(const std::vector &ruleSettings) { + ruleSettings_ = ruleSettings; + for(int dep1 = 0; dep1 != ruleSettings.size(); dep1++) { + setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".AssociatedService", ruleSettings[dep1].associatedService); + setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".MasterService", ruleSettings[dep1].masterService); + setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".MasterResourceType", ruleSettings[dep1].masterResourceType); + setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".AssociatedResourceType", ruleSettings[dep1].associatedResourceType); + setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".RuleId", ruleSettings[dep1].ruleId); + setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".Status", ruleSettings[dep1].status); + } +} + +std::string UpdateAssociatedTransferSettingRequest::getEnableExistingResourcesTransfer() const { + return enableExistingResourcesTransfer_; +} + +void UpdateAssociatedTransferSettingRequest::setEnableExistingResourcesTransfer(const std::string &enableExistingResourcesTransfer) { + enableExistingResourcesTransfer_ = enableExistingResourcesTransfer; + setParameter(std::string("EnableExistingResourcesTransfer"), enableExistingResourcesTransfer); +} + diff --git a/resourcemanager/src/model/UpdateAssociatedTransferSettingResult.cc b/resourcemanager/src/model/UpdateAssociatedTransferSettingResult.cc new file mode 100644 index 000000000..6031ed9ac --- /dev/null +++ b/resourcemanager/src/model/UpdateAssociatedTransferSettingResult.cc @@ -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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +UpdateAssociatedTransferSettingResult::UpdateAssociatedTransferSettingResult() : + ServiceResult() +{} + +UpdateAssociatedTransferSettingResult::UpdateAssociatedTransferSettingResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateAssociatedTransferSettingResult::~UpdateAssociatedTransferSettingResult() +{} + +void UpdateAssociatedTransferSettingResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/resourcemanager/src/model/UpdateAutoGroupingConfigRequest.cc b/resourcemanager/src/model/UpdateAutoGroupingConfigRequest.cc new file mode 100644 index 000000000..da99b0705 --- /dev/null +++ b/resourcemanager/src/model/UpdateAutoGroupingConfigRequest.cc @@ -0,0 +1,36 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::UpdateAutoGroupingConfigRequest; + +UpdateAutoGroupingConfigRequest::UpdateAutoGroupingConfigRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "UpdateAutoGroupingConfig") { + setMethod(HttpRequest::Method::Post); +} + +UpdateAutoGroupingConfigRequest::~UpdateAutoGroupingConfigRequest() {} + +bool UpdateAutoGroupingConfigRequest::getEnableExistingResourcesTransfer() const { + return enableExistingResourcesTransfer_; +} + +void UpdateAutoGroupingConfigRequest::setEnableExistingResourcesTransfer(bool enableExistingResourcesTransfer) { + enableExistingResourcesTransfer_ = enableExistingResourcesTransfer; + setParameter(std::string("EnableExistingResourcesTransfer"), enableExistingResourcesTransfer ? "true" : "false"); +} + diff --git a/resourcemanager/src/model/UpdateAutoGroupingConfigResult.cc b/resourcemanager/src/model/UpdateAutoGroupingConfigResult.cc new file mode 100644 index 000000000..ad65b44bc --- /dev/null +++ b/resourcemanager/src/model/UpdateAutoGroupingConfigResult.cc @@ -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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +UpdateAutoGroupingConfigResult::UpdateAutoGroupingConfigResult() : + ServiceResult() +{} + +UpdateAutoGroupingConfigResult::UpdateAutoGroupingConfigResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateAutoGroupingConfigResult::~UpdateAutoGroupingConfigResult() +{} + +void UpdateAutoGroupingConfigResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/resourcemanager/src/model/UpdateAutoGroupingRuleRequest.cc b/resourcemanager/src/model/UpdateAutoGroupingRuleRequest.cc new file mode 100644 index 000000000..d365bb934 --- /dev/null +++ b/resourcemanager/src/model/UpdateAutoGroupingRuleRequest.cc @@ -0,0 +1,141 @@ +/* + * 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 + +using AlibabaCloud::ResourceManager::Model::UpdateAutoGroupingRuleRequest; + +UpdateAutoGroupingRuleRequest::UpdateAutoGroupingRuleRequest() + : RpcServiceRequest("resourcemanager", "2020-03-31", "UpdateAutoGroupingRule") { + setMethod(HttpRequest::Method::Post); +} + +UpdateAutoGroupingRuleRequest::~UpdateAutoGroupingRuleRequest() {} + +std::string UpdateAutoGroupingRuleRequest::getRuleDesc() const { + return ruleDesc_; +} + +void UpdateAutoGroupingRuleRequest::setRuleDesc(const std::string &ruleDesc) { + ruleDesc_ = ruleDesc; + setParameter(std::string("RuleDesc"), ruleDesc); +} + +std::string UpdateAutoGroupingRuleRequest::getResourceTypesScope() const { + return resourceTypesScope_; +} + +void UpdateAutoGroupingRuleRequest::setResourceTypesScope(const std::string &resourceTypesScope) { + resourceTypesScope_ = resourceTypesScope; + setParameter(std::string("ResourceTypesScope"), resourceTypesScope); +} + +std::string UpdateAutoGroupingRuleRequest::getRuleName() const { + return ruleName_; +} + +void UpdateAutoGroupingRuleRequest::setRuleName(const std::string &ruleName) { + ruleName_ = ruleName; + setParameter(std::string("RuleName"), ruleName); +} + +std::string UpdateAutoGroupingRuleRequest::getExcludeResourceGroupIdsScope() const { + return excludeResourceGroupIdsScope_; +} + +void UpdateAutoGroupingRuleRequest::setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope) { + excludeResourceGroupIdsScope_ = excludeResourceGroupIdsScope; + setParameter(std::string("ExcludeResourceGroupIdsScope"), excludeResourceGroupIdsScope); +} + +std::string UpdateAutoGroupingRuleRequest::getRegionIdsScope() const { + return regionIdsScope_; +} + +void UpdateAutoGroupingRuleRequest::setRegionIdsScope(const std::string ®ionIdsScope) { + regionIdsScope_ = regionIdsScope; + setParameter(std::string("RegionIdsScope"), regionIdsScope); +} + +std::string UpdateAutoGroupingRuleRequest::getResourceIdsScope() const { + return resourceIdsScope_; +} + +void UpdateAutoGroupingRuleRequest::setResourceIdsScope(const std::string &resourceIdsScope) { + resourceIdsScope_ = resourceIdsScope; + setParameter(std::string("ResourceIdsScope"), resourceIdsScope); +} + +std::vector UpdateAutoGroupingRuleRequest::getRuleContents() const { + return ruleContents_; +} + +void UpdateAutoGroupingRuleRequest::setRuleContents(const std::vector &ruleContents) { + ruleContents_ = ruleContents; + for(int dep1 = 0; dep1 != ruleContents.size(); dep1++) { + auto ruleContentsObj = ruleContents.at(dep1); + std::string ruleContentsObjStr = std::string("RuleContents") + "." + std::to_string(dep1 + 1); + setParameter(ruleContentsObjStr + ".RuleContentId", ruleContentsObj.ruleContentId); + setParameter(ruleContentsObjStr + ".TargetResourceGroupCondition", ruleContentsObj.targetResourceGroupCondition); + setParameter(ruleContentsObjStr + ".AutoGroupingScopeCondition", ruleContentsObj.autoGroupingScopeCondition); + } +} + +std::string UpdateAutoGroupingRuleRequest::getExcludeResourceTypesScope() const { + return excludeResourceTypesScope_; +} + +void UpdateAutoGroupingRuleRequest::setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope) { + excludeResourceTypesScope_ = excludeResourceTypesScope; + setParameter(std::string("ExcludeResourceTypesScope"), excludeResourceTypesScope); +} + +std::string UpdateAutoGroupingRuleRequest::getResourceGroupIdsScope() const { + return resourceGroupIdsScope_; +} + +void UpdateAutoGroupingRuleRequest::setResourceGroupIdsScope(const std::string &resourceGroupIdsScope) { + resourceGroupIdsScope_ = resourceGroupIdsScope; + setParameter(std::string("ResourceGroupIdsScope"), resourceGroupIdsScope); +} + +std::string UpdateAutoGroupingRuleRequest::getExcludeRegionIdsScope() const { + return excludeRegionIdsScope_; +} + +void UpdateAutoGroupingRuleRequest::setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope) { + excludeRegionIdsScope_ = excludeRegionIdsScope; + setParameter(std::string("ExcludeRegionIdsScope"), excludeRegionIdsScope); +} + +std::string UpdateAutoGroupingRuleRequest::getExcludeResourceIdsScope() const { + return excludeResourceIdsScope_; +} + +void UpdateAutoGroupingRuleRequest::setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope) { + excludeResourceIdsScope_ = excludeResourceIdsScope; + setParameter(std::string("ExcludeResourceIdsScope"), excludeResourceIdsScope); +} + +std::string UpdateAutoGroupingRuleRequest::getRuleId() const { + return ruleId_; +} + +void UpdateAutoGroupingRuleRequest::setRuleId(const std::string &ruleId) { + ruleId_ = ruleId; + setParameter(std::string("RuleId"), ruleId); +} + diff --git a/resourcemanager/src/model/UpdateAutoGroupingRuleResult.cc b/resourcemanager/src/model/UpdateAutoGroupingRuleResult.cc new file mode 100644 index 000000000..9e25a1163 --- /dev/null +++ b/resourcemanager/src/model/UpdateAutoGroupingRuleResult.cc @@ -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 +#include + +using namespace AlibabaCloud::ResourceManager; +using namespace AlibabaCloud::ResourceManager::Model; + +UpdateAutoGroupingRuleResult::UpdateAutoGroupingRuleResult() : + ServiceResult() +{} + +UpdateAutoGroupingRuleResult::UpdateAutoGroupingRuleResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateAutoGroupingRuleResult::~UpdateAutoGroupingRuleResult() +{} + +void UpdateAutoGroupingRuleResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/resourcemanager/src/model/UpdateRoleResult.cc b/resourcemanager/src/model/UpdateRoleResult.cc index 641cdfce8..b7a524c2c 100644 --- a/resourcemanager/src/model/UpdateRoleResult.cc +++ b/resourcemanager/src/model/UpdateRoleResult.cc @@ -40,24 +40,24 @@ void UpdateRoleResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto roleNode = value["Role"]; - if(!roleNode["AssumeRolePolicyDocument"].isNull()) - role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString(); - if(!roleNode["RolePrincipalName"].isNull()) - role_.rolePrincipalName = roleNode["RolePrincipalName"].asString(); - if(!roleNode["Description"].isNull()) - role_.description = roleNode["Description"].asString(); - if(!roleNode["UpdateDate"].isNull()) - role_.updateDate = roleNode["UpdateDate"].asString(); - if(!roleNode["MaxSessionDuration"].isNull()) - role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString()); - if(!roleNode["RoleName"].isNull()) - role_.roleName = roleNode["RoleName"].asString(); - if(!roleNode["CreateDate"].isNull()) - role_.createDate = roleNode["CreateDate"].asString(); - if(!roleNode["RoleId"].isNull()) - role_.roleId = roleNode["RoleId"].asString(); if(!roleNode["Arn"].isNull()) role_.arn = roleNode["Arn"].asString(); + if(!roleNode["AssumeRolePolicyDocument"].isNull()) + role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString(); + if(!roleNode["CreateDate"].isNull()) + role_.createDate = roleNode["CreateDate"].asString(); + if(!roleNode["Description"].isNull()) + role_.description = roleNode["Description"].asString(); + if(!roleNode["MaxSessionDuration"].isNull()) + role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString()); + if(!roleNode["RoleId"].isNull()) + role_.roleId = roleNode["RoleId"].asString(); + if(!roleNode["RoleName"].isNull()) + role_.roleName = roleNode["RoleName"].asString(); + if(!roleNode["RolePrincipalName"].isNull()) + role_.rolePrincipalName = roleNode["RolePrincipalName"].asString(); + if(!roleNode["UpdateDate"].isNull()) + role_.updateDate = roleNode["UpdateDate"].asString(); }