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

Support managed rule query.

Browse Source
This commit is contained in:
sdk-team
2021-12-28 10:53:21 +00:00
parent 1bc2727696
commit 4e60cd4654
60 changed files with 1820 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2021-12-28 Version: 1.36.999
- Support managed rule query.
2021-12-27 Version: 1.36.998
- Support ACR EE, OSS, EIP for deploy.

2
VERSION
View File

@@ -1 +1 @@
1.36.998
1.36.999

24
config/CMakeLists.txt
View File

@@ -79,6 +79,10 @@ set(config_public_header_model
include/alibabacloud/config/model/GetAggregateResourceComplianceByConfigRuleResult.h
include/alibabacloud/config/model/GetAggregateResourceComplianceByPackRequest.h
include/alibabacloud/config/model/GetAggregateResourceComplianceByPackResult.h
include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionRequest.h
include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionResult.h
include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeRequest.h
include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeResult.h
include/alibabacloud/config/model/GetAggregateResourceComplianceTimelineRequest.h
include/alibabacloud/config/model/GetAggregateResourceComplianceTimelineResult.h
include/alibabacloud/config/model/GetAggregateResourceConfigurationTimelineRequest.h
@@ -105,10 +109,16 @@ set(config_public_header_model
include/alibabacloud/config/model/GetDiscoveredResourceCountsGroupByRegionResult.h
include/alibabacloud/config/model/GetDiscoveredResourceCountsGroupByResourceTypeRequest.h
include/alibabacloud/config/model/GetDiscoveredResourceCountsGroupByResourceTypeResult.h
include/alibabacloud/config/model/GetManagedRuleRequest.h
include/alibabacloud/config/model/GetManagedRuleResult.h
include/alibabacloud/config/model/GetResourceComplianceByConfigRuleRequest.h
include/alibabacloud/config/model/GetResourceComplianceByConfigRuleResult.h
include/alibabacloud/config/model/GetResourceComplianceByPackRequest.h
include/alibabacloud/config/model/GetResourceComplianceByPackResult.h
include/alibabacloud/config/model/GetResourceComplianceGroupByRegionRequest.h
include/alibabacloud/config/model/GetResourceComplianceGroupByRegionResult.h
include/alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeRequest.h
include/alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeResult.h
include/alibabacloud/config/model/GetResourceComplianceTimelineRequest.h
include/alibabacloud/config/model/GetResourceComplianceTimelineResult.h
include/alibabacloud/config/model/GetResourceConfigurationTimelineRequest.h
@@ -133,6 +143,8 @@ set(config_public_header_model
include/alibabacloud/config/model/ListCompliancePacksResult.h
include/alibabacloud/config/model/ListConfigRuleEvaluationResultsRequest.h
include/alibabacloud/config/model/ListConfigRuleEvaluationResultsResult.h
include/alibabacloud/config/model/ListManagedRulesRequest.h
include/alibabacloud/config/model/ListManagedRulesResult.h
include/alibabacloud/config/model/ListResourceEvaluationResultsRequest.h
include/alibabacloud/config/model/ListResourceEvaluationResultsResult.h
include/alibabacloud/config/model/RevertAggregateEvaluationResultsRequest.h
@@ -212,6 +224,10 @@ set(config_src
src/model/GetAggregateResourceComplianceByConfigRuleResult.cc
src/model/GetAggregateResourceComplianceByPackRequest.cc
src/model/GetAggregateResourceComplianceByPackResult.cc
src/model/GetAggregateResourceComplianceGroupByRegionRequest.cc
src/model/GetAggregateResourceComplianceGroupByRegionResult.cc
src/model/GetAggregateResourceComplianceGroupByResourceTypeRequest.cc
src/model/GetAggregateResourceComplianceGroupByResourceTypeResult.cc
src/model/GetAggregateResourceComplianceTimelineRequest.cc
src/model/GetAggregateResourceComplianceTimelineResult.cc
src/model/GetAggregateResourceConfigurationTimelineRequest.cc
@@ -238,10 +254,16 @@ set(config_src
src/model/GetDiscoveredResourceCountsGroupByRegionResult.cc
src/model/GetDiscoveredResourceCountsGroupByResourceTypeRequest.cc
src/model/GetDiscoveredResourceCountsGroupByResourceTypeResult.cc
src/model/GetManagedRuleRequest.cc
src/model/GetManagedRuleResult.cc
src/model/GetResourceComplianceByConfigRuleRequest.cc
src/model/GetResourceComplianceByConfigRuleResult.cc
src/model/GetResourceComplianceByPackRequest.cc
src/model/GetResourceComplianceByPackResult.cc
src/model/GetResourceComplianceGroupByRegionRequest.cc
src/model/GetResourceComplianceGroupByRegionResult.cc
src/model/GetResourceComplianceGroupByResourceTypeRequest.cc
src/model/GetResourceComplianceGroupByResourceTypeResult.cc
src/model/GetResourceComplianceTimelineRequest.cc
src/model/GetResourceComplianceTimelineResult.cc
src/model/GetResourceConfigurationTimelineRequest.cc
@@ -266,6 +288,8 @@ set(config_src
src/model/ListCompliancePacksResult.cc
src/model/ListConfigRuleEvaluationResultsRequest.cc
src/model/ListConfigRuleEvaluationResultsResult.cc
src/model/ListManagedRulesRequest.cc
src/model/ListManagedRulesResult.cc
src/model/ListResourceEvaluationResultsRequest.cc
src/model/ListResourceEvaluationResultsResult.cc
src/model/RevertAggregateEvaluationResultsRequest.cc

48
config/include/alibabacloud/config/ConfigClient.h
View File

@@ -80,6 +80,10 @@
#include "model/GetAggregateResourceComplianceByConfigRuleResult.h"
#include "model/GetAggregateResourceComplianceByPackRequest.h"
#include "model/GetAggregateResourceComplianceByPackResult.h"
#include "model/GetAggregateResourceComplianceGroupByRegionRequest.h"
#include "model/GetAggregateResourceComplianceGroupByRegionResult.h"
#include "model/GetAggregateResourceComplianceGroupByResourceTypeRequest.h"
#include "model/GetAggregateResourceComplianceGroupByResourceTypeResult.h"
#include "model/GetAggregateResourceComplianceTimelineRequest.h"
#include "model/GetAggregateResourceComplianceTimelineResult.h"
#include "model/GetAggregateResourceConfigurationTimelineRequest.h"
@@ -106,10 +110,16 @@
#include "model/GetDiscoveredResourceCountsGroupByRegionResult.h"
#include "model/GetDiscoveredResourceCountsGroupByResourceTypeRequest.h"
#include "model/GetDiscoveredResourceCountsGroupByResourceTypeResult.h"
#include "model/GetManagedRuleRequest.h"
#include "model/GetManagedRuleResult.h"
#include "model/GetResourceComplianceByConfigRuleRequest.h"
#include "model/GetResourceComplianceByConfigRuleResult.h"
#include "model/GetResourceComplianceByPackRequest.h"
#include "model/GetResourceComplianceByPackResult.h"
#include "model/GetResourceComplianceGroupByRegionRequest.h"
#include "model/GetResourceComplianceGroupByRegionResult.h"
#include "model/GetResourceComplianceGroupByResourceTypeRequest.h"
#include "model/GetResourceComplianceGroupByResourceTypeResult.h"
#include "model/GetResourceComplianceTimelineRequest.h"
#include "model/GetResourceComplianceTimelineResult.h"
#include "model/GetResourceConfigurationTimelineRequest.h"
@@ -134,6 +144,8 @@
#include "model/ListCompliancePacksResult.h"
#include "model/ListConfigRuleEvaluationResultsRequest.h"
#include "model/ListConfigRuleEvaluationResultsResult.h"
#include "model/ListManagedRulesRequest.h"
#include "model/ListManagedRulesResult.h"
#include "model/ListResourceEvaluationResultsRequest.h"
#include "model/ListResourceEvaluationResultsResult.h"
#include "model/RevertAggregateEvaluationResultsRequest.h"
@@ -248,6 +260,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetAggregateResourceComplianceByPackResult> GetAggregateResourceComplianceByPackOutcome;
typedef std::future<GetAggregateResourceComplianceByPackOutcome> GetAggregateResourceComplianceByPackOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceByPackRequest&, const GetAggregateResourceComplianceByPackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceByPackAsyncHandler;
typedef Outcome<Error, Model::GetAggregateResourceComplianceGroupByRegionResult> GetAggregateResourceComplianceGroupByRegionOutcome;
typedef std::future<GetAggregateResourceComplianceGroupByRegionOutcome> GetAggregateResourceComplianceGroupByRegionOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceGroupByRegionRequest&, const GetAggregateResourceComplianceGroupByRegionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceGroupByRegionAsyncHandler;
typedef Outcome<Error, Model::GetAggregateResourceComplianceGroupByResourceTypeResult> GetAggregateResourceComplianceGroupByResourceTypeOutcome;
typedef std::future<GetAggregateResourceComplianceGroupByResourceTypeOutcome> GetAggregateResourceComplianceGroupByResourceTypeOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceGroupByResourceTypeRequest&, const GetAggregateResourceComplianceGroupByResourceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceGroupByResourceTypeAsyncHandler;
typedef Outcome<Error, Model::GetAggregateResourceComplianceTimelineResult> GetAggregateResourceComplianceTimelineOutcome;
typedef std::future<GetAggregateResourceComplianceTimelineOutcome> GetAggregateResourceComplianceTimelineOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceTimelineRequest&, const GetAggregateResourceComplianceTimelineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceTimelineAsyncHandler;
@@ -287,12 +305,21 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetDiscoveredResourceCountsGroupByResourceTypeResult> GetDiscoveredResourceCountsGroupByResourceTypeOutcome;
typedef std::future<GetDiscoveredResourceCountsGroupByResourceTypeOutcome> GetDiscoveredResourceCountsGroupByResourceTypeOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest&, const GetDiscoveredResourceCountsGroupByResourceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDiscoveredResourceCountsGroupByResourceTypeAsyncHandler;
typedef Outcome<Error, Model::GetManagedRuleResult> GetManagedRuleOutcome;
typedef std::future<GetManagedRuleOutcome> GetManagedRuleOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetManagedRuleRequest&, const GetManagedRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetManagedRuleAsyncHandler;
typedef Outcome<Error, Model::GetResourceComplianceByConfigRuleResult> GetResourceComplianceByConfigRuleOutcome;
typedef std::future<GetResourceComplianceByConfigRuleOutcome> GetResourceComplianceByConfigRuleOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceByConfigRuleRequest&, const GetResourceComplianceByConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceByConfigRuleAsyncHandler;
typedef Outcome<Error, Model::GetResourceComplianceByPackResult> GetResourceComplianceByPackOutcome;
typedef std::future<GetResourceComplianceByPackOutcome> GetResourceComplianceByPackOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceByPackRequest&, const GetResourceComplianceByPackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceByPackAsyncHandler;
typedef Outcome<Error, Model::GetResourceComplianceGroupByRegionResult> GetResourceComplianceGroupByRegionOutcome;
typedef std::future<GetResourceComplianceGroupByRegionOutcome> GetResourceComplianceGroupByRegionOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceGroupByRegionRequest&, const GetResourceComplianceGroupByRegionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceGroupByRegionAsyncHandler;
typedef Outcome<Error, Model::GetResourceComplianceGroupByResourceTypeResult> GetResourceComplianceGroupByResourceTypeOutcome;
typedef std::future<GetResourceComplianceGroupByResourceTypeOutcome> GetResourceComplianceGroupByResourceTypeOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceGroupByResourceTypeRequest&, const GetResourceComplianceGroupByResourceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceGroupByResourceTypeAsyncHandler;
typedef Outcome<Error, Model::GetResourceComplianceTimelineResult> GetResourceComplianceTimelineOutcome;
typedef std::future<GetResourceComplianceTimelineOutcome> GetResourceComplianceTimelineOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceTimelineRequest&, const GetResourceComplianceTimelineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceTimelineAsyncHandler;
@@ -329,6 +356,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListConfigRuleEvaluationResultsResult> ListConfigRuleEvaluationResultsOutcome;
typedef std::future<ListConfigRuleEvaluationResultsOutcome> ListConfigRuleEvaluationResultsOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::ListConfigRuleEvaluationResultsRequest&, const ListConfigRuleEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListConfigRuleEvaluationResultsAsyncHandler;
typedef Outcome<Error, Model::ListManagedRulesResult> ListManagedRulesOutcome;
typedef std::future<ListManagedRulesOutcome> ListManagedRulesOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::ListManagedRulesRequest&, const ListManagedRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListManagedRulesAsyncHandler;
typedef Outcome<Error, Model::ListResourceEvaluationResultsResult> ListResourceEvaluationResultsOutcome;
typedef std::future<ListResourceEvaluationResultsOutcome> ListResourceEvaluationResultsOutcomeCallable;
typedef std::function<void(const ConfigClient*, const Model::ListResourceEvaluationResultsRequest&, const ListResourceEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourceEvaluationResultsAsyncHandler;
@@ -448,6 +478,12 @@ namespace AlibabaCloud
GetAggregateResourceComplianceByPackOutcome getAggregateResourceComplianceByPack(const Model::GetAggregateResourceComplianceByPackRequest &request)const;
void getAggregateResourceComplianceByPackAsync(const Model::GetAggregateResourceComplianceByPackRequest& request, const GetAggregateResourceComplianceByPackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAggregateResourceComplianceByPackOutcomeCallable getAggregateResourceComplianceByPackCallable(const Model::GetAggregateResourceComplianceByPackRequest& request) const;
GetAggregateResourceComplianceGroupByRegionOutcome getAggregateResourceComplianceGroupByRegion(const Model::GetAggregateResourceComplianceGroupByRegionRequest &request)const;
void getAggregateResourceComplianceGroupByRegionAsync(const Model::GetAggregateResourceComplianceGroupByRegionRequest& request, const GetAggregateResourceComplianceGroupByRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAggregateResourceComplianceGroupByRegionOutcomeCallable getAggregateResourceComplianceGroupByRegionCallable(const Model::GetAggregateResourceComplianceGroupByRegionRequest& request) const;
GetAggregateResourceComplianceGroupByResourceTypeOutcome getAggregateResourceComplianceGroupByResourceType(const Model::GetAggregateResourceComplianceGroupByResourceTypeRequest &request)const;
void getAggregateResourceComplianceGroupByResourceTypeAsync(const Model::GetAggregateResourceComplianceGroupByResourceTypeRequest& request, const GetAggregateResourceComplianceGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAggregateResourceComplianceGroupByResourceTypeOutcomeCallable getAggregateResourceComplianceGroupByResourceTypeCallable(const Model::GetAggregateResourceComplianceGroupByResourceTypeRequest& request) const;
GetAggregateResourceComplianceTimelineOutcome getAggregateResourceComplianceTimeline(const Model::GetAggregateResourceComplianceTimelineRequest &request)const;
void getAggregateResourceComplianceTimelineAsync(const Model::GetAggregateResourceComplianceTimelineRequest& request, const GetAggregateResourceComplianceTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAggregateResourceComplianceTimelineOutcomeCallable getAggregateResourceComplianceTimelineCallable(const Model::GetAggregateResourceComplianceTimelineRequest& request) const;
@@ -487,12 +523,21 @@ namespace AlibabaCloud
GetDiscoveredResourceCountsGroupByResourceTypeOutcome getDiscoveredResourceCountsGroupByResourceType(const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest &request)const;
void getDiscoveredResourceCountsGroupByResourceTypeAsync(const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest& request, const GetDiscoveredResourceCountsGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetDiscoveredResourceCountsGroupByResourceTypeOutcomeCallable getDiscoveredResourceCountsGroupByResourceTypeCallable(const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest& request) const;
GetManagedRuleOutcome getManagedRule(const Model::GetManagedRuleRequest &request)const;
void getManagedRuleAsync(const Model::GetManagedRuleRequest& request, const GetManagedRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetManagedRuleOutcomeCallable getManagedRuleCallable(const Model::GetManagedRuleRequest& request) const;
GetResourceComplianceByConfigRuleOutcome getResourceComplianceByConfigRule(const Model::GetResourceComplianceByConfigRuleRequest &request)const;
void getResourceComplianceByConfigRuleAsync(const Model::GetResourceComplianceByConfigRuleRequest& request, const GetResourceComplianceByConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetResourceComplianceByConfigRuleOutcomeCallable getResourceComplianceByConfigRuleCallable(const Model::GetResourceComplianceByConfigRuleRequest& request) const;
GetResourceComplianceByPackOutcome getResourceComplianceByPack(const Model::GetResourceComplianceByPackRequest &request)const;
void getResourceComplianceByPackAsync(const Model::GetResourceComplianceByPackRequest& request, const GetResourceComplianceByPackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetResourceComplianceByPackOutcomeCallable getResourceComplianceByPackCallable(const Model::GetResourceComplianceByPackRequest& request) const;
GetResourceComplianceGroupByRegionOutcome getResourceComplianceGroupByRegion(const Model::GetResourceComplianceGroupByRegionRequest &request)const;
void getResourceComplianceGroupByRegionAsync(const Model::GetResourceComplianceGroupByRegionRequest& request, const GetResourceComplianceGroupByRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetResourceComplianceGroupByRegionOutcomeCallable getResourceComplianceGroupByRegionCallable(const Model::GetResourceComplianceGroupByRegionRequest& request) const;
GetResourceComplianceGroupByResourceTypeOutcome getResourceComplianceGroupByResourceType(const Model::GetResourceComplianceGroupByResourceTypeRequest &request)const;
void getResourceComplianceGroupByResourceTypeAsync(const Model::GetResourceComplianceGroupByResourceTypeRequest& request, const GetResourceComplianceGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetResourceComplianceGroupByResourceTypeOutcomeCallable getResourceComplianceGroupByResourceTypeCallable(const Model::GetResourceComplianceGroupByResourceTypeRequest& request) const;
GetResourceComplianceTimelineOutcome getResourceComplianceTimeline(const Model::GetResourceComplianceTimelineRequest &request)const;
void getResourceComplianceTimelineAsync(const Model::GetResourceComplianceTimelineRequest& request, const GetResourceComplianceTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetResourceComplianceTimelineOutcomeCallable getResourceComplianceTimelineCallable(const Model::GetResourceComplianceTimelineRequest& request) const;
@@ -529,6 +574,9 @@ namespace AlibabaCloud
ListConfigRuleEvaluationResultsOutcome listConfigRuleEvaluationResults(const Model::ListConfigRuleEvaluationResultsRequest &request)const;
void listConfigRuleEvaluationResultsAsync(const Model::ListConfigRuleEvaluationResultsRequest& request, const ListConfigRuleEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListConfigRuleEvaluationResultsOutcomeCallable listConfigRuleEvaluationResultsCallable(const Model::ListConfigRuleEvaluationResultsRequest& request) const;
ListManagedRulesOutcome listManagedRules(const Model::ListManagedRulesRequest &request)const;
void listManagedRulesAsync(const Model::ListManagedRulesRequest& request, const ListManagedRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListManagedRulesOutcomeCallable listManagedRulesCallable(const Model::ListManagedRulesRequest& request) const;
ListResourceEvaluationResultsOutcome listResourceEvaluationResults(const Model::ListResourceEvaluationResultsRequest &request)const;
void listResourceEvaluationResultsAsync(const Model::ListResourceEvaluationResultsRequest& request, const ListResourceEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListResourceEvaluationResultsOutcomeCallable listResourceEvaluationResultsCallable(const Model::ListResourceEvaluationResultsRequest& request) const;

3
config/include/alibabacloud/config/model/CreateAggregateConfigRuleRequest.h
View File

@@ -58,6 +58,8 @@ public:
void setInputParameters(const std::string &inputParameters);
std::string getConfigRuleName() const;
void setConfigRuleName(const std::string &configRuleName);
std::string getTagKeyLogicScope() const;
void setTagKeyLogicScope(const std::string &tagKeyLogicScope);
std::string getMaximumExecutionFrequency() const;
void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
std::string getExcludeResourceIdsScope() const;
@@ -78,6 +80,7 @@ private:
std::string resourceGroupIdsScope_;
std::string inputParameters_;
std::string configRuleName_;
std::string tagKeyLogicScope_;
std::string maximumExecutionFrequency_;
std::string excludeResourceIdsScope_;
};

3
config/include/alibabacloud/config/model/CreateConfigRuleRequest.h
View File

@@ -56,6 +56,8 @@ public:
void setInputParameters(const std::string &inputParameters);
std::string getConfigRuleName() const;
void setConfigRuleName(const std::string &configRuleName);
std::string getTagKeyLogicScope() const;
void setTagKeyLogicScope(const std::string &tagKeyLogicScope);
std::string getMaximumExecutionFrequency() const;
void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
std::string getExcludeResourceIdsScope() const;
@@ -75,6 +77,7 @@ private:
std::string resourceGroupIdsScope_;
std::string inputParameters_;
std::string configRuleName_;
std::string tagKeyLogicScope_;
std::string maximumExecutionFrequency_;
std::string excludeResourceIdsScope_;
};

3
config/include/alibabacloud/config/model/GenerateAggregateConfigRulesReportRequest.h
View File

@@ -32,11 +32,14 @@ public:
~GenerateAggregateConfigRulesReportRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getConfigRuleIds() const;
void setConfigRuleIds(const std::string &configRuleIds);
std::string getAggregatorId() const;
void setAggregatorId(const std::string &aggregatorId);
private:
std::string clientToken_;
std::string configRuleIds_;
std::string aggregatorId_;
};
} // namespace Model

2
config/include/alibabacloud/config/model/GenerateAggregateConfigRulesReportResult.h
View File

@@ -37,11 +37,13 @@ namespace AlibabaCloud
GenerateAggregateConfigRulesReportResult();
explicit GenerateAggregateConfigRulesReportResult(const std::string &payload);
~GenerateAggregateConfigRulesReportResult();
std::string getReportId()const;
std::string getAggregatorId()const;
protected:
void parse(const std::string &payload);
private:
std::string reportId_;
std::string aggregatorId_;
};

3
config/include/alibabacloud/config/model/GenerateConfigRulesReportRequest.h
View File

@@ -32,9 +32,12 @@ public:
~GenerateConfigRulesReportRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getConfigRuleIds() const;
void setConfigRuleIds(const std::string &configRuleIds);
private:
std::string clientToken_;
std::string configRuleIds_;
};
} // namespace Model
} // namespace Config

2
config/include/alibabacloud/config/model/GenerateConfigRulesReportResult.h
View File

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

1
config/include/alibabacloud/config/model/GetAggregateConfigRuleResult.h
View File

@@ -94,6 +94,7 @@ namespace AlibabaCloud
ManagedRule managedRule;
std::string description;
std::string excludeResourceIdsScope;
std::string tagKeyLogicScope;
CreateBy createBy;
ConfigRuleEvaluationStatus configRuleEvaluationStatus;
Source source;

3
config/include/alibabacloud/config/model/GetAggregateConfigRulesReportRequest.h
View File

@@ -30,10 +30,13 @@ class ALIBABACLOUD_CONFIG_EXPORT GetAggregateConfigRulesReportRequest : public R
public:
GetAggregateConfigRulesReportRequest();
~GetAggregateConfigRulesReportRequest();
std::string getReportId() const;
void setReportId(const std::string &reportId);
std::string getAggregatorId() const;
void setAggregatorId(const std::string &aggregatorId);
private:
std::string reportId_;
std::string aggregatorId_;
};
} // namespace Model

1
config/include/alibabacloud/config/model/GetAggregateConfigRulesReportResult.h
View File

@@ -36,6 +36,7 @@ namespace AlibabaCloud
{
long accountId;
std::string reportUrl;
std::string reportId;
std::string reportStatus;
std::string aggregatorId;
long reportCreateTimestamp;

45
config/include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYREGIONREQUEST_H_
#define ALIBABACLOUD_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYREGIONREQUEST_H_
#include <alibabacloud/config/ConfigExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Config {
namespace Model {
class ALIBABACLOUD_CONFIG_EXPORT GetAggregateResourceComplianceGroupByRegionRequest : public RpcServiceRequest {
public:
GetAggregateResourceComplianceGroupByRegionRequest();
~GetAggregateResourceComplianceGroupByRegionRequest();
std::string getConfigRuleIds() const;
void setConfigRuleIds(const std::string &configRuleIds);
std::string getAggregatorId() const;
void setAggregatorId(const std::string &aggregatorId);
private:
std::string configRuleIds_;
std::string aggregatorId_;
};
} // namespace Model
} // namespace Config
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYREGIONREQUEST_H_

65
config/include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYREGIONRESULT_H_
#define ALIBABACLOUD_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYREGIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/config/ConfigExport.h>
namespace AlibabaCloud
{
namespace Config
{
namespace Model
{
class ALIBABACLOUD_CONFIG_EXPORT GetAggregateResourceComplianceGroupByRegionResult : public ServiceResult
{
public:
struct ComplianceResult
{
struct ComplianceResultListItem
{
struct CompliancesItem
{
std::string complianceType;
long count;
};
std::vector<ComplianceResultListItem::CompliancesItem> compliances;
std::string regionId;
};
std::vector<ComplianceResultListItem> complianceResultList;
};
GetAggregateResourceComplianceGroupByRegionResult();
explicit GetAggregateResourceComplianceGroupByRegionResult(const std::string &payload);
~GetAggregateResourceComplianceGroupByRegionResult();
ComplianceResult getComplianceResult()const;
protected:
void parse(const std::string &payload);
private:
ComplianceResult complianceResult_;
};
}
}
}
#endif // !ALIBABACLOUD_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYREGIONRESULT_H_

45
config/include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYRESOURCETYPEREQUEST_H_
#define ALIBABACLOUD_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYRESOURCETYPEREQUEST_H_
#include <alibabacloud/config/ConfigExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Config {
namespace Model {
class ALIBABACLOUD_CONFIG_EXPORT GetAggregateResourceComplianceGroupByResourceTypeRequest : public RpcServiceRequest {
public:
GetAggregateResourceComplianceGroupByResourceTypeRequest();
~GetAggregateResourceComplianceGroupByResourceTypeRequest();
std::string getConfigRuleIds() const;
void setConfigRuleIds(const std::string &configRuleIds);
std::string getAggregatorId() const;
void setAggregatorId(const std::string &aggregatorId);
private:
std::string configRuleIds_;
std::string aggregatorId_;
};
} // namespace Model
} // namespace Config
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYRESOURCETYPEREQUEST_H_

65
config/include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYRESOURCETYPERESULT_H_
#define ALIBABACLOUD_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYRESOURCETYPERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/config/ConfigExport.h>
namespace AlibabaCloud
{
namespace Config
{
namespace Model
{
class ALIBABACLOUD_CONFIG_EXPORT GetAggregateResourceComplianceGroupByResourceTypeResult : public ServiceResult
{
public:
struct ComplianceResult
{
struct ComplianceResultListItem
{
struct CompliancesItem
{
std::string complianceType;
long count;
};
std::vector<ComplianceResultListItem::CompliancesItem> compliances;
std::string resourceType;
};
std::vector<ComplianceResultListItem> complianceResultList;
};
GetAggregateResourceComplianceGroupByResourceTypeResult();
explicit GetAggregateResourceComplianceGroupByResourceTypeResult(const std::string &payload);
~GetAggregateResourceComplianceGroupByResourceTypeResult();
ComplianceResult getComplianceResult()const;
protected:
void parse(const std::string &payload);
private:
ComplianceResult complianceResult_;
};
}
}
}
#endif // !ALIBABACLOUD_CONFIG_MODEL_GETAGGREGATERESOURCECOMPLIANCEGROUPBYRESOURCETYPERESULT_H_

1
config/include/alibabacloud/config/model/GetConfigRuleResult.h
View File

@@ -94,6 +94,7 @@ namespace AlibabaCloud
ManagedRule managedRule;
std::string description;
std::string excludeResourceIdsScope;
std::string tagKeyLogicScope;
CreateBy createBy;
ConfigRuleEvaluationStatus configRuleEvaluationStatus;
Source source;

3
config/include/alibabacloud/config/model/GetConfigRulesReportRequest.h
View File

@@ -30,8 +30,11 @@ class ALIBABACLOUD_CONFIG_EXPORT GetConfigRulesReportRequest : public RpcService
public:
GetConfigRulesReportRequest();
~GetConfigRulesReportRequest();
std::string getReportId() const;
void setReportId(const std::string &reportId);
private:
std::string reportId_;
};
} // namespace Model
} // namespace Config

1
config/include/alibabacloud/config/model/GetConfigRulesReportResult.h
View File

@@ -36,6 +36,7 @@ namespace AlibabaCloud
{
long accountId;
std::string reportUrl;
std::string reportId;
std::string reportStatus;
long reportCreateTimestamp;
};

42
config/include/alibabacloud/config/model/GetManagedRuleRequest.h Normal file
View File

@@ -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_CONFIG_MODEL_GETMANAGEDRULEREQUEST_H_
#define ALIBABACLOUD_CONFIG_MODEL_GETMANAGEDRULEREQUEST_H_
#include <alibabacloud/config/ConfigExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Config {
namespace Model {
class ALIBABACLOUD_CONFIG_EXPORT GetManagedRuleRequest : public RpcServiceRequest {
public:
GetManagedRuleRequest();
~GetManagedRuleRequest();
std::string getIdentifier() const;
void setIdentifier(const std::string &identifier);
private:
std::string identifier_;
};
} // namespace Model
} // namespace Config
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CONFIG_MODEL_GETMANAGEDRULEREQUEST_H_

82
config/include/alibabacloud/config/model/GetManagedRuleResult.h Normal file
View File

@@ -0,0 +1,82 @@
/*
* 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_CONFIG_MODEL_GETMANAGEDRULERESULT_H_
#define ALIBABACLOUD_CONFIG_MODEL_GETMANAGEDRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/config/ConfigExport.h>
namespace AlibabaCloud
{
namespace Config
{
namespace Model
{
class ALIBABACLOUD_CONFIG_EXPORT GetManagedRuleResult : public ServiceResult
{
public:
struct ManagedRule
{
struct Scope
{
std::vector<std::string> complianceResourceTypes;
};
struct SourceDetailsItem
{
std::string eventSource;
std::string messageType;
std::string maximumExecutionFrequency;
};
std::vector<std::string> optionalInputParameterDetails;
std::string description;
std::vector<std::string> compulsoryInputParameterDetails;
std::string helpHint;
std::vector<std::string> labels;
std::string helpUrls;
std::string functionName;
std::string identifier;
Scope scope;
std::vector<std::string> sourceConditions;
std::string serviceName;
std::string defaultName;
std::string helpDoc;
std::string configRuleName;
std::string regionId;
std::vector<SourceDetailsItem> sourceDetails;
int riskLevel;
long createTimestamp;
};
GetManagedRuleResult();
explicit GetManagedRuleResult(const std::string &payload);
~GetManagedRuleResult();
ManagedRule getManagedRule()const;
protected:
void parse(const std::string &payload);
private:
ManagedRule managedRule_;
};
}
}
}
#endif // !ALIBABACLOUD_CONFIG_MODEL_GETMANAGEDRULERESULT_H_

42
config/include/alibabacloud/config/model/GetResourceComplianceGroupByRegionRequest.h Normal file
View File

@@ -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_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYREGIONREQUEST_H_
#define ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYREGIONREQUEST_H_
#include <alibabacloud/config/ConfigExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Config {
namespace Model {
class ALIBABACLOUD_CONFIG_EXPORT GetResourceComplianceGroupByRegionRequest : public RpcServiceRequest {
public:
GetResourceComplianceGroupByRegionRequest();
~GetResourceComplianceGroupByRegionRequest();
std::string getConfigRuleIds() const;
void setConfigRuleIds(const std::string &configRuleIds);
private:
std::string configRuleIds_;
};
} // namespace Model
} // namespace Config
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYREGIONREQUEST_H_

65
config/include/alibabacloud/config/model/GetResourceComplianceGroupByRegionResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYREGIONRESULT_H_
#define ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYREGIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/config/ConfigExport.h>
namespace AlibabaCloud
{
namespace Config
{
namespace Model
{
class ALIBABACLOUD_CONFIG_EXPORT GetResourceComplianceGroupByRegionResult : public ServiceResult
{
public:
struct ComplianceResult
{
struct ComplianceResultListItem
{
struct CompliancesItem
{
std::string complianceType;
long count;
};
std::vector<ComplianceResultListItem::CompliancesItem> compliances;
std::string regionId;
};
std::vector<ComplianceResultListItem> complianceResultList;
};
GetResourceComplianceGroupByRegionResult();
explicit GetResourceComplianceGroupByRegionResult(const std::string &payload);
~GetResourceComplianceGroupByRegionResult();
ComplianceResult getComplianceResult()const;
protected:
void parse(const std::string &payload);
private:
ComplianceResult complianceResult_;
};
}
}
}
#endif // !ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYREGIONRESULT_H_

42
config/include/alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeRequest.h Normal file
View File

@@ -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_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYRESOURCETYPEREQUEST_H_
#define ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYRESOURCETYPEREQUEST_H_
#include <alibabacloud/config/ConfigExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Config {
namespace Model {
class ALIBABACLOUD_CONFIG_EXPORT GetResourceComplianceGroupByResourceTypeRequest : public RpcServiceRequest {
public:
GetResourceComplianceGroupByResourceTypeRequest();
~GetResourceComplianceGroupByResourceTypeRequest();
std::string getConfigRuleIds() const;
void setConfigRuleIds(const std::string &configRuleIds);
private:
std::string configRuleIds_;
};
} // namespace Model
} // namespace Config
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYRESOURCETYPEREQUEST_H_

65
config/include/alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYRESOURCETYPERESULT_H_
#define ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYRESOURCETYPERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/config/ConfigExport.h>
namespace AlibabaCloud
{
namespace Config
{
namespace Model
{
class ALIBABACLOUD_CONFIG_EXPORT GetResourceComplianceGroupByResourceTypeResult : public ServiceResult
{
public:
struct ComplianceResult
{
struct ComplianceResultListItem
{
struct CompliancesItem
{
std::string complianceType;
long count;
};
std::vector<ComplianceResultListItem::CompliancesItem> compliances;
std::string resourceType;
};
std::vector<ComplianceResultListItem> complianceResultList;
};
GetResourceComplianceGroupByResourceTypeResult();
explicit GetResourceComplianceGroupByResourceTypeResult(const std::string &payload);
~GetResourceComplianceGroupByResourceTypeResult();
ComplianceResult getComplianceResult()const;
protected:
void parse(const std::string &payload);
private:
ComplianceResult complianceResult_;
};
}
}
}
#endif // !ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYRESOURCETYPERESULT_H_

51
config/include/alibabacloud/config/model/ListManagedRulesRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_CONFIG_MODEL_LISTMANAGEDRULESREQUEST_H_
#define ALIBABACLOUD_CONFIG_MODEL_LISTMANAGEDRULESREQUEST_H_
#include <alibabacloud/config/ConfigExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Config {
namespace Model {
class ALIBABACLOUD_CONFIG_EXPORT ListManagedRulesRequest : public RpcServiceRequest {
public:
ListManagedRulesRequest();
~ListManagedRulesRequest();
int getRiskLevel() const;
void setRiskLevel(int riskLevel);
int getPageNumber() const;
void setPageNumber(int pageNumber);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getKeyword() const;
void setKeyword(const std::string &keyword);
private:
int riskLevel_;
int pageNumber_;
int pageSize_;
std::string keyword_;
};
} // namespace Model
} // namespace Config
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CONFIG_MODEL_LISTMANAGEDRULESREQUEST_H_

69
config/include/alibabacloud/config/model/ListManagedRulesResult.h Normal file
View File

@@ -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_CONFIG_MODEL_LISTMANAGEDRULESRESULT_H_
#define ALIBABACLOUD_CONFIG_MODEL_LISTMANAGEDRULESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/config/ConfigExport.h>
namespace AlibabaCloud
{
namespace Config
{
namespace Model
{
class ALIBABACLOUD_CONFIG_EXPORT ListManagedRulesResult : public ServiceResult
{
public:
struct Data
{
struct ManagedRule
{
std::string description;
std::string identifier;
std::string configRuleName;
std::vector<std::string> labels;
std::string useCases;
int riskLevel;
std::string helpUrls;
int referenceCount;
};
long totalCount;
int pageSize;
int pageNumber;
std::vector<Data::ManagedRule> managedRuleList;
};
ListManagedRulesResult();
explicit ListManagedRulesResult(const std::string &payload);
~ListManagedRulesResult();
std::vector<Data> getManagedRules()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Data> managedRules_;
};
}
}
}
#endif // !ALIBABACLOUD_CONFIG_MODEL_LISTMANAGEDRULESRESULT_H_

3
config/include/alibabacloud/config/model/UpdateAggregateConfigRuleRequest.h
View File

@@ -56,6 +56,8 @@ public:
void setInputParameters(const std::string &inputParameters);
std::string getConfigRuleName() const;
void setConfigRuleName(const std::string &configRuleName);
std::string getTagKeyLogicScope() const;
void setTagKeyLogicScope(const std::string &tagKeyLogicScope);
std::string getMaximumExecutionFrequency() const;
void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
std::string getExcludeResourceIdsScope() const;
@@ -75,6 +77,7 @@ private:
std::string resourceGroupIdsScope_;
std::string inputParameters_;
std::string configRuleName_;
std::string tagKeyLogicScope_;
std::string maximumExecutionFrequency_;
std::string excludeResourceIdsScope_;
};

3
config/include/alibabacloud/config/model/UpdateConfigRuleRequest.h
View File

@@ -54,6 +54,8 @@ public:
void setInputParameters(const std::string &inputParameters);
std::string getConfigRuleName() const;
void setConfigRuleName(const std::string &configRuleName);
std::string getTagKeyLogicScope() const;
void setTagKeyLogicScope(const std::string &tagKeyLogicScope);
std::string getMaximumExecutionFrequency() const;
void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
std::string getExcludeResourceIdsScope() const;
@@ -72,6 +74,7 @@ private:
std::string resourceGroupIdsScope_;
std::string inputParameters_;
std::string configRuleName_;
std::string tagKeyLogicScope_;
std::string maximumExecutionFrequency_;
std::string excludeResourceIdsScope_;
};

216
config/src/ConfigClient.cc
View File

@@ -1095,6 +1095,78 @@ ConfigClient::GetAggregateResourceComplianceByPackOutcomeCallable ConfigClient::
return task->get_future();
}
ConfigClient::GetAggregateResourceComplianceGroupByRegionOutcome ConfigClient::getAggregateResourceComplianceGroupByRegion(const GetAggregateResourceComplianceGroupByRegionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAggregateResourceComplianceGroupByRegionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAggregateResourceComplianceGroupByRegionOutcome(GetAggregateResourceComplianceGroupByRegionResult(outcome.result()));
else
return GetAggregateResourceComplianceGroupByRegionOutcome(outcome.error());
}
void ConfigClient::getAggregateResourceComplianceGroupByRegionAsync(const GetAggregateResourceComplianceGroupByRegionRequest& request, const GetAggregateResourceComplianceGroupByRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAggregateResourceComplianceGroupByRegion(request), context);
};
asyncExecute(new Runnable(fn));
}
ConfigClient::GetAggregateResourceComplianceGroupByRegionOutcomeCallable ConfigClient::getAggregateResourceComplianceGroupByRegionCallable(const GetAggregateResourceComplianceGroupByRegionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAggregateResourceComplianceGroupByRegionOutcome()>>(
[this, request]()
{
return this->getAggregateResourceComplianceGroupByRegion(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ConfigClient::GetAggregateResourceComplianceGroupByResourceTypeOutcome ConfigClient::getAggregateResourceComplianceGroupByResourceType(const GetAggregateResourceComplianceGroupByResourceTypeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAggregateResourceComplianceGroupByResourceTypeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAggregateResourceComplianceGroupByResourceTypeOutcome(GetAggregateResourceComplianceGroupByResourceTypeResult(outcome.result()));
else
return GetAggregateResourceComplianceGroupByResourceTypeOutcome(outcome.error());
}
void ConfigClient::getAggregateResourceComplianceGroupByResourceTypeAsync(const GetAggregateResourceComplianceGroupByResourceTypeRequest& request, const GetAggregateResourceComplianceGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAggregateResourceComplianceGroupByResourceType(request), context);
};
asyncExecute(new Runnable(fn));
}
ConfigClient::GetAggregateResourceComplianceGroupByResourceTypeOutcomeCallable ConfigClient::getAggregateResourceComplianceGroupByResourceTypeCallable(const GetAggregateResourceComplianceGroupByResourceTypeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAggregateResourceComplianceGroupByResourceTypeOutcome()>>(
[this, request]()
{
return this->getAggregateResourceComplianceGroupByResourceType(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ConfigClient::GetAggregateResourceComplianceTimelineOutcome ConfigClient::getAggregateResourceComplianceTimeline(const GetAggregateResourceComplianceTimelineRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1563,6 +1635,42 @@ ConfigClient::GetDiscoveredResourceCountsGroupByResourceTypeOutcomeCallable Conf
return task->get_future();
}
ConfigClient::GetManagedRuleOutcome ConfigClient::getManagedRule(const GetManagedRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetManagedRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetManagedRuleOutcome(GetManagedRuleResult(outcome.result()));
else
return GetManagedRuleOutcome(outcome.error());
}
void ConfigClient::getManagedRuleAsync(const GetManagedRuleRequest& request, const GetManagedRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getManagedRule(request), context);
};
asyncExecute(new Runnable(fn));
}
ConfigClient::GetManagedRuleOutcomeCallable ConfigClient::getManagedRuleCallable(const GetManagedRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetManagedRuleOutcome()>>(
[this, request]()
{
return this->getManagedRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ConfigClient::GetResourceComplianceByConfigRuleOutcome ConfigClient::getResourceComplianceByConfigRule(const GetResourceComplianceByConfigRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1635,6 +1743,78 @@ ConfigClient::GetResourceComplianceByPackOutcomeCallable ConfigClient::getResour
return task->get_future();
}
ConfigClient::GetResourceComplianceGroupByRegionOutcome ConfigClient::getResourceComplianceGroupByRegion(const GetResourceComplianceGroupByRegionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetResourceComplianceGroupByRegionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetResourceComplianceGroupByRegionOutcome(GetResourceComplianceGroupByRegionResult(outcome.result()));
else
return GetResourceComplianceGroupByRegionOutcome(outcome.error());
}
void ConfigClient::getResourceComplianceGroupByRegionAsync(const GetResourceComplianceGroupByRegionRequest& request, const GetResourceComplianceGroupByRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getResourceComplianceGroupByRegion(request), context);
};
asyncExecute(new Runnable(fn));
}
ConfigClient::GetResourceComplianceGroupByRegionOutcomeCallable ConfigClient::getResourceComplianceGroupByRegionCallable(const GetResourceComplianceGroupByRegionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetResourceComplianceGroupByRegionOutcome()>>(
[this, request]()
{
return this->getResourceComplianceGroupByRegion(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ConfigClient::GetResourceComplianceGroupByResourceTypeOutcome ConfigClient::getResourceComplianceGroupByResourceType(const GetResourceComplianceGroupByResourceTypeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetResourceComplianceGroupByResourceTypeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetResourceComplianceGroupByResourceTypeOutcome(GetResourceComplianceGroupByResourceTypeResult(outcome.result()));
else
return GetResourceComplianceGroupByResourceTypeOutcome(outcome.error());
}
void ConfigClient::getResourceComplianceGroupByResourceTypeAsync(const GetResourceComplianceGroupByResourceTypeRequest& request, const GetResourceComplianceGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getResourceComplianceGroupByResourceType(request), context);
};
asyncExecute(new Runnable(fn));
}
ConfigClient::GetResourceComplianceGroupByResourceTypeOutcomeCallable ConfigClient::getResourceComplianceGroupByResourceTypeCallable(const GetResourceComplianceGroupByResourceTypeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetResourceComplianceGroupByResourceTypeOutcome()>>(
[this, request]()
{
return this->getResourceComplianceGroupByResourceType(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ConfigClient::GetResourceComplianceTimelineOutcome ConfigClient::getResourceComplianceTimeline(const GetResourceComplianceTimelineRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2067,6 +2247,42 @@ ConfigClient::ListConfigRuleEvaluationResultsOutcomeCallable ConfigClient::listC
return task->get_future();
}
ConfigClient::ListManagedRulesOutcome ConfigClient::listManagedRules(const ListManagedRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListManagedRulesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListManagedRulesOutcome(ListManagedRulesResult(outcome.result()));
else
return ListManagedRulesOutcome(outcome.error());
}
void ConfigClient::listManagedRulesAsync(const ListManagedRulesRequest& request, const ListManagedRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listManagedRules(request), context);
};
asyncExecute(new Runnable(fn));
}
ConfigClient::ListManagedRulesOutcomeCallable ConfigClient::listManagedRulesCallable(const ListManagedRulesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListManagedRulesOutcome()>>(
[this, request]()
{
return this->listManagedRules(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ConfigClient::ListResourceEvaluationResultsOutcome ConfigClient::listResourceEvaluationResults(const ListResourceEvaluationResultsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

9
config/src/model/CreateAggregateConfigRuleRequest.cc
View File

@@ -153,6 +153,15 @@ void CreateAggregateConfigRuleRequest::setConfigRuleName(const std::string &conf
setBodyParameter(std::string("ConfigRuleName"), configRuleName);
}
std::string CreateAggregateConfigRuleRequest::getTagKeyLogicScope() const {
return tagKeyLogicScope_;
}
void CreateAggregateConfigRuleRequest::setTagKeyLogicScope(const std::string &tagKeyLogicScope) {
tagKeyLogicScope_ = tagKeyLogicScope;
setBodyParameter(std::string("TagKeyLogicScope"), tagKeyLogicScope);
}
std::string CreateAggregateConfigRuleRequest::getMaximumExecutionFrequency() const {
return maximumExecutionFrequency_;
}

9
config/src/model/CreateConfigRuleRequest.cc
View File

@@ -144,6 +144,15 @@ void CreateConfigRuleRequest::setConfigRuleName(const std::string &configRuleNam
setBodyParameter(std::string("ConfigRuleName"), configRuleName);
}
std::string CreateConfigRuleRequest::getTagKeyLogicScope() const {
return tagKeyLogicScope_;
}
void CreateConfigRuleRequest::setTagKeyLogicScope(const std::string &tagKeyLogicScope) {
tagKeyLogicScope_ = tagKeyLogicScope;
setBodyParameter(std::string("TagKeyLogicScope"), tagKeyLogicScope);
}
std::string CreateConfigRuleRequest::getMaximumExecutionFrequency() const {
return maximumExecutionFrequency_;
}

9
config/src/model/GenerateAggregateConfigRulesReportRequest.cc
View File

@@ -34,6 +34,15 @@ void GenerateAggregateConfigRulesReportRequest::setClientToken(const std::string
setBodyParameter(std::string("ClientToken"), clientToken);
}
std::string GenerateAggregateConfigRulesReportRequest::getConfigRuleIds() const {
return configRuleIds_;
}
void GenerateAggregateConfigRulesReportRequest::setConfigRuleIds(const std::string &configRuleIds) {
configRuleIds_ = configRuleIds;
setBodyParameter(std::string("ConfigRuleIds"), configRuleIds);
}
std::string GenerateAggregateConfigRulesReportRequest::getAggregatorId() const {
return aggregatorId_;
}

7
config/src/model/GenerateAggregateConfigRulesReportResult.cc
View File

@@ -41,9 +41,16 @@ void GenerateAggregateConfigRulesReportResult::parse(const std::string &payload)
setRequestId(value["RequestId"].asString());
if(!value["AggregatorId"].isNull())
aggregatorId_ = value["AggregatorId"].asString();
if(!value["ReportId"].isNull())
reportId_ = value["ReportId"].asString();
}
std::string GenerateAggregateConfigRulesReportResult::getReportId()const
{
return reportId_;
}
std::string GenerateAggregateConfigRulesReportResult::getAggregatorId()const
{
return aggregatorId_;

9
config/src/model/GenerateConfigRulesReportRequest.cc
View File

@@ -34,3 +34,12 @@ void GenerateConfigRulesReportRequest::setClientToken(const std::string &clientT
setBodyParameter(std::string("ClientToken"), clientToken);
}
std::string GenerateConfigRulesReportRequest::getConfigRuleIds() const {
return configRuleIds_;
}
void GenerateConfigRulesReportRequest::setConfigRuleIds(const std::string &configRuleIds) {
configRuleIds_ = configRuleIds;
setBodyParameter(std::string("ConfigRuleIds"), configRuleIds);
}

7
config/src/model/GenerateConfigRulesReportResult.cc
View File

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

2
config/src/model/GetAggregateConfigRuleResult.cc
View File

@@ -74,6 +74,8 @@ void GetAggregateConfigRuleResult::parse(const std::string &payload)
configRule_.tagValueScope = configRuleNode["TagValueScope"].asString();
if(!configRuleNode["ConfigRuleTriggerTypes"].isNull())
configRule_.configRuleTriggerTypes = configRuleNode["ConfigRuleTriggerTypes"].asString();
if(!configRuleNode["TagKeyLogicScope"].isNull())
configRule_.tagKeyLogicScope = configRuleNode["TagKeyLogicScope"].asString();
auto sourceNode = configRuleNode["Source"];
if(!sourceNode["Owner"].isNull())
configRule_.source.owner = sourceNode["Owner"].asString();

11
config/src/model/GetAggregateConfigRulesReportRequest.cc
View File

@@ -20,11 +20,20 @@ using AlibabaCloud::Config::Model::GetAggregateConfigRulesReportRequest;
GetAggregateConfigRulesReportRequest::GetAggregateConfigRulesReportRequest()
: RpcServiceRequest("config", "2020-09-07", "GetAggregateConfigRulesReport") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
GetAggregateConfigRulesReportRequest::~GetAggregateConfigRulesReportRequest() {}
std::string GetAggregateConfigRulesReportRequest::getReportId() const {
return reportId_;
}
void GetAggregateConfigRulesReportRequest::setReportId(const std::string &reportId) {
reportId_ = reportId;
setParameter(std::string("ReportId"), reportId);
}
std::string GetAggregateConfigRulesReportRequest::getAggregatorId() const {
return aggregatorId_;
}

2
config/src/model/GetAggregateConfigRulesReportResult.cc
View File

@@ -50,6 +50,8 @@ void GetAggregateConfigRulesReportResult::parse(const std::string &payload)
configRulesReport_.aggregatorId = configRulesReportNode["AggregatorId"].asString();
if(!configRulesReportNode["ReportCreateTimestamp"].isNull())
configRulesReport_.reportCreateTimestamp = std::stol(configRulesReportNode["ReportCreateTimestamp"].asString());
if(!configRulesReportNode["ReportId"].isNull())
configRulesReport_.reportId = configRulesReportNode["ReportId"].asString();
}

2
config/src/model/GetAggregateResourceComplianceByConfigRuleRequest.cc
View File

@@ -20,7 +20,7 @@ using AlibabaCloud::Config::Model::GetAggregateResourceComplianceByConfigRuleReq
GetAggregateResourceComplianceByConfigRuleRequest::GetAggregateResourceComplianceByConfigRuleRequest()
: RpcServiceRequest("config", "2020-09-07", "GetAggregateResourceComplianceByConfigRule") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
GetAggregateResourceComplianceByConfigRuleRequest::~GetAggregateResourceComplianceByConfigRuleRequest() {}

45
config/src/model/GetAggregateResourceComplianceGroupByRegionRequest.cc Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionRequest.h>
using AlibabaCloud::Config::Model::GetAggregateResourceComplianceGroupByRegionRequest;
GetAggregateResourceComplianceGroupByRegionRequest::GetAggregateResourceComplianceGroupByRegionRequest()
: RpcServiceRequest("config", "2020-09-07", "GetAggregateResourceComplianceGroupByRegion") {
setMethod(HttpRequest::Method::Post);
}
GetAggregateResourceComplianceGroupByRegionRequest::~GetAggregateResourceComplianceGroupByRegionRequest() {}
std::string GetAggregateResourceComplianceGroupByRegionRequest::getConfigRuleIds() const {
return configRuleIds_;
}
void GetAggregateResourceComplianceGroupByRegionRequest::setConfigRuleIds(const std::string &configRuleIds) {
configRuleIds_ = configRuleIds;
setParameter(std::string("ConfigRuleIds"), configRuleIds);
}
std::string GetAggregateResourceComplianceGroupByRegionRequest::getAggregatorId() const {
return aggregatorId_;
}
void GetAggregateResourceComplianceGroupByRegionRequest::setAggregatorId(const std::string &aggregatorId) {
aggregatorId_ = aggregatorId;
setParameter(std::string("AggregatorId"), aggregatorId);
}

68
config/src/model/GetAggregateResourceComplianceGroupByRegionResult.cc Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Config;
using namespace AlibabaCloud::Config::Model;
GetAggregateResourceComplianceGroupByRegionResult::GetAggregateResourceComplianceGroupByRegionResult() :
ServiceResult()
{}
GetAggregateResourceComplianceGroupByRegionResult::GetAggregateResourceComplianceGroupByRegionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAggregateResourceComplianceGroupByRegionResult::~GetAggregateResourceComplianceGroupByRegionResult()
{}
void GetAggregateResourceComplianceGroupByRegionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto complianceResultNode = value["ComplianceResult"];
auto allComplianceResultListNode = complianceResultNode["ComplianceResultList"]["ComplianceResultListItem"];
for (auto complianceResultNodeComplianceResultListComplianceResultListItem : allComplianceResultListNode)
{
ComplianceResult::ComplianceResultListItem complianceResultListItemObject;
if(!complianceResultNodeComplianceResultListComplianceResultListItem["RegionId"].isNull())
complianceResultListItemObject.regionId = complianceResultNodeComplianceResultListComplianceResultListItem["RegionId"].asString();
auto allCompliancesNode = complianceResultNodeComplianceResultListComplianceResultListItem["Compliances"]["CompliancesItem"];
for (auto complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem : allCompliancesNode)
{
ComplianceResult::ComplianceResultListItem::CompliancesItem compliancesObject;
if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].isNull())
compliancesObject.complianceType = complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].asString();
if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].isNull())
compliancesObject.count = std::stol(complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].asString());
complianceResultListItemObject.compliances.push_back(compliancesObject);
}
complianceResult_.complianceResultList.push_back(complianceResultListItemObject);
}
}
GetAggregateResourceComplianceGroupByRegionResult::ComplianceResult GetAggregateResourceComplianceGroupByRegionResult::getComplianceResult()const
{
return complianceResult_;
}

45
config/src/model/GetAggregateResourceComplianceGroupByResourceTypeRequest.cc Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeRequest.h>
using AlibabaCloud::Config::Model::GetAggregateResourceComplianceGroupByResourceTypeRequest;
GetAggregateResourceComplianceGroupByResourceTypeRequest::GetAggregateResourceComplianceGroupByResourceTypeRequest()
: RpcServiceRequest("config", "2020-09-07", "GetAggregateResourceComplianceGroupByResourceType") {
setMethod(HttpRequest::Method::Post);
}
GetAggregateResourceComplianceGroupByResourceTypeRequest::~GetAggregateResourceComplianceGroupByResourceTypeRequest() {}
std::string GetAggregateResourceComplianceGroupByResourceTypeRequest::getConfigRuleIds() const {
return configRuleIds_;
}
void GetAggregateResourceComplianceGroupByResourceTypeRequest::setConfigRuleIds(const std::string &configRuleIds) {
configRuleIds_ = configRuleIds;
setParameter(std::string("ConfigRuleIds"), configRuleIds);
}
std::string GetAggregateResourceComplianceGroupByResourceTypeRequest::getAggregatorId() const {
return aggregatorId_;
}
void GetAggregateResourceComplianceGroupByResourceTypeRequest::setAggregatorId(const std::string &aggregatorId) {
aggregatorId_ = aggregatorId;
setParameter(std::string("AggregatorId"), aggregatorId);
}

68
config/src/model/GetAggregateResourceComplianceGroupByResourceTypeResult.cc Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Config;
using namespace AlibabaCloud::Config::Model;
GetAggregateResourceComplianceGroupByResourceTypeResult::GetAggregateResourceComplianceGroupByResourceTypeResult() :
ServiceResult()
{}
GetAggregateResourceComplianceGroupByResourceTypeResult::GetAggregateResourceComplianceGroupByResourceTypeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAggregateResourceComplianceGroupByResourceTypeResult::~GetAggregateResourceComplianceGroupByResourceTypeResult()
{}
void GetAggregateResourceComplianceGroupByResourceTypeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto complianceResultNode = value["ComplianceResult"];
auto allComplianceResultListNode = complianceResultNode["ComplianceResultList"]["ComplianceResultListItem"];
for (auto complianceResultNodeComplianceResultListComplianceResultListItem : allComplianceResultListNode)
{
ComplianceResult::ComplianceResultListItem complianceResultListItemObject;
if(!complianceResultNodeComplianceResultListComplianceResultListItem["ResourceType"].isNull())
complianceResultListItemObject.resourceType = complianceResultNodeComplianceResultListComplianceResultListItem["ResourceType"].asString();
auto allCompliancesNode = complianceResultNodeComplianceResultListComplianceResultListItem["Compliances"]["CompliancesItem"];
for (auto complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem : allCompliancesNode)
{
ComplianceResult::ComplianceResultListItem::CompliancesItem compliancesObject;
if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].isNull())
compliancesObject.complianceType = complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].asString();
if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].isNull())
compliancesObject.count = std::stol(complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].asString());
complianceResultListItemObject.compliances.push_back(compliancesObject);
}
complianceResult_.complianceResultList.push_back(complianceResultListItemObject);
}
}
GetAggregateResourceComplianceGroupByResourceTypeResult::ComplianceResult GetAggregateResourceComplianceGroupByResourceTypeResult::getComplianceResult()const
{
return complianceResult_;
}

2
config/src/model/GetConfigRuleResult.cc
View File

@@ -74,6 +74,8 @@ void GetConfigRuleResult::parse(const std::string &payload)
configRule_.tagValueScope = configRuleNode["TagValueScope"].asString();
if(!configRuleNode["ConfigRuleTriggerTypes"].isNull())
configRule_.configRuleTriggerTypes = configRuleNode["ConfigRuleTriggerTypes"].asString();
if(!configRuleNode["TagKeyLogicScope"].isNull())
configRule_.tagKeyLogicScope = configRuleNode["TagKeyLogicScope"].asString();
auto sourceNode = configRuleNode["Source"];
if(!sourceNode["Owner"].isNull())
configRule_.source.owner = sourceNode["Owner"].asString();

11
config/src/model/GetConfigRulesReportRequest.cc
View File

@@ -20,8 +20,17 @@ using AlibabaCloud::Config::Model::GetConfigRulesReportRequest;
GetConfigRulesReportRequest::GetConfigRulesReportRequest()
: RpcServiceRequest("config", "2020-09-07", "GetConfigRulesReport") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
GetConfigRulesReportRequest::~GetConfigRulesReportRequest() {}
std::string GetConfigRulesReportRequest::getReportId() const {
return reportId_;
}
void GetConfigRulesReportRequest::setReportId(const std::string &reportId) {
reportId_ = reportId;
setParameter(std::string("ReportId"), reportId);
}

2
config/src/model/GetConfigRulesReportResult.cc
View File

@@ -48,6 +48,8 @@ void GetConfigRulesReportResult::parse(const std::string &payload)
configRulesReport_.accountId = std::stol(configRulesReportNode["AccountId"].asString());
if(!configRulesReportNode["ReportCreateTimestamp"].isNull())
configRulesReport_.reportCreateTimestamp = std::stol(configRulesReportNode["ReportCreateTimestamp"].asString());
if(!configRulesReportNode["ReportId"].isNull())
configRulesReport_.reportId = configRulesReportNode["ReportId"].asString();
}

36
config/src/model/GetManagedRuleRequest.cc Normal file
View File

@@ -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 <alibabacloud/config/model/GetManagedRuleRequest.h>
using AlibabaCloud::Config::Model::GetManagedRuleRequest;
GetManagedRuleRequest::GetManagedRuleRequest()
: RpcServiceRequest("config", "2020-09-07", "GetManagedRule") {
setMethod(HttpRequest::Method::Post);
}
GetManagedRuleRequest::~GetManagedRuleRequest() {}
std::string GetManagedRuleRequest::getIdentifier() const {
return identifier_;
}
void GetManagedRuleRequest::setIdentifier(const std::string &identifier) {
identifier_ = identifier;
setParameter(std::string("Identifier"), identifier);
}

102
config/src/model/GetManagedRuleResult.cc Normal file
View File

@@ -0,0 +1,102 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/config/model/GetManagedRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Config;
using namespace AlibabaCloud::Config::Model;
GetManagedRuleResult::GetManagedRuleResult() :
ServiceResult()
{}
GetManagedRuleResult::GetManagedRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetManagedRuleResult::~GetManagedRuleResult()
{}
void GetManagedRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto managedRuleNode = value["ManagedRule"];
if(!managedRuleNode["RiskLevel"].isNull())
managedRule_.riskLevel = std::stoi(managedRuleNode["RiskLevel"].asString());
if(!managedRuleNode["HelpHint"].isNull())
managedRule_.helpHint = managedRuleNode["HelpHint"].asString();
if(!managedRuleNode["DefaultName"].isNull())
managedRule_.defaultName = managedRuleNode["DefaultName"].asString();
if(!managedRuleNode["Identifier"].isNull())
managedRule_.identifier = managedRuleNode["Identifier"].asString();
if(!managedRuleNode["RegionId"].isNull())
managedRule_.regionId = managedRuleNode["RegionId"].asString();
if(!managedRuleNode["Description"].isNull())
managedRule_.description = managedRuleNode["Description"].asString();
if(!managedRuleNode["FunctionName"].isNull())
managedRule_.functionName = managedRuleNode["FunctionName"].asString();
if(!managedRuleNode["ConfigRuleName"].isNull())
managedRule_.configRuleName = managedRuleNode["ConfigRuleName"].asString();
if(!managedRuleNode["HelpDoc"].isNull())
managedRule_.helpDoc = managedRuleNode["HelpDoc"].asString();
if(!managedRuleNode["HelpUrls"].isNull())
managedRule_.helpUrls = managedRuleNode["HelpUrls"].asString();
if(!managedRuleNode["ServiceName"].isNull())
managedRule_.serviceName = managedRuleNode["ServiceName"].asString();
if(!managedRuleNode["CreateTimestamp"].isNull())
managedRule_.createTimestamp = std::stol(managedRuleNode["CreateTimestamp"].asString());
auto allSourceDetailsNode = managedRuleNode["SourceDetails"]["SourceDetailsItem"];
for (auto managedRuleNodeSourceDetailsSourceDetailsItem : allSourceDetailsNode)
{
ManagedRule::SourceDetailsItem sourceDetailsItemObject;
if(!managedRuleNodeSourceDetailsSourceDetailsItem["MessageType"].isNull())
sourceDetailsItemObject.messageType = managedRuleNodeSourceDetailsSourceDetailsItem["MessageType"].asString();
if(!managedRuleNodeSourceDetailsSourceDetailsItem["EventSource"].isNull())
sourceDetailsItemObject.eventSource = managedRuleNodeSourceDetailsSourceDetailsItem["EventSource"].asString();
if(!managedRuleNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].isNull())
sourceDetailsItemObject.maximumExecutionFrequency = managedRuleNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].asString();
managedRule_.sourceDetails.push_back(sourceDetailsItemObject);
}
auto scopeNode = managedRuleNode["Scope"];
auto allComplianceResourceTypes = scopeNode["ComplianceResourceTypes"]["ComplianceResourceTypes"];
for (auto value : allComplianceResourceTypes)
managedRule_.scope.complianceResourceTypes.push_back(value.asString());
auto allLabels = managedRuleNode["Labels"]["Labels"];
for (auto value : allLabels)
managedRule_.labels.push_back(value.asString());
auto allSourceConditions = managedRuleNode["SourceConditions"]["SourceConditions"];
for (auto value : allSourceConditions)
managedRule_.sourceConditions.push_back(value.asString());
auto allOptionalInputParameterDetails = managedRuleNode["OptionalInputParameterDetails"]["OptionalInputParameterDetails"];
for (auto value : allOptionalInputParameterDetails)
managedRule_.optionalInputParameterDetails.push_back(value.asString());
auto allCompulsoryInputParameterDetails = managedRuleNode["CompulsoryInputParameterDetails"]["CompulsoryInputParameterDetails"];
for (auto value : allCompulsoryInputParameterDetails)
managedRule_.compulsoryInputParameterDetails.push_back(value.asString());
}
GetManagedRuleResult::ManagedRule GetManagedRuleResult::getManagedRule()const
{
return managedRule_;
}

36
config/src/model/GetResourceComplianceGroupByRegionRequest.cc Normal file
View File

@@ -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 <alibabacloud/config/model/GetResourceComplianceGroupByRegionRequest.h>
using AlibabaCloud::Config::Model::GetResourceComplianceGroupByRegionRequest;
GetResourceComplianceGroupByRegionRequest::GetResourceComplianceGroupByRegionRequest()
: RpcServiceRequest("config", "2020-09-07", "GetResourceComplianceGroupByRegion") {
setMethod(HttpRequest::Method::Post);
}
GetResourceComplianceGroupByRegionRequest::~GetResourceComplianceGroupByRegionRequest() {}
std::string GetResourceComplianceGroupByRegionRequest::getConfigRuleIds() const {
return configRuleIds_;
}
void GetResourceComplianceGroupByRegionRequest::setConfigRuleIds(const std::string &configRuleIds) {
configRuleIds_ = configRuleIds;
setParameter(std::string("ConfigRuleIds"), configRuleIds);
}

68
config/src/model/GetResourceComplianceGroupByRegionResult.cc Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/config/model/GetResourceComplianceGroupByRegionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Config;
using namespace AlibabaCloud::Config::Model;
GetResourceComplianceGroupByRegionResult::GetResourceComplianceGroupByRegionResult() :
ServiceResult()
{}
GetResourceComplianceGroupByRegionResult::GetResourceComplianceGroupByRegionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetResourceComplianceGroupByRegionResult::~GetResourceComplianceGroupByRegionResult()
{}
void GetResourceComplianceGroupByRegionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto complianceResultNode = value["ComplianceResult"];
auto allComplianceResultListNode = complianceResultNode["ComplianceResultList"]["ComplianceResultListItem"];
for (auto complianceResultNodeComplianceResultListComplianceResultListItem : allComplianceResultListNode)
{
ComplianceResult::ComplianceResultListItem complianceResultListItemObject;
if(!complianceResultNodeComplianceResultListComplianceResultListItem["RegionId"].isNull())
complianceResultListItemObject.regionId = complianceResultNodeComplianceResultListComplianceResultListItem["RegionId"].asString();
auto allCompliancesNode = complianceResultNodeComplianceResultListComplianceResultListItem["Compliances"]["CompliancesItem"];
for (auto complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem : allCompliancesNode)
{
ComplianceResult::ComplianceResultListItem::CompliancesItem compliancesObject;
if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].isNull())
compliancesObject.complianceType = complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].asString();
if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].isNull())
compliancesObject.count = std::stol(complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].asString());
complianceResultListItemObject.compliances.push_back(compliancesObject);
}
complianceResult_.complianceResultList.push_back(complianceResultListItemObject);
}
}
GetResourceComplianceGroupByRegionResult::ComplianceResult GetResourceComplianceGroupByRegionResult::getComplianceResult()const
{
return complianceResult_;
}

36
config/src/model/GetResourceComplianceGroupByResourceTypeRequest.cc Normal file
View File

@@ -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 <alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeRequest.h>
using AlibabaCloud::Config::Model::GetResourceComplianceGroupByResourceTypeRequest;
GetResourceComplianceGroupByResourceTypeRequest::GetResourceComplianceGroupByResourceTypeRequest()
: RpcServiceRequest("config", "2020-09-07", "GetResourceComplianceGroupByResourceType") {
setMethod(HttpRequest::Method::Post);
}
GetResourceComplianceGroupByResourceTypeRequest::~GetResourceComplianceGroupByResourceTypeRequest() {}
std::string GetResourceComplianceGroupByResourceTypeRequest::getConfigRuleIds() const {
return configRuleIds_;
}
void GetResourceComplianceGroupByResourceTypeRequest::setConfigRuleIds(const std::string &configRuleIds) {
configRuleIds_ = configRuleIds;
setParameter(std::string("ConfigRuleIds"), configRuleIds);
}

68
config/src/model/GetResourceComplianceGroupByResourceTypeResult.cc Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Config;
using namespace AlibabaCloud::Config::Model;
GetResourceComplianceGroupByResourceTypeResult::GetResourceComplianceGroupByResourceTypeResult() :
ServiceResult()
{}
GetResourceComplianceGroupByResourceTypeResult::GetResourceComplianceGroupByResourceTypeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetResourceComplianceGroupByResourceTypeResult::~GetResourceComplianceGroupByResourceTypeResult()
{}
void GetResourceComplianceGroupByResourceTypeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto complianceResultNode = value["ComplianceResult"];
auto allComplianceResultListNode = complianceResultNode["ComplianceResultList"]["ComplianceResultListItem"];
for (auto complianceResultNodeComplianceResultListComplianceResultListItem : allComplianceResultListNode)
{
ComplianceResult::ComplianceResultListItem complianceResultListItemObject;
if(!complianceResultNodeComplianceResultListComplianceResultListItem["ResourceType"].isNull())
complianceResultListItemObject.resourceType = complianceResultNodeComplianceResultListComplianceResultListItem["ResourceType"].asString();
auto allCompliancesNode = complianceResultNodeComplianceResultListComplianceResultListItem["Compliances"]["CompliancesItem"];
for (auto complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem : allCompliancesNode)
{
ComplianceResult::ComplianceResultListItem::CompliancesItem compliancesObject;
if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].isNull())
compliancesObject.complianceType = complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].asString();
if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].isNull())
compliancesObject.count = std::stol(complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].asString());
complianceResultListItemObject.compliances.push_back(compliancesObject);
}
complianceResult_.complianceResultList.push_back(complianceResultListItemObject);
}
}
GetResourceComplianceGroupByResourceTypeResult::ComplianceResult GetResourceComplianceGroupByResourceTypeResult::getComplianceResult()const
{
return complianceResult_;
}

2
config/src/model/ListAggregateResourceEvaluationResultsRequest.cc
View File

@@ -20,7 +20,7 @@ using AlibabaCloud::Config::Model::ListAggregateResourceEvaluationResultsRequest
ListAggregateResourceEvaluationResultsRequest::ListAggregateResourceEvaluationResultsRequest()
: RpcServiceRequest("config", "2020-09-07", "ListAggregateResourceEvaluationResults") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
ListAggregateResourceEvaluationResultsRequest::~ListAggregateResourceEvaluationResultsRequest() {}

63
config/src/model/ListManagedRulesRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/config/model/ListManagedRulesRequest.h>
using AlibabaCloud::Config::Model::ListManagedRulesRequest;
ListManagedRulesRequest::ListManagedRulesRequest()
: RpcServiceRequest("config", "2020-09-07", "ListManagedRules") {
setMethod(HttpRequest::Method::Post);
}
ListManagedRulesRequest::~ListManagedRulesRequest() {}
int ListManagedRulesRequest::getRiskLevel() const {
return riskLevel_;
}
void ListManagedRulesRequest::setRiskLevel(int riskLevel) {
riskLevel_ = riskLevel;
setParameter(std::string("RiskLevel"), std::to_string(riskLevel));
}
int ListManagedRulesRequest::getPageNumber() const {
return pageNumber_;
}
void ListManagedRulesRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
int ListManagedRulesRequest::getPageSize() const {
return pageSize_;
}
void ListManagedRulesRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string ListManagedRulesRequest::getKeyword() const {
return keyword_;
}
void ListManagedRulesRequest::setKeyword(const std::string &keyword) {
keyword_ = keyword;
setParameter(std::string("Keyword"), keyword);
}

84
config/src/model/ListManagedRulesResult.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/config/model/ListManagedRulesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Config;
using namespace AlibabaCloud::Config::Model;
ListManagedRulesResult::ListManagedRulesResult() :
ServiceResult()
{}
ListManagedRulesResult::ListManagedRulesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListManagedRulesResult::~ListManagedRulesResult()
{}
void ListManagedRulesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allManagedRulesNode = value["ManagedRules"]["Data"];
for (auto valueManagedRulesData : allManagedRulesNode)
{
Data managedRulesObject;
if(!valueManagedRulesData["PageSize"].isNull())
managedRulesObject.pageSize = std::stoi(valueManagedRulesData["PageSize"].asString());
if(!valueManagedRulesData["PageNumber"].isNull())
managedRulesObject.pageNumber = std::stoi(valueManagedRulesData["PageNumber"].asString());
if(!valueManagedRulesData["TotalCount"].isNull())
managedRulesObject.totalCount = std::stol(valueManagedRulesData["TotalCount"].asString());
auto allManagedRuleListNode = valueManagedRulesData["ManagedRuleList"]["ManagedRule"];
for (auto valueManagedRulesDataManagedRuleListManagedRule : allManagedRuleListNode)
{
Data::ManagedRule managedRuleListObject;
if(!valueManagedRulesDataManagedRuleListManagedRule["RiskLevel"].isNull())
managedRuleListObject.riskLevel = std::stoi(valueManagedRulesDataManagedRuleListManagedRule["RiskLevel"].asString());
if(!valueManagedRulesDataManagedRuleListManagedRule["Description"].isNull())
managedRuleListObject.description = valueManagedRulesDataManagedRuleListManagedRule["Description"].asString();
if(!valueManagedRulesDataManagedRuleListManagedRule["UseCases"].isNull())
managedRuleListObject.useCases = valueManagedRulesDataManagedRuleListManagedRule["UseCases"].asString();
if(!valueManagedRulesDataManagedRuleListManagedRule["Identifier"].isNull())
managedRuleListObject.identifier = valueManagedRulesDataManagedRuleListManagedRule["Identifier"].asString();
if(!valueManagedRulesDataManagedRuleListManagedRule["ConfigRuleName"].isNull())
managedRuleListObject.configRuleName = valueManagedRulesDataManagedRuleListManagedRule["ConfigRuleName"].asString();
if(!valueManagedRulesDataManagedRuleListManagedRule["ReferenceCount"].isNull())
managedRuleListObject.referenceCount = std::stoi(valueManagedRulesDataManagedRuleListManagedRule["ReferenceCount"].asString());
if(!valueManagedRulesDataManagedRuleListManagedRule["HelpUrls"].isNull())
managedRuleListObject.helpUrls = valueManagedRulesDataManagedRuleListManagedRule["HelpUrls"].asString();
auto allLabels = value["Labels"]["Labels"];
for (auto value : allLabels)
managedRuleListObject.labels.push_back(value.asString());
managedRulesObject.managedRuleList.push_back(managedRuleListObject);
}
managedRules_.push_back(managedRulesObject);
}
}
std::vector<ListManagedRulesResult::Data> ListManagedRulesResult::getManagedRules()const
{
return managedRules_;
}

2
config/src/model/ListResourceEvaluationResultsRequest.cc
View File

@@ -20,7 +20,7 @@ using AlibabaCloud::Config::Model::ListResourceEvaluationResultsRequest;
ListResourceEvaluationResultsRequest::ListResourceEvaluationResultsRequest()
: RpcServiceRequest("config", "2020-09-07", "ListResourceEvaluationResults") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
ListResourceEvaluationResultsRequest::~ListResourceEvaluationResultsRequest() {}

9
config/src/model/UpdateAggregateConfigRuleRequest.cc
View File

@@ -144,6 +144,15 @@ void UpdateAggregateConfigRuleRequest::setConfigRuleName(const std::string &conf
setBodyParameter(std::string("ConfigRuleName"), configRuleName);
}
std::string UpdateAggregateConfigRuleRequest::getTagKeyLogicScope() const {
return tagKeyLogicScope_;
}
void UpdateAggregateConfigRuleRequest::setTagKeyLogicScope(const std::string &tagKeyLogicScope) {
tagKeyLogicScope_ = tagKeyLogicScope;
setBodyParameter(std::string("TagKeyLogicScope"), tagKeyLogicScope);
}
std::string UpdateAggregateConfigRuleRequest::getMaximumExecutionFrequency() const {
return maximumExecutionFrequency_;
}

9
config/src/model/UpdateConfigRuleRequest.cc
View File

@@ -135,6 +135,15 @@ void UpdateConfigRuleRequest::setConfigRuleName(const std::string &configRuleNam
setBodyParameter(std::string("ConfigRuleName"), configRuleName);
}
std::string UpdateConfigRuleRequest::getTagKeyLogicScope() const {
return tagKeyLogicScope_;
}
void UpdateConfigRuleRequest::setTagKeyLogicScope(const std::string &tagKeyLogicScope) {
tagKeyLogicScope_ = tagKeyLogicScope;
setBodyParameter(std::string("TagKeyLogicScope"), tagKeyLogicScope);
}
std::string UpdateConfigRuleRequest::getMaximumExecutionFrequency() const {
return maximumExecutionFrequency_;
}