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

Optimize return code.

Browse Source
This commit is contained in:
sdk-team
2019-08-13 22:13:11 +08:00
parent 919e9477c5
commit 600883d23a
60 changed files with 4095 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

184
arms/include/alibabacloud/arms/ARMSClient.h
View File

@@ -22,24 +22,34 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ARMSExport.h"
#include "model/GetTraceRequest.h"
#include "model/GetTraceResult.h"
#include "model/SearchTracesRequest.h"
#include "model/SearchTracesResult.h"
#include "model/SearchTraceCountRequest.h"
#include "model/SearchTraceCountResult.h"
#include "model/GetTagKeyRequest.h"
#include "model/GetTagKeyResult.h"
#include "model/ARMSQueryDataSetRequest.h"
#include "model/ARMSQueryDataSetResult.h"
#include "model/GetSpanNamesRequest.h"
#include "model/GetSpanNamesResult.h"
#include "model/GetServicesRequest.h"
#include "model/GetServicesResult.h"
#include "model/MetricQueryRequest.h"
#include "model/MetricQueryResult.h"
#include "model/GetTagValRequest.h"
#include "model/GetTagValResult.h"
#include "model/SearchAlertContactRequest.h"
#include "model/SearchAlertContactResult.h"
#include "model/ListTraceAppsRequest.h"
#include "model/ListTraceAppsResult.h"
#include "model/DeleteRetcodeAppRequest.h"
#include "model/DeleteRetcodeAppResult.h"
#include "model/SearchTraceAppByPageRequest.h"
#include "model/SearchTraceAppByPageResult.h"
#include "model/ImportAppAlertRulesRequest.h"
#include "model/ImportAppAlertRulesResult.h"
#include "model/CreateAlertContactGroupRequest.h"
#include "model/CreateAlertContactGroupResult.h"
#include "model/QueryDatasetRequest.h"
#include "model/QueryDatasetResult.h"
#include "model/SearchRetcodeAppByPageRequest.h"
#include "model/SearchRetcodeAppByPageResult.h"
#include "model/SearchTraceAppByNameRequest.h"
#include "model/SearchTraceAppByNameResult.h"
#include "model/ListRetcodeAppsRequest.h"
#include "model/ListRetcodeAppsResult.h"
#include "model/SearchAlertContactGroupRequest.h"
#include "model/SearchAlertContactGroupResult.h"
#include "model/CreateAlertContactRequest.h"
#include "model/CreateAlertContactResult.h"
#include "model/QueryMetricRequest.h"
#include "model/QueryMetricResult.h"
#include "model/CreateRetcodeAppRequest.h"
#include "model/CreateRetcodeAppResult.h"
namespace AlibabaCloud
@@ -49,65 +59,95 @@ namespace AlibabaCloud
class ALIBABACLOUD_ARMS_EXPORT ARMSClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::GetTraceResult> GetTraceOutcome;
typedef std::future<GetTraceOutcome> GetTraceOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::GetTraceRequest&, const GetTraceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTraceAsyncHandler;
typedef Outcome<Error, Model::SearchTracesResult> SearchTracesOutcome;
typedef std::future<SearchTracesOutcome> SearchTracesOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::SearchTracesRequest&, const SearchTracesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchTracesAsyncHandler;
typedef Outcome<Error, Model::SearchTraceCountResult> SearchTraceCountOutcome;
typedef std::future<SearchTraceCountOutcome> SearchTraceCountOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::SearchTraceCountRequest&, const SearchTraceCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchTraceCountAsyncHandler;
typedef Outcome<Error, Model::GetTagKeyResult> GetTagKeyOutcome;
typedef std::future<GetTagKeyOutcome> GetTagKeyOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::GetTagKeyRequest&, const GetTagKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTagKeyAsyncHandler;
typedef Outcome<Error, Model::ARMSQueryDataSetResult> ARMSQueryDataSetOutcome;
typedef std::future<ARMSQueryDataSetOutcome> ARMSQueryDataSetOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ARMSQueryDataSetRequest&, const ARMSQueryDataSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ARMSQueryDataSetAsyncHandler;
typedef Outcome<Error, Model::GetSpanNamesResult> GetSpanNamesOutcome;
typedef std::future<GetSpanNamesOutcome> GetSpanNamesOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::GetSpanNamesRequest&, const GetSpanNamesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSpanNamesAsyncHandler;
typedef Outcome<Error, Model::GetServicesResult> GetServicesOutcome;
typedef std::future<GetServicesOutcome> GetServicesOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::GetServicesRequest&, const GetServicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServicesAsyncHandler;
typedef Outcome<Error, Model::MetricQueryResult> MetricQueryOutcome;
typedef std::future<MetricQueryOutcome> MetricQueryOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::MetricQueryRequest&, const MetricQueryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MetricQueryAsyncHandler;
typedef Outcome<Error, Model::GetTagValResult> GetTagValOutcome;
typedef std::future<GetTagValOutcome> GetTagValOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::GetTagValRequest&, const GetTagValOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTagValAsyncHandler;
typedef Outcome<Error, Model::SearchAlertContactResult> SearchAlertContactOutcome;
typedef std::future<SearchAlertContactOutcome> SearchAlertContactOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::SearchAlertContactRequest&, const SearchAlertContactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchAlertContactAsyncHandler;
typedef Outcome<Error, Model::ListTraceAppsResult> ListTraceAppsOutcome;
typedef std::future<ListTraceAppsOutcome> ListTraceAppsOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ListTraceAppsRequest&, const ListTraceAppsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTraceAppsAsyncHandler;
typedef Outcome<Error, Model::DeleteRetcodeAppResult> DeleteRetcodeAppOutcome;
typedef std::future<DeleteRetcodeAppOutcome> DeleteRetcodeAppOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::DeleteRetcodeAppRequest&, const DeleteRetcodeAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRetcodeAppAsyncHandler;
typedef Outcome<Error, Model::SearchTraceAppByPageResult> SearchTraceAppByPageOutcome;
typedef std::future<SearchTraceAppByPageOutcome> SearchTraceAppByPageOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::SearchTraceAppByPageRequest&, const SearchTraceAppByPageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchTraceAppByPageAsyncHandler;
typedef Outcome<Error, Model::ImportAppAlertRulesResult> ImportAppAlertRulesOutcome;
typedef std::future<ImportAppAlertRulesOutcome> ImportAppAlertRulesOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ImportAppAlertRulesRequest&, const ImportAppAlertRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportAppAlertRulesAsyncHandler;
typedef Outcome<Error, Model::CreateAlertContactGroupResult> CreateAlertContactGroupOutcome;
typedef std::future<CreateAlertContactGroupOutcome> CreateAlertContactGroupOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::CreateAlertContactGroupRequest&, const CreateAlertContactGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAlertContactGroupAsyncHandler;
typedef Outcome<Error, Model::QueryDatasetResult> QueryDatasetOutcome;
typedef std::future<QueryDatasetOutcome> QueryDatasetOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::QueryDatasetRequest&, const QueryDatasetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDatasetAsyncHandler;
typedef Outcome<Error, Model::SearchRetcodeAppByPageResult> SearchRetcodeAppByPageOutcome;
typedef std::future<SearchRetcodeAppByPageOutcome> SearchRetcodeAppByPageOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::SearchRetcodeAppByPageRequest&, const SearchRetcodeAppByPageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchRetcodeAppByPageAsyncHandler;
typedef Outcome<Error, Model::SearchTraceAppByNameResult> SearchTraceAppByNameOutcome;
typedef std::future<SearchTraceAppByNameOutcome> SearchTraceAppByNameOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::SearchTraceAppByNameRequest&, const SearchTraceAppByNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchTraceAppByNameAsyncHandler;
typedef Outcome<Error, Model::ListRetcodeAppsResult> ListRetcodeAppsOutcome;
typedef std::future<ListRetcodeAppsOutcome> ListRetcodeAppsOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::ListRetcodeAppsRequest&, const ListRetcodeAppsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRetcodeAppsAsyncHandler;
typedef Outcome<Error, Model::SearchAlertContactGroupResult> SearchAlertContactGroupOutcome;
typedef std::future<SearchAlertContactGroupOutcome> SearchAlertContactGroupOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::SearchAlertContactGroupRequest&, const SearchAlertContactGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchAlertContactGroupAsyncHandler;
typedef Outcome<Error, Model::CreateAlertContactResult> CreateAlertContactOutcome;
typedef std::future<CreateAlertContactOutcome> CreateAlertContactOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::CreateAlertContactRequest&, const CreateAlertContactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAlertContactAsyncHandler;
typedef Outcome<Error, Model::QueryMetricResult> QueryMetricOutcome;
typedef std::future<QueryMetricOutcome> QueryMetricOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::QueryMetricRequest&, const QueryMetricOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryMetricAsyncHandler;
typedef Outcome<Error, Model::CreateRetcodeAppResult> CreateRetcodeAppOutcome;
typedef std::future<CreateRetcodeAppOutcome> CreateRetcodeAppOutcomeCallable;
typedef std::function<void(const ARMSClient*, const Model::CreateRetcodeAppRequest&, const CreateRetcodeAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRetcodeAppAsyncHandler;
ARMSClient(const Credentials &credentials, const ClientConfiguration &configuration);
ARMSClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ARMSClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ARMSClient();
GetTraceOutcome getTrace(const Model::GetTraceRequest &request)const;
void getTraceAsync(const Model::GetTraceRequest& request, const GetTraceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTraceOutcomeCallable getTraceCallable(const Model::GetTraceRequest& request) const;
SearchTracesOutcome searchTraces(const Model::SearchTracesRequest &request)const;
void searchTracesAsync(const Model::SearchTracesRequest& request, const SearchTracesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchTracesOutcomeCallable searchTracesCallable(const Model::SearchTracesRequest& request) const;
SearchTraceCountOutcome searchTraceCount(const Model::SearchTraceCountRequest &request)const;
void searchTraceCountAsync(const Model::SearchTraceCountRequest& request, const SearchTraceCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchTraceCountOutcomeCallable searchTraceCountCallable(const Model::SearchTraceCountRequest& request) const;
GetTagKeyOutcome getTagKey(const Model::GetTagKeyRequest &request)const;
void getTagKeyAsync(const Model::GetTagKeyRequest& request, const GetTagKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTagKeyOutcomeCallable getTagKeyCallable(const Model::GetTagKeyRequest& request) const;
ARMSQueryDataSetOutcome aRMSQueryDataSet(const Model::ARMSQueryDataSetRequest &request)const;
void aRMSQueryDataSetAsync(const Model::ARMSQueryDataSetRequest& request, const ARMSQueryDataSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ARMSQueryDataSetOutcomeCallable aRMSQueryDataSetCallable(const Model::ARMSQueryDataSetRequest& request) const;
GetSpanNamesOutcome getSpanNames(const Model::GetSpanNamesRequest &request)const;
void getSpanNamesAsync(const Model::GetSpanNamesRequest& request, const GetSpanNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetSpanNamesOutcomeCallable getSpanNamesCallable(const Model::GetSpanNamesRequest& request) const;
GetServicesOutcome getServices(const Model::GetServicesRequest &request)const;
void getServicesAsync(const Model::GetServicesRequest& request, const GetServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetServicesOutcomeCallable getServicesCallable(const Model::GetServicesRequest& request) const;
MetricQueryOutcome metricQuery(const Model::MetricQueryRequest &request)const;
void metricQueryAsync(const Model::MetricQueryRequest& request, const MetricQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MetricQueryOutcomeCallable metricQueryCallable(const Model::MetricQueryRequest& request) const;
GetTagValOutcome getTagVal(const Model::GetTagValRequest &request)const;
void getTagValAsync(const Model::GetTagValRequest& request, const GetTagValAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTagValOutcomeCallable getTagValCallable(const Model::GetTagValRequest& request) const;
SearchAlertContactOutcome searchAlertContact(const Model::SearchAlertContactRequest &request)const;
void searchAlertContactAsync(const Model::SearchAlertContactRequest& request, const SearchAlertContactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchAlertContactOutcomeCallable searchAlertContactCallable(const Model::SearchAlertContactRequest& request) const;
ListTraceAppsOutcome listTraceApps(const Model::ListTraceAppsRequest &request)const;
void listTraceAppsAsync(const Model::ListTraceAppsRequest& request, const ListTraceAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTraceAppsOutcomeCallable listTraceAppsCallable(const Model::ListTraceAppsRequest& request) const;
DeleteRetcodeAppOutcome deleteRetcodeApp(const Model::DeleteRetcodeAppRequest &request)const;
void deleteRetcodeAppAsync(const Model::DeleteRetcodeAppRequest& request, const DeleteRetcodeAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteRetcodeAppOutcomeCallable deleteRetcodeAppCallable(const Model::DeleteRetcodeAppRequest& request) const;
SearchTraceAppByPageOutcome searchTraceAppByPage(const Model::SearchTraceAppByPageRequest &request)const;
void searchTraceAppByPageAsync(const Model::SearchTraceAppByPageRequest& request, const SearchTraceAppByPageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchTraceAppByPageOutcomeCallable searchTraceAppByPageCallable(const Model::SearchTraceAppByPageRequest& request) const;
ImportAppAlertRulesOutcome importAppAlertRules(const Model::ImportAppAlertRulesRequest &request)const;
void importAppAlertRulesAsync(const Model::ImportAppAlertRulesRequest& request, const ImportAppAlertRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImportAppAlertRulesOutcomeCallable importAppAlertRulesCallable(const Model::ImportAppAlertRulesRequest& request) const;
CreateAlertContactGroupOutcome createAlertContactGroup(const Model::CreateAlertContactGroupRequest &request)const;
void createAlertContactGroupAsync(const Model::CreateAlertContactGroupRequest& request, const CreateAlertContactGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAlertContactGroupOutcomeCallable createAlertContactGroupCallable(const Model::CreateAlertContactGroupRequest& request) const;
QueryDatasetOutcome queryDataset(const Model::QueryDatasetRequest &request)const;
void queryDatasetAsync(const Model::QueryDatasetRequest& request, const QueryDatasetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryDatasetOutcomeCallable queryDatasetCallable(const Model::QueryDatasetRequest& request) const;
SearchRetcodeAppByPageOutcome searchRetcodeAppByPage(const Model::SearchRetcodeAppByPageRequest &request)const;
void searchRetcodeAppByPageAsync(const Model::SearchRetcodeAppByPageRequest& request, const SearchRetcodeAppByPageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchRetcodeAppByPageOutcomeCallable searchRetcodeAppByPageCallable(const Model::SearchRetcodeAppByPageRequest& request) const;
SearchTraceAppByNameOutcome searchTraceAppByName(const Model::SearchTraceAppByNameRequest &request)const;
void searchTraceAppByNameAsync(const Model::SearchTraceAppByNameRequest& request, const SearchTraceAppByNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchTraceAppByNameOutcomeCallable searchTraceAppByNameCallable(const Model::SearchTraceAppByNameRequest& request) const;
ListRetcodeAppsOutcome listRetcodeApps(const Model::ListRetcodeAppsRequest &request)const;
void listRetcodeAppsAsync(const Model::ListRetcodeAppsRequest& request, const ListRetcodeAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListRetcodeAppsOutcomeCallable listRetcodeAppsCallable(const Model::ListRetcodeAppsRequest& request) const;
SearchAlertContactGroupOutcome searchAlertContactGroup(const Model::SearchAlertContactGroupRequest &request)const;
void searchAlertContactGroupAsync(const Model::SearchAlertContactGroupRequest& request, const SearchAlertContactGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchAlertContactGroupOutcomeCallable searchAlertContactGroupCallable(const Model::SearchAlertContactGroupRequest& request) const;
CreateAlertContactOutcome createAlertContact(const Model::CreateAlertContactRequest &request)const;
void createAlertContactAsync(const Model::CreateAlertContactRequest& request, const CreateAlertContactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAlertContactOutcomeCallable createAlertContactCallable(const Model::CreateAlertContactRequest& request) const;
QueryMetricOutcome queryMetric(const Model::QueryMetricRequest &request)const;
void queryMetricAsync(const Model::QueryMetricRequest& request, const QueryMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryMetricOutcomeCallable queryMetricCallable(const Model::QueryMetricRequest& request) const;
CreateRetcodeAppOutcome createRetcodeApp(const Model::CreateRetcodeAppRequest &request)const;
void createRetcodeAppAsync(const Model::CreateRetcodeAppRequest& request, const CreateRetcodeAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateRetcodeAppOutcomeCallable createRetcodeAppCallable(const Model::CreateRetcodeAppRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

54
arms/include/alibabacloud/arms/model/CreateAlertContactGroupRequest.h Normal file
View File

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

51
arms/include/alibabacloud/arms/model/CreateAlertContactGroupResult.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_ARMS_MODEL_CREATEALERTCONTACTGROUPRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_CREATEALERTCONTACTGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT CreateAlertContactGroupResult : public ServiceResult
{
public:
CreateAlertContactGroupResult();
explicit CreateAlertContactGroupResult(const std::string &payload);
~CreateAlertContactGroupResult();
std::string getContactGroupId()const;
protected:
void parse(const std::string &payload);
private:
std::string contactGroupId_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_CREATEALERTCONTACTGROUPRESULT_H_

63
arms/include/alibabacloud/arms/model/CreateAlertContactRequest.h 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.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_CREATEALERTCONTACTREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_CREATEALERTCONTACTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT CreateAlertContactRequest : public RpcServiceRequest
{
public:
CreateAlertContactRequest();
~CreateAlertContactRequest();
std::string getContactName()const;
void setContactName(const std::string& contactName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getPhoneNum()const;
void setPhoneNum(const std::string& phoneNum);
std::string getDingRobotWebhookUrl()const;
void setDingRobotWebhookUrl(const std::string& dingRobotWebhookUrl);
std::string getEmail()const;
void setEmail(const std::string& email);
bool getSystemNoc()const;
void setSystemNoc(bool systemNoc);
private:
std::string contactName_;
std::string regionId_;
std::string phoneNum_;
std::string dingRobotWebhookUrl_;
std::string email_;
bool systemNoc_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_CREATEALERTCONTACTREQUEST_H_

51
arms/include/alibabacloud/arms/model/CreateAlertContactResult.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_ARMS_MODEL_CREATEALERTCONTACTRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_CREATEALERTCONTACTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT CreateAlertContactResult : public ServiceResult
{
public:
CreateAlertContactResult();
explicit CreateAlertContactResult(const std::string &payload);
~CreateAlertContactResult();
std::string getContactId()const;
protected:
void parse(const std::string &payload);
private:
std::string contactId_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_CREATEALERTCONTACTRESULT_H_

54
arms/include/alibabacloud/arms/model/CreateRetcodeAppRequest.h Normal file
View File

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

56
arms/include/alibabacloud/arms/model/CreateRetcodeAppResult.h Normal file
View File

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

51
arms/include/alibabacloud/arms/model/DeleteRetcodeAppRequest.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_ARMS_MODEL_DELETERETCODEAPPREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_DELETERETCODEAPPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT DeleteRetcodeAppRequest : public RpcServiceRequest
{
public:
DeleteRetcodeAppRequest();
~DeleteRetcodeAppRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getAppId()const;
void setAppId(const std::string& appId);
private:
std::string regionId_;
std::string appId_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_DELETERETCODEAPPREQUEST_H_

51
arms/include/alibabacloud/arms/model/DeleteRetcodeAppResult.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_ARMS_MODEL_DELETERETCODEAPPRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_DELETERETCODEAPPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT DeleteRetcodeAppResult : public ServiceResult
{
public:
DeleteRetcodeAppResult();
explicit DeleteRetcodeAppResult(const std::string &payload);
~DeleteRetcodeAppResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_DELETERETCODEAPPRESULT_H_

60
arms/include/alibabacloud/arms/model/ImportAppAlertRulesRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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_ARMS_MODEL_IMPORTAPPALERTRULESREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_IMPORTAPPALERTRULESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT ImportAppAlertRulesRequest : public RpcServiceRequest
{
public:
ImportAppAlertRulesRequest();
~ImportAppAlertRulesRequest();
bool getIsAutoStart()const;
void setIsAutoStart(bool isAutoStart);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getContactGroupIds()const;
void setContactGroupIds(const std::string& contactGroupIds);
std::string getPids()const;
void setPids(const std::string& pids);
std::string getTemplateAlertId()const;
void setTemplateAlertId(const std::string& templateAlertId);
private:
bool isAutoStart_;
std::string regionId_;
std::string contactGroupIds_;
std::string pids_;
std::string templateAlertId_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_IMPORTAPPALERTRULESREQUEST_H_

51
arms/include/alibabacloud/arms/model/ImportAppAlertRulesResult.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_ARMS_MODEL_IMPORTAPPALERTRULESRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_IMPORTAPPALERTRULESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT ImportAppAlertRulesResult : public ServiceResult
{
public:
ImportAppAlertRulesResult();
explicit ImportAppAlertRulesResult(const std::string &payload);
~ImportAppAlertRulesResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_IMPORTAPPALERTRULESRESULT_H_

54
arms/include/alibabacloud/arms/model/ListRetcodeAppsRequest.h Normal file
View File

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

57
arms/include/alibabacloud/arms/model/ListRetcodeAppsResult.h Normal file
View File

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

48
arms/include/alibabacloud/arms/model/ListTraceAppsRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_ARMS_MODEL_LISTTRACEAPPSREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_LISTTRACEAPPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT ListTraceAppsRequest : public RpcServiceRequest
{
public:
ListTraceAppsRequest();
~ListTraceAppsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_LISTTRACEAPPSREQUEST_H_

68
arms/include/alibabacloud/arms/model/ListTraceAppsResult.h 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.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_LISTTRACEAPPSRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_LISTTRACEAPPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT ListTraceAppsResult : public ServiceResult
{
public:
struct TraceApp
{
std::string type;
long appId;
std::string userId;
long createTime;
long updateTime;
std::string pid;
std::string regionId;
std::string appName;
};
ListTraceAppsResult();
explicit ListTraceAppsResult(const std::string &payload);
~ListTraceAppsResult();
std::vector<TraceApp> getTraceApps()const;
std::string getMessage()const;
int getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::vector<TraceApp> traceApps_;
std::string message_;
int code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_LISTTRACEAPPSRESULT_H_

108
arms/include/alibabacloud/arms/model/QueryDatasetRequest.h Normal file
View File

@@ -0,0 +1,108 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_QUERYDATASETREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_QUERYDATASETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT QueryDatasetRequest : public RpcServiceRequest
{
struct OptionalDims
{
std::string type;
std::string value;
std::string key;
};
struct RequiredDims
{
std::string type;
std::string value;
std::string key;
};
struct Dimensions
{
std::string type;
std::string value;
std::string key;
};
public:
QueryDatasetRequest();
~QueryDatasetRequest();
std::string getDateStr()const;
void setDateStr(const std::string& dateStr);
long getMinTime()const;
void setMinTime(long minTime);
bool getReduceTail()const;
void setReduceTail(bool reduceTail);
long getMaxTime()const;
void setMaxTime(long maxTime);
std::vector<OptionalDims> getOptionalDims()const;
void setOptionalDims(const std::vector<OptionalDims>& optionalDims);
std::vector<std::string> getMeasures()const;
void setMeasures(const std::vector<std::string>& measures);
int getIntervalInSec()const;
void setIntervalInSec(int intervalInSec);
bool getIsDrillDown()const;
void setIsDrillDown(bool isDrillDown);
bool getHungryMode()const;
void setHungryMode(bool hungryMode);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOrderByKey()const;
void setOrderByKey(const std::string& orderByKey);
int getLimit()const;
void setLimit(int limit);
long getDatasetId()const;
void setDatasetId(long datasetId);
std::vector<RequiredDims> getRequiredDims()const;
void setRequiredDims(const std::vector<RequiredDims>& requiredDims);
std::vector<Dimensions> getDimensions()const;
void setDimensions(const std::vector<Dimensions>& dimensions);
private:
std::string dateStr_;
long minTime_;
bool reduceTail_;
long maxTime_;
std::vector<OptionalDims> optionalDims_;
std::vector<std::string> measures_;
int intervalInSec_;
bool isDrillDown_;
bool hungryMode_;
std::string regionId_;
std::string orderByKey_;
int limit_;
long datasetId_;
std::vector<RequiredDims> requiredDims_;
std::vector<Dimensions> dimensions_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_QUERYDATASETREQUEST_H_

51
arms/include/alibabacloud/arms/model/QueryDatasetResult.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_ARMS_MODEL_QUERYDATASETRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_QUERYDATASETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT QueryDatasetResult : public ServiceResult
{
public:
QueryDatasetResult();
explicit QueryDatasetResult(const std::string &payload);
~QueryDatasetResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_QUERYDATASETRESULT_H_

83
arms/include/alibabacloud/arms/model/QueryMetricRequest.h Normal file
View File

@@ -0,0 +1,83 @@
/*
* 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_ARMS_MODEL_QUERYMETRICREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_QUERYMETRICREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT QueryMetricRequest : public RpcServiceRequest
{
struct Filters
{
std::string value;
std::string key;
};
public:
QueryMetricRequest();
~QueryMetricRequest();
std::vector<std::string> getMeasures()const;
void setMeasures(const std::vector<std::string>& measures);
int getIntervalInSec()const;
void setIntervalInSec(int intervalInSec);
std::string getMetric()const;
void setMetric(const std::string& metric);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getLimit()const;
void setLimit(int limit);
long getEndTime()const;
void setEndTime(long endTime);
std::string getOrderBy()const;
void setOrderBy(const std::string& orderBy);
long getStartTime()const;
void setStartTime(long startTime);
std::vector<Filters> getFilters()const;
void setFilters(const std::vector<Filters>& filters);
std::vector<std::string> getDimensions()const;
void setDimensions(const std::vector<std::string>& dimensions);
std::string getOrder()const;
void setOrder(const std::string& order);
private:
std::vector<std::string> measures_;
int intervalInSec_;
std::string metric_;
std::string regionId_;
int limit_;
long endTime_;
std::string orderBy_;
long startTime_;
std::vector<Filters> filters_;
std::vector<std::string> dimensions_;
std::string order_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_QUERYMETRICREQUEST_H_

51
arms/include/alibabacloud/arms/model/QueryMetricResult.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_ARMS_MODEL_QUERYMETRICRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_QUERYMETRICRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT QueryMetricResult : public ServiceResult
{
public:
QueryMetricResult();
explicit QueryMetricResult(const std::string &payload);
~QueryMetricResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_QUERYMETRICRESULT_H_

51
arms/include/alibabacloud/arms/model/SearchAlertContactGroupRequest.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_ARMS_MODEL_SEARCHALERTCONTACTGROUPREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHALERTCONTACTGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT SearchAlertContactGroupRequest : public RpcServiceRequest
{
public:
SearchAlertContactGroupRequest();
~SearchAlertContactGroupRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getContactGroupName()const;
void setContactGroupName(const std::string& contactGroupName);
private:
std::string regionId_;
std::string contactGroupName_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHALERTCONTACTGROUPREQUEST_H_

59
arms/include/alibabacloud/arms/model/SearchAlertContactGroupResult.h Normal file
View File

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

63
arms/include/alibabacloud/arms/model/SearchAlertContactRequest.h 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.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_SEARCHALERTCONTACTREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHALERTCONTACTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT SearchAlertContactRequest : public RpcServiceRequest
{
public:
SearchAlertContactRequest();
~SearchAlertContactRequest();
std::string getContactName()const;
void setContactName(const std::string& contactName);
std::string getPhone()const;
void setPhone(const std::string& phone);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getPageSize()const;
void setPageSize(const std::string& pageSize);
std::string getCurrentPage()const;
void setCurrentPage(const std::string& currentPage);
std::string getEmail()const;
void setEmail(const std::string& email);
private:
std::string contactName_;
std::string phone_;
std::string regionId_;
std::string pageSize_;
std::string currentPage_;
std::string email_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHALERTCONTACTREQUEST_H_

70
arms/include/alibabacloud/arms/model/SearchAlertContactResult.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* 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_ARMS_MODEL_SEARCHALERTCONTACTRESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHALERTCONTACTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT SearchAlertContactResult : public ServiceResult
{
public:
struct PageBean
{
struct Contact
{
std::string email;
std::string phone;
std::string userId;
long createTime;
long updateTime;
long contactId;
std::string dingRobot;
std::string contactName;
bool systemNoc;
};
int totalCount;
std::vector<Contact> contacts;
int pageSize;
int pageNumber;
};
SearchAlertContactResult();
explicit SearchAlertContactResult(const std::string &payload);
~SearchAlertContactResult();
PageBean getPageBean()const;
protected:
void parse(const std::string &payload);
private:
PageBean pageBean_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHALERTCONTACTRESULT_H_

57
arms/include/alibabacloud/arms/model/SearchRetcodeAppByPageRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_SEARCHRETCODEAPPBYPAGEREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHRETCODEAPPBYPAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT SearchRetcodeAppByPageRequest : public RpcServiceRequest
{
public:
SearchRetcodeAppByPageRequest();
~SearchRetcodeAppByPageRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getRetcodeAppName()const;
void setRetcodeAppName(const std::string& retcodeAppName);
int getPageSize()const;
void setPageSize(int pageSize);
int getPageNumber()const;
void setPageNumber(int pageNumber);
private:
std::string regionId_;
std::string retcodeAppName_;
int pageSize_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHRETCODEAPPBYPAGEREQUEST_H_

69
arms/include/alibabacloud/arms/model/SearchRetcodeAppByPageResult.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_ARMS_MODEL_SEARCHRETCODEAPPBYPAGERESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHRETCODEAPPBYPAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT SearchRetcodeAppByPageResult : public ServiceResult
{
public:
struct PageBean
{
struct RetcodeApp
{
std::string type;
long appId;
std::string userId;
long createTime;
long updateTime;
std::string pid;
std::string regionId;
std::string appName;
};
int totalCount;
int pageSize;
int pageNumber;
std::vector<RetcodeApp> retcodeApps;
};
SearchRetcodeAppByPageResult();
explicit SearchRetcodeAppByPageResult(const std::string &payload);
~SearchRetcodeAppByPageResult();
PageBean getPageBean()const;
protected:
void parse(const std::string &payload);
private:
PageBean pageBean_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHRETCODEAPPBYPAGERESULT_H_

51
arms/include/alibabacloud/arms/model/SearchTraceAppByNameRequest.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_ARMS_MODEL_SEARCHTRACEAPPBYNAMEREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHTRACEAPPBYNAMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT SearchTraceAppByNameRequest : public RpcServiceRequest
{
public:
SearchTraceAppByNameRequest();
~SearchTraceAppByNameRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTraceAppName()const;
void setTraceAppName(const std::string& traceAppName);
private:
std::string regionId_;
std::string traceAppName_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHTRACEAPPBYNAMEREQUEST_H_

62
arms/include/alibabacloud/arms/model/SearchTraceAppByNameResult.h Normal file
View File

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

57
arms/include/alibabacloud/arms/model/SearchTraceAppByPageRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ARMS_MODEL_SEARCHTRACEAPPBYPAGEREQUEST_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHTRACEAPPBYPAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT SearchTraceAppByPageRequest : public RpcServiceRequest
{
public:
SearchTraceAppByPageRequest();
~SearchTraceAppByPageRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTraceAppName()const;
void setTraceAppName(const std::string& traceAppName);
int getPageSize()const;
void setPageSize(int pageSize);
int getPageNumber()const;
void setPageNumber(int pageNumber);
private:
std::string regionId_;
std::string traceAppName_;
int pageSize_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHTRACEAPPBYPAGEREQUEST_H_

69
arms/include/alibabacloud/arms/model/SearchTraceAppByPageResult.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_ARMS_MODEL_SEARCHTRACEAPPBYPAGERESULT_H_
#define ALIBABACLOUD_ARMS_MODEL_SEARCHTRACEAPPBYPAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/arms/ARMSExport.h>
namespace AlibabaCloud
{
namespace ARMS
{
namespace Model
{
class ALIBABACLOUD_ARMS_EXPORT SearchTraceAppByPageResult : public ServiceResult
{
public:
struct PageBean
{
struct TraceApp
{
std::string type;
long appId;
std::string userId;
long createTime;
long updateTime;
std::string pid;
std::string regionId;
std::string appName;
};
std::vector<TraceApp> traceApps;
int totalCount;
int pageSize;
int pageNumber;
};
SearchTraceAppByPageResult();
explicit SearchTraceAppByPageResult(const std::string &payload);
~SearchTraceAppByPageResult();
PageBean getPageBean()const;
protected:
void parse(const std::string &payload);
private:
PageBean pageBean_;
};
}
}
}
#endif // !ALIBABACLOUD_ARMS_MODEL_SEARCHTRACEAPPBYPAGERESULT_H_

348
arms/src/ARMSClient.cc
View File

@@ -31,344 +31,524 @@ ARMSClient::ARMSClient(const Credentials &credentials, const ClientConfiguration
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "arms");
}
ARMSClient::ARMSClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "arms");
}
ARMSClient::ARMSClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "arms");
}
ARMSClient::~ARMSClient()
{}
ARMSClient::GetTraceOutcome ARMSClient::getTrace(const GetTraceRequest &request) const
ARMSClient::SearchAlertContactOutcome ARMSClient::searchAlertContact(const SearchAlertContactRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetTraceOutcome(endpointOutcome.error());
return SearchAlertContactOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetTraceOutcome(GetTraceResult(outcome.result()));
return SearchAlertContactOutcome(SearchAlertContactResult(outcome.result()));
else
return GetTraceOutcome(outcome.error());
return SearchAlertContactOutcome(outcome.error());
}
void ARMSClient::getTraceAsync(const GetTraceRequest& request, const GetTraceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void ARMSClient::searchAlertContactAsync(const SearchAlertContactRequest& request, const SearchAlertContactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getTrace(request), context);
handler(this, request, searchAlertContact(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::GetTraceOutcomeCallable ARMSClient::getTraceCallable(const GetTraceRequest &request) const
ARMSClient::SearchAlertContactOutcomeCallable ARMSClient::searchAlertContactCallable(const SearchAlertContactRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetTraceOutcome()>>(
auto task = std::make_shared<std::packaged_task<SearchAlertContactOutcome()>>(
[this, request]()
{
return this->getTrace(request);
return this->searchAlertContact(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::SearchTracesOutcome ARMSClient::searchTraces(const SearchTracesRequest &request) const
ARMSClient::ListTraceAppsOutcome ARMSClient::listTraceApps(const ListTraceAppsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SearchTracesOutcome(endpointOutcome.error());
return ListTraceAppsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SearchTracesOutcome(SearchTracesResult(outcome.result()));
return ListTraceAppsOutcome(ListTraceAppsResult(outcome.result()));
else
return SearchTracesOutcome(outcome.error());
return ListTraceAppsOutcome(outcome.error());
}
void ARMSClient::searchTracesAsync(const SearchTracesRequest& request, const SearchTracesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void ARMSClient::listTraceAppsAsync(const ListTraceAppsRequest& request, const ListTraceAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, searchTraces(request), context);
handler(this, request, listTraceApps(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::SearchTracesOutcomeCallable ARMSClient::searchTracesCallable(const SearchTracesRequest &request) const
ARMSClient::ListTraceAppsOutcomeCallable ARMSClient::listTraceAppsCallable(const ListTraceAppsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SearchTracesOutcome()>>(
auto task = std::make_shared<std::packaged_task<ListTraceAppsOutcome()>>(
[this, request]()
{
return this->searchTraces(request);
return this->listTraceApps(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::SearchTraceCountOutcome ARMSClient::searchTraceCount(const SearchTraceCountRequest &request) const
ARMSClient::DeleteRetcodeAppOutcome ARMSClient::deleteRetcodeApp(const DeleteRetcodeAppRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SearchTraceCountOutcome(endpointOutcome.error());
return DeleteRetcodeAppOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SearchTraceCountOutcome(SearchTraceCountResult(outcome.result()));
return DeleteRetcodeAppOutcome(DeleteRetcodeAppResult(outcome.result()));
else
return SearchTraceCountOutcome(outcome.error());
return DeleteRetcodeAppOutcome(outcome.error());
}
void ARMSClient::searchTraceCountAsync(const SearchTraceCountRequest& request, const SearchTraceCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void ARMSClient::deleteRetcodeAppAsync(const DeleteRetcodeAppRequest& request, const DeleteRetcodeAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, searchTraceCount(request), context);
handler(this, request, deleteRetcodeApp(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::SearchTraceCountOutcomeCallable ARMSClient::searchTraceCountCallable(const SearchTraceCountRequest &request) const
ARMSClient::DeleteRetcodeAppOutcomeCallable ARMSClient::deleteRetcodeAppCallable(const DeleteRetcodeAppRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SearchTraceCountOutcome()>>(
auto task = std::make_shared<std::packaged_task<DeleteRetcodeAppOutcome()>>(
[this, request]()
{
return this->searchTraceCount(request);
return this->deleteRetcodeApp(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::GetTagKeyOutcome ARMSClient::getTagKey(const GetTagKeyRequest &request) const
ARMSClient::SearchTraceAppByPageOutcome ARMSClient::searchTraceAppByPage(const SearchTraceAppByPageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetTagKeyOutcome(endpointOutcome.error());
return SearchTraceAppByPageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetTagKeyOutcome(GetTagKeyResult(outcome.result()));
return SearchTraceAppByPageOutcome(SearchTraceAppByPageResult(outcome.result()));
else
return GetTagKeyOutcome(outcome.error());
return SearchTraceAppByPageOutcome(outcome.error());
}
void ARMSClient::getTagKeyAsync(const GetTagKeyRequest& request, const GetTagKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void ARMSClient::searchTraceAppByPageAsync(const SearchTraceAppByPageRequest& request, const SearchTraceAppByPageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getTagKey(request), context);
handler(this, request, searchTraceAppByPage(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::GetTagKeyOutcomeCallable ARMSClient::getTagKeyCallable(const GetTagKeyRequest &request) const
ARMSClient::SearchTraceAppByPageOutcomeCallable ARMSClient::searchTraceAppByPageCallable(const SearchTraceAppByPageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetTagKeyOutcome()>>(
auto task = std::make_shared<std::packaged_task<SearchTraceAppByPageOutcome()>>(
[this, request]()
{
return this->getTagKey(request);
return this->searchTraceAppByPage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::ARMSQueryDataSetOutcome ARMSClient::aRMSQueryDataSet(const ARMSQueryDataSetRequest &request) const
ARMSClient::ImportAppAlertRulesOutcome ARMSClient::importAppAlertRules(const ImportAppAlertRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ARMSQueryDataSetOutcome(endpointOutcome.error());
return ImportAppAlertRulesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ARMSQueryDataSetOutcome(ARMSQueryDataSetResult(outcome.result()));
return ImportAppAlertRulesOutcome(ImportAppAlertRulesResult(outcome.result()));
else
return ARMSQueryDataSetOutcome(outcome.error());
return ImportAppAlertRulesOutcome(outcome.error());
}
void ARMSClient::aRMSQueryDataSetAsync(const ARMSQueryDataSetRequest& request, const ARMSQueryDataSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void ARMSClient::importAppAlertRulesAsync(const ImportAppAlertRulesRequest& request, const ImportAppAlertRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, aRMSQueryDataSet(request), context);
handler(this, request, importAppAlertRules(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::ARMSQueryDataSetOutcomeCallable ARMSClient::aRMSQueryDataSetCallable(const ARMSQueryDataSetRequest &request) const
ARMSClient::ImportAppAlertRulesOutcomeCallable ARMSClient::importAppAlertRulesCallable(const ImportAppAlertRulesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ARMSQueryDataSetOutcome()>>(
auto task = std::make_shared<std::packaged_task<ImportAppAlertRulesOutcome()>>(
[this, request]()
{
return this->aRMSQueryDataSet(request);
return this->importAppAlertRules(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::GetSpanNamesOutcome ARMSClient::getSpanNames(const GetSpanNamesRequest &request) const
ARMSClient::CreateAlertContactGroupOutcome ARMSClient::createAlertContactGroup(const CreateAlertContactGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetSpanNamesOutcome(endpointOutcome.error());
return CreateAlertContactGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetSpanNamesOutcome(GetSpanNamesResult(outcome.result()));
return CreateAlertContactGroupOutcome(CreateAlertContactGroupResult(outcome.result()));
else
return GetSpanNamesOutcome(outcome.error());
return CreateAlertContactGroupOutcome(outcome.error());
}
void ARMSClient::getSpanNamesAsync(const GetSpanNamesRequest& request, const GetSpanNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void ARMSClient::createAlertContactGroupAsync(const CreateAlertContactGroupRequest& request, const CreateAlertContactGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getSpanNames(request), context);
handler(this, request, createAlertContactGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::GetSpanNamesOutcomeCallable ARMSClient::getSpanNamesCallable(const GetSpanNamesRequest &request) const
ARMSClient::CreateAlertContactGroupOutcomeCallable ARMSClient::createAlertContactGroupCallable(const CreateAlertContactGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetSpanNamesOutcome()>>(
auto task = std::make_shared<std::packaged_task<CreateAlertContactGroupOutcome()>>(
[this, request]()
{
return this->getSpanNames(request);
return this->createAlertContactGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::GetServicesOutcome ARMSClient::getServices(const GetServicesRequest &request) const
ARMSClient::QueryDatasetOutcome ARMSClient::queryDataset(const QueryDatasetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetServicesOutcome(endpointOutcome.error());
return QueryDatasetOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetServicesOutcome(GetServicesResult(outcome.result()));
return QueryDatasetOutcome(QueryDatasetResult(outcome.result()));
else
return GetServicesOutcome(outcome.error());
return QueryDatasetOutcome(outcome.error());
}
void ARMSClient::getServicesAsync(const GetServicesRequest& request, const GetServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void ARMSClient::queryDatasetAsync(const QueryDatasetRequest& request, const QueryDatasetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getServices(request), context);
handler(this, request, queryDataset(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::GetServicesOutcomeCallable ARMSClient::getServicesCallable(const GetServicesRequest &request) const
ARMSClient::QueryDatasetOutcomeCallable ARMSClient::queryDatasetCallable(const QueryDatasetRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetServicesOutcome()>>(
auto task = std::make_shared<std::packaged_task<QueryDatasetOutcome()>>(
[this, request]()
{
return this->getServices(request);
return this->queryDataset(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::MetricQueryOutcome ARMSClient::metricQuery(const MetricQueryRequest &request) const
ARMSClient::SearchRetcodeAppByPageOutcome ARMSClient::searchRetcodeAppByPage(const SearchRetcodeAppByPageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MetricQueryOutcome(endpointOutcome.error());
return SearchRetcodeAppByPageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MetricQueryOutcome(MetricQueryResult(outcome.result()));
return SearchRetcodeAppByPageOutcome(SearchRetcodeAppByPageResult(outcome.result()));
else
return MetricQueryOutcome(outcome.error());
return SearchRetcodeAppByPageOutcome(outcome.error());
}
void ARMSClient::metricQueryAsync(const MetricQueryRequest& request, const MetricQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void ARMSClient::searchRetcodeAppByPageAsync(const SearchRetcodeAppByPageRequest& request, const SearchRetcodeAppByPageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, metricQuery(request), context);
handler(this, request, searchRetcodeAppByPage(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::MetricQueryOutcomeCallable ARMSClient::metricQueryCallable(const MetricQueryRequest &request) const
ARMSClient::SearchRetcodeAppByPageOutcomeCallable ARMSClient::searchRetcodeAppByPageCallable(const SearchRetcodeAppByPageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MetricQueryOutcome()>>(
auto task = std::make_shared<std::packaged_task<SearchRetcodeAppByPageOutcome()>>(
[this, request]()
{
return this->metricQuery(request);
return this->searchRetcodeAppByPage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::GetTagValOutcome ARMSClient::getTagVal(const GetTagValRequest &request) const
ARMSClient::SearchTraceAppByNameOutcome ARMSClient::searchTraceAppByName(const SearchTraceAppByNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetTagValOutcome(endpointOutcome.error());
return SearchTraceAppByNameOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetTagValOutcome(GetTagValResult(outcome.result()));
return SearchTraceAppByNameOutcome(SearchTraceAppByNameResult(outcome.result()));
else
return GetTagValOutcome(outcome.error());
return SearchTraceAppByNameOutcome(outcome.error());
}
void ARMSClient::getTagValAsync(const GetTagValRequest& request, const GetTagValAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void ARMSClient::searchTraceAppByNameAsync(const SearchTraceAppByNameRequest& request, const SearchTraceAppByNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getTagVal(request), context);
handler(this, request, searchTraceAppByName(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::GetTagValOutcomeCallable ARMSClient::getTagValCallable(const GetTagValRequest &request) const
ARMSClient::SearchTraceAppByNameOutcomeCallable ARMSClient::searchTraceAppByNameCallable(const SearchTraceAppByNameRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetTagValOutcome()>>(
auto task = std::make_shared<std::packaged_task<SearchTraceAppByNameOutcome()>>(
[this, request]()
{
return this->getTagVal(request);
return this->searchTraceAppByName(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::ListRetcodeAppsOutcome ARMSClient::listRetcodeApps(const ListRetcodeAppsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListRetcodeAppsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListRetcodeAppsOutcome(ListRetcodeAppsResult(outcome.result()));
else
return ListRetcodeAppsOutcome(outcome.error());
}
void ARMSClient::listRetcodeAppsAsync(const ListRetcodeAppsRequest& request, const ListRetcodeAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listRetcodeApps(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::ListRetcodeAppsOutcomeCallable ARMSClient::listRetcodeAppsCallable(const ListRetcodeAppsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListRetcodeAppsOutcome()>>(
[this, request]()
{
return this->listRetcodeApps(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::SearchAlertContactGroupOutcome ARMSClient::searchAlertContactGroup(const SearchAlertContactGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SearchAlertContactGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SearchAlertContactGroupOutcome(SearchAlertContactGroupResult(outcome.result()));
else
return SearchAlertContactGroupOutcome(outcome.error());
}
void ARMSClient::searchAlertContactGroupAsync(const SearchAlertContactGroupRequest& request, const SearchAlertContactGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, searchAlertContactGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::SearchAlertContactGroupOutcomeCallable ARMSClient::searchAlertContactGroupCallable(const SearchAlertContactGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SearchAlertContactGroupOutcome()>>(
[this, request]()
{
return this->searchAlertContactGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::CreateAlertContactOutcome ARMSClient::createAlertContact(const CreateAlertContactRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateAlertContactOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateAlertContactOutcome(CreateAlertContactResult(outcome.result()));
else
return CreateAlertContactOutcome(outcome.error());
}
void ARMSClient::createAlertContactAsync(const CreateAlertContactRequest& request, const CreateAlertContactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createAlertContact(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::CreateAlertContactOutcomeCallable ARMSClient::createAlertContactCallable(const CreateAlertContactRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateAlertContactOutcome()>>(
[this, request]()
{
return this->createAlertContact(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::QueryMetricOutcome ARMSClient::queryMetric(const QueryMetricRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryMetricOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryMetricOutcome(QueryMetricResult(outcome.result()));
else
return QueryMetricOutcome(outcome.error());
}
void ARMSClient::queryMetricAsync(const QueryMetricRequest& request, const QueryMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryMetric(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::QueryMetricOutcomeCallable ARMSClient::queryMetricCallable(const QueryMetricRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryMetricOutcome()>>(
[this, request]()
{
return this->queryMetric(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ARMSClient::CreateRetcodeAppOutcome ARMSClient::createRetcodeApp(const CreateRetcodeAppRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateRetcodeAppOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateRetcodeAppOutcome(CreateRetcodeAppResult(outcome.result()));
else
return CreateRetcodeAppOutcome(outcome.error());
}
void ARMSClient::createRetcodeAppAsync(const CreateRetcodeAppRequest& request, const CreateRetcodeAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createRetcodeApp(request), context);
};
asyncExecute(new Runnable(fn));
}
ARMSClient::CreateRetcodeAppOutcomeCallable ARMSClient::createRetcodeAppCallable(const CreateRetcodeAppRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateRetcodeAppOutcome()>>(
[this, request]()
{
return this->createRetcodeApp(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));

60
arms/src/model/CreateAlertContactGroupRequest.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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/arms/model/CreateAlertContactGroupRequest.h>
using AlibabaCloud::ARMS::Model::CreateAlertContactGroupRequest;
CreateAlertContactGroupRequest::CreateAlertContactGroupRequest() :
RpcServiceRequest("arms", "2019-08-08", "CreateAlertContactGroup")
{}
CreateAlertContactGroupRequest::~CreateAlertContactGroupRequest()
{}
std::string CreateAlertContactGroupRequest::getRegionId()const
{
return regionId_;
}
void CreateAlertContactGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string CreateAlertContactGroupRequest::getContactGroupName()const
{
return contactGroupName_;
}
void CreateAlertContactGroupRequest::setContactGroupName(const std::string& contactGroupName)
{
contactGroupName_ = contactGroupName;
setCoreParameter("ContactGroupName", contactGroupName);
}
std::string CreateAlertContactGroupRequest::getContactIds()const
{
return contactIds_;
}
void CreateAlertContactGroupRequest::setContactIds(const std::string& contactIds)
{
contactIds_ = contactIds;
setCoreParameter("ContactIds", contactIds);
}

52
arms/src/model/CreateAlertContactGroupResult.cc Normal file
View File

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

93
arms/src/model/CreateAlertContactRequest.cc Normal file
View File

@@ -0,0 +1,93 @@
/*
* 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/arms/model/CreateAlertContactRequest.h>
using AlibabaCloud::ARMS::Model::CreateAlertContactRequest;
CreateAlertContactRequest::CreateAlertContactRequest() :
RpcServiceRequest("arms", "2019-08-08", "CreateAlertContact")
{}
CreateAlertContactRequest::~CreateAlertContactRequest()
{}
std::string CreateAlertContactRequest::getContactName()const
{
return contactName_;
}
void CreateAlertContactRequest::setContactName(const std::string& contactName)
{
contactName_ = contactName;
setCoreParameter("ContactName", contactName);
}
std::string CreateAlertContactRequest::getRegionId()const
{
return regionId_;
}
void CreateAlertContactRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string CreateAlertContactRequest::getPhoneNum()const
{
return phoneNum_;
}
void CreateAlertContactRequest::setPhoneNum(const std::string& phoneNum)
{
phoneNum_ = phoneNum;
setCoreParameter("PhoneNum", phoneNum);
}
std::string CreateAlertContactRequest::getDingRobotWebhookUrl()const
{
return dingRobotWebhookUrl_;
}
void CreateAlertContactRequest::setDingRobotWebhookUrl(const std::string& dingRobotWebhookUrl)
{
dingRobotWebhookUrl_ = dingRobotWebhookUrl;
setCoreParameter("DingRobotWebhookUrl", dingRobotWebhookUrl);
}
std::string CreateAlertContactRequest::getEmail()const
{
return email_;
}
void CreateAlertContactRequest::setEmail(const std::string& email)
{
email_ = email;
setCoreParameter("Email", email);
}
bool CreateAlertContactRequest::getSystemNoc()const
{
return systemNoc_;
}
void CreateAlertContactRequest::setSystemNoc(bool systemNoc)
{
systemNoc_ = systemNoc;
setCoreParameter("SystemNoc", systemNoc ? "true" : "false");
}

52
arms/src/model/CreateAlertContactResult.cc Normal file
View File

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

60
arms/src/model/CreateRetcodeAppRequest.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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/arms/model/CreateRetcodeAppRequest.h>
using AlibabaCloud::ARMS::Model::CreateRetcodeAppRequest;
CreateRetcodeAppRequest::CreateRetcodeAppRequest() :
RpcServiceRequest("arms", "2019-08-08", "CreateRetcodeApp")
{}
CreateRetcodeAppRequest::~CreateRetcodeAppRequest()
{}
std::string CreateRetcodeAppRequest::getRegionId()const
{
return regionId_;
}
void CreateRetcodeAppRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string CreateRetcodeAppRequest::getRetcodeAppName()const
{
return retcodeAppName_;
}
void CreateRetcodeAppRequest::setRetcodeAppName(const std::string& retcodeAppName)
{
retcodeAppName_ = retcodeAppName;
setCoreParameter("RetcodeAppName", retcodeAppName);
}
std::string CreateRetcodeAppRequest::getRetcodeAppType()const
{
return retcodeAppType_;
}
void CreateRetcodeAppRequest::setRetcodeAppType(const std::string& retcodeAppType)
{
retcodeAppType_ = retcodeAppType;
setCoreParameter("RetcodeAppType", retcodeAppType);
}

55
arms/src/model/CreateRetcodeAppResult.cc Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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/arms/model/CreateRetcodeAppResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
CreateRetcodeAppResult::CreateRetcodeAppResult() :
ServiceResult()
{}
CreateRetcodeAppResult::CreateRetcodeAppResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateRetcodeAppResult::~CreateRetcodeAppResult()
{}
void CreateRetcodeAppResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto retcodeAppDataBeanNode = value["RetcodeAppDataBean"];
if(!retcodeAppDataBeanNode["AppId"].isNull())
retcodeAppDataBean_.appId = std::stol(retcodeAppDataBeanNode["AppId"].asString());
if(!retcodeAppDataBeanNode["Pid"].isNull())
retcodeAppDataBean_.pid = retcodeAppDataBeanNode["Pid"].asString();
}
CreateRetcodeAppResult::RetcodeAppDataBean CreateRetcodeAppResult::getRetcodeAppDataBean()const
{
return retcodeAppDataBean_;
}

49
arms/src/model/DeleteRetcodeAppRequest.cc Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/DeleteRetcodeAppRequest.h>
using AlibabaCloud::ARMS::Model::DeleteRetcodeAppRequest;
DeleteRetcodeAppRequest::DeleteRetcodeAppRequest() :
RpcServiceRequest("arms", "2019-08-08", "DeleteRetcodeApp")
{}
DeleteRetcodeAppRequest::~DeleteRetcodeAppRequest()
{}
std::string DeleteRetcodeAppRequest::getRegionId()const
{
return regionId_;
}
void DeleteRetcodeAppRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DeleteRetcodeAppRequest::getAppId()const
{
return appId_;
}
void DeleteRetcodeAppRequest::setAppId(const std::string& appId)
{
appId_ = appId;
setCoreParameter("AppId", appId);
}

52
arms/src/model/DeleteRetcodeAppResult.cc Normal file
View File

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

82
arms/src/model/ImportAppAlertRulesRequest.cc 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.
*/
#include <alibabacloud/arms/model/ImportAppAlertRulesRequest.h>
using AlibabaCloud::ARMS::Model::ImportAppAlertRulesRequest;
ImportAppAlertRulesRequest::ImportAppAlertRulesRequest() :
RpcServiceRequest("arms", "2019-08-08", "ImportAppAlertRules")
{}
ImportAppAlertRulesRequest::~ImportAppAlertRulesRequest()
{}
bool ImportAppAlertRulesRequest::getIsAutoStart()const
{
return isAutoStart_;
}
void ImportAppAlertRulesRequest::setIsAutoStart(bool isAutoStart)
{
isAutoStart_ = isAutoStart;
setCoreParameter("IsAutoStart", isAutoStart ? "true" : "false");
}
std::string ImportAppAlertRulesRequest::getRegionId()const
{
return regionId_;
}
void ImportAppAlertRulesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ImportAppAlertRulesRequest::getContactGroupIds()const
{
return contactGroupIds_;
}
void ImportAppAlertRulesRequest::setContactGroupIds(const std::string& contactGroupIds)
{
contactGroupIds_ = contactGroupIds;
setCoreParameter("ContactGroupIds", contactGroupIds);
}
std::string ImportAppAlertRulesRequest::getPids()const
{
return pids_;
}
void ImportAppAlertRulesRequest::setPids(const std::string& pids)
{
pids_ = pids;
setCoreParameter("Pids", pids);
}
std::string ImportAppAlertRulesRequest::getTemplateAlertId()const
{
return templateAlertId_;
}
void ImportAppAlertRulesRequest::setTemplateAlertId(const std::string& templateAlertId)
{
templateAlertId_ = templateAlertId;
setCoreParameter("TemplateAlertId", templateAlertId);
}

52
arms/src/model/ImportAppAlertRulesResult.cc Normal file
View File

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

60
arms/src/model/ListRetcodeAppsRequest.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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/arms/model/ListRetcodeAppsRequest.h>
using AlibabaCloud::ARMS::Model::ListRetcodeAppsRequest;
ListRetcodeAppsRequest::ListRetcodeAppsRequest() :
RpcServiceRequest("arms", "2019-08-08", "ListRetcodeApps")
{}
ListRetcodeAppsRequest::~ListRetcodeAppsRequest()
{}
std::string ListRetcodeAppsRequest::getSecurityToken()const
{
return securityToken_;
}
void ListRetcodeAppsRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setCoreParameter("SecurityToken", securityToken);
}
std::string ListRetcodeAppsRequest::getRegionId()const
{
return regionId_;
}
void ListRetcodeAppsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ListRetcodeAppsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ListRetcodeAppsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}

62
arms/src/model/ListRetcodeAppsResult.cc Normal file
View File

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

38
arms/src/model/ListTraceAppsRequest.cc Normal file
View File

@@ -0,0 +1,38 @@
/*
* 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/arms/model/ListTraceAppsRequest.h>
using AlibabaCloud::ARMS::Model::ListTraceAppsRequest;
ListTraceAppsRequest::ListTraceAppsRequest() :
RpcServiceRequest("arms", "2019-08-08", "ListTraceApps")
{}
ListTraceAppsRequest::~ListTraceAppsRequest()
{}
std::string ListTraceAppsRequest::getRegionId()const
{
return regionId_;
}
void ListTraceAppsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}

93
arms/src/model/ListTraceAppsResult.cc Normal file
View File

@@ -0,0 +1,93 @@
/*
* 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/arms/model/ListTraceAppsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
ListTraceAppsResult::ListTraceAppsResult() :
ServiceResult()
{}
ListTraceAppsResult::ListTraceAppsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListTraceAppsResult::~ListTraceAppsResult()
{}
void ListTraceAppsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTraceApps = value["TraceApps"]["TraceApp"];
for (auto value : allTraceApps)
{
TraceApp traceAppsObject;
if(!value["AppId"].isNull())
traceAppsObject.appId = std::stol(value["AppId"].asString());
if(!value["Pid"].isNull())
traceAppsObject.pid = value["Pid"].asString();
if(!value["AppName"].isNull())
traceAppsObject.appName = value["AppName"].asString();
if(!value["Type"].isNull())
traceAppsObject.type = value["Type"].asString();
if(!value["UserId"].isNull())
traceAppsObject.userId = value["UserId"].asString();
if(!value["CreateTime"].isNull())
traceAppsObject.createTime = std::stol(value["CreateTime"].asString());
if(!value["UpdateTime"].isNull())
traceAppsObject.updateTime = std::stol(value["UpdateTime"].asString());
if(!value["RegionId"].isNull())
traceAppsObject.regionId = value["RegionId"].asString();
traceApps_.push_back(traceAppsObject);
}
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::vector<ListTraceAppsResult::TraceApp> ListTraceAppsResult::getTraceApps()const
{
return traceApps_;
}
std::string ListTraceAppsResult::getMessage()const
{
return message_;
}
int ListTraceAppsResult::getCode()const
{
return code_;
}
bool ListTraceAppsResult::getSuccess()const
{
return success_;
}

214
arms/src/model/QueryDatasetRequest.cc Normal file
View File

@@ -0,0 +1,214 @@
/*
* 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/arms/model/QueryDatasetRequest.h>
using AlibabaCloud::ARMS::Model::QueryDatasetRequest;
QueryDatasetRequest::QueryDatasetRequest() :
RpcServiceRequest("arms", "2019-08-08", "QueryDataset")
{}
QueryDatasetRequest::~QueryDatasetRequest()
{}
std::string QueryDatasetRequest::getDateStr()const
{
return dateStr_;
}
void QueryDatasetRequest::setDateStr(const std::string& dateStr)
{
dateStr_ = dateStr;
setCoreParameter("DateStr", dateStr);
}
long QueryDatasetRequest::getMinTime()const
{
return minTime_;
}
void QueryDatasetRequest::setMinTime(long minTime)
{
minTime_ = minTime;
setCoreParameter("MinTime", std::to_string(minTime));
}
bool QueryDatasetRequest::getReduceTail()const
{
return reduceTail_;
}
void QueryDatasetRequest::setReduceTail(bool reduceTail)
{
reduceTail_ = reduceTail;
setCoreParameter("ReduceTail", reduceTail ? "true" : "false");
}
long QueryDatasetRequest::getMaxTime()const
{
return maxTime_;
}
void QueryDatasetRequest::setMaxTime(long maxTime)
{
maxTime_ = maxTime;
setCoreParameter("MaxTime", std::to_string(maxTime));
}
std::vector<QueryDatasetRequest::OptionalDims> QueryDatasetRequest::getOptionalDims()const
{
return optionalDims_;
}
void QueryDatasetRequest::setOptionalDims(const std::vector<OptionalDims>& optionalDims)
{
optionalDims_ = optionalDims;
int i = 0;
for(int i = 0; i!= optionalDims.size(); i++) {
auto obj = optionalDims.at(i);
std::string str ="OptionalDims."+ std::to_string(i);
setCoreParameter(str + ".Type", obj.type);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}
std::vector<std::string> QueryDatasetRequest::getMeasures()const
{
return measures_;
}
void QueryDatasetRequest::setMeasures(const std::vector<std::string>& measures)
{
measures_ = measures;
for(int i = 0; i!= measures.size(); i++)
setCoreParameter("Measures."+ std::to_string(i), measures.at(i));
}
int QueryDatasetRequest::getIntervalInSec()const
{
return intervalInSec_;
}
void QueryDatasetRequest::setIntervalInSec(int intervalInSec)
{
intervalInSec_ = intervalInSec;
setCoreParameter("IntervalInSec", std::to_string(intervalInSec));
}
bool QueryDatasetRequest::getIsDrillDown()const
{
return isDrillDown_;
}
void QueryDatasetRequest::setIsDrillDown(bool isDrillDown)
{
isDrillDown_ = isDrillDown;
setCoreParameter("IsDrillDown", isDrillDown ? "true" : "false");
}
bool QueryDatasetRequest::getHungryMode()const
{
return hungryMode_;
}
void QueryDatasetRequest::setHungryMode(bool hungryMode)
{
hungryMode_ = hungryMode;
setCoreParameter("HungryMode", hungryMode ? "true" : "false");
}
std::string QueryDatasetRequest::getRegionId()const
{
return regionId_;
}
void QueryDatasetRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string QueryDatasetRequest::getOrderByKey()const
{
return orderByKey_;
}
void QueryDatasetRequest::setOrderByKey(const std::string& orderByKey)
{
orderByKey_ = orderByKey;
setCoreParameter("OrderByKey", orderByKey);
}
int QueryDatasetRequest::getLimit()const
{
return limit_;
}
void QueryDatasetRequest::setLimit(int limit)
{
limit_ = limit;
setCoreParameter("Limit", std::to_string(limit));
}
long QueryDatasetRequest::getDatasetId()const
{
return datasetId_;
}
void QueryDatasetRequest::setDatasetId(long datasetId)
{
datasetId_ = datasetId;
setCoreParameter("DatasetId", std::to_string(datasetId));
}
std::vector<QueryDatasetRequest::RequiredDims> QueryDatasetRequest::getRequiredDims()const
{
return requiredDims_;
}
void QueryDatasetRequest::setRequiredDims(const std::vector<RequiredDims>& requiredDims)
{
requiredDims_ = requiredDims;
int i = 0;
for(int i = 0; i!= requiredDims.size(); i++) {
auto obj = requiredDims.at(i);
std::string str ="RequiredDims."+ std::to_string(i);
setCoreParameter(str + ".Type", obj.type);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}
std::vector<QueryDatasetRequest::Dimensions> QueryDatasetRequest::getDimensions()const
{
return dimensions_;
}
void QueryDatasetRequest::setDimensions(const std::vector<Dimensions>& dimensions)
{
dimensions_ = dimensions;
int i = 0;
for(int i = 0; i!= dimensions.size(); i++) {
auto obj = dimensions.at(i);
std::string str ="Dimensions."+ std::to_string(i);
setCoreParameter(str + ".Type", obj.type);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}

52
arms/src/model/QueryDatasetResult.cc Normal file
View File

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

156
arms/src/model/QueryMetricRequest.cc Normal file
View File

@@ -0,0 +1,156 @@
/*
* 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/arms/model/QueryMetricRequest.h>
using AlibabaCloud::ARMS::Model::QueryMetricRequest;
QueryMetricRequest::QueryMetricRequest() :
RpcServiceRequest("arms", "2019-08-08", "QueryMetric")
{}
QueryMetricRequest::~QueryMetricRequest()
{}
std::vector<std::string> QueryMetricRequest::getMeasures()const
{
return measures_;
}
void QueryMetricRequest::setMeasures(const std::vector<std::string>& measures)
{
measures_ = measures;
for(int i = 0; i!= measures.size(); i++)
setCoreParameter("Measures."+ std::to_string(i), measures.at(i));
}
int QueryMetricRequest::getIntervalInSec()const
{
return intervalInSec_;
}
void QueryMetricRequest::setIntervalInSec(int intervalInSec)
{
intervalInSec_ = intervalInSec;
setCoreParameter("IntervalInSec", std::to_string(intervalInSec));
}
std::string QueryMetricRequest::getMetric()const
{
return metric_;
}
void QueryMetricRequest::setMetric(const std::string& metric)
{
metric_ = metric;
setCoreParameter("Metric", metric);
}
std::string QueryMetricRequest::getRegionId()const
{
return regionId_;
}
void QueryMetricRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
int QueryMetricRequest::getLimit()const
{
return limit_;
}
void QueryMetricRequest::setLimit(int limit)
{
limit_ = limit;
setCoreParameter("Limit", std::to_string(limit));
}
long QueryMetricRequest::getEndTime()const
{
return endTime_;
}
void QueryMetricRequest::setEndTime(long endTime)
{
endTime_ = endTime;
setCoreParameter("EndTime", std::to_string(endTime));
}
std::string QueryMetricRequest::getOrderBy()const
{
return orderBy_;
}
void QueryMetricRequest::setOrderBy(const std::string& orderBy)
{
orderBy_ = orderBy;
setCoreParameter("OrderBy", orderBy);
}
long QueryMetricRequest::getStartTime()const
{
return startTime_;
}
void QueryMetricRequest::setStartTime(long startTime)
{
startTime_ = startTime;
setCoreParameter("StartTime", std::to_string(startTime));
}
std::vector<QueryMetricRequest::Filters> QueryMetricRequest::getFilters()const
{
return filters_;
}
void QueryMetricRequest::setFilters(const std::vector<Filters>& filters)
{
filters_ = filters;
int i = 0;
for(int i = 0; i!= filters.size(); i++) {
auto obj = filters.at(i);
std::string str ="Filters."+ std::to_string(i);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}
std::vector<std::string> QueryMetricRequest::getDimensions()const
{
return dimensions_;
}
void QueryMetricRequest::setDimensions(const std::vector<std::string>& dimensions)
{
dimensions_ = dimensions;
for(int i = 0; i!= dimensions.size(); i++)
setCoreParameter("Dimensions."+ std::to_string(i), dimensions.at(i));
}
std::string QueryMetricRequest::getOrder()const
{
return order_;
}
void QueryMetricRequest::setOrder(const std::string& order)
{
order_ = order;
setCoreParameter("Order", order);
}

52
arms/src/model/QueryMetricResult.cc Normal file
View File

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

49
arms/src/model/SearchAlertContactGroupRequest.cc Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/SearchAlertContactGroupRequest.h>
using AlibabaCloud::ARMS::Model::SearchAlertContactGroupRequest;
SearchAlertContactGroupRequest::SearchAlertContactGroupRequest() :
RpcServiceRequest("arms", "2019-08-08", "SearchAlertContactGroup")
{}
SearchAlertContactGroupRequest::~SearchAlertContactGroupRequest()
{}
std::string SearchAlertContactGroupRequest::getRegionId()const
{
return regionId_;
}
void SearchAlertContactGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string SearchAlertContactGroupRequest::getContactGroupName()const
{
return contactGroupName_;
}
void SearchAlertContactGroupRequest::setContactGroupName(const std::string& contactGroupName)
{
contactGroupName_ = contactGroupName;
setCoreParameter("ContactGroupName", contactGroupName);
}

66
arms/src/model/SearchAlertContactGroupResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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/arms/model/SearchAlertContactGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
SearchAlertContactGroupResult::SearchAlertContactGroupResult() :
ServiceResult()
{}
SearchAlertContactGroupResult::SearchAlertContactGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SearchAlertContactGroupResult::~SearchAlertContactGroupResult()
{}
void SearchAlertContactGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allContactGroups = value["ContactGroups"]["ContactGroup"];
for (auto value : allContactGroups)
{
ContactGroup contactGroupsObject;
if(!value["ContactGroupId"].isNull())
contactGroupsObject.contactGroupId = std::stol(value["ContactGroupId"].asString());
if(!value["ContactGroupName"].isNull())
contactGroupsObject.contactGroupName = value["ContactGroupName"].asString();
if(!value["UserId"].isNull())
contactGroupsObject.userId = value["UserId"].asString();
if(!value["CreateTime"].isNull())
contactGroupsObject.createTime = std::stol(value["CreateTime"].asString());
if(!value["UpdateTime"].isNull())
contactGroupsObject.updateTime = std::stol(value["UpdateTime"].asString());
contactGroups_.push_back(contactGroupsObject);
}
}
std::vector<SearchAlertContactGroupResult::ContactGroup> SearchAlertContactGroupResult::getContactGroups()const
{
return contactGroups_;
}

93
arms/src/model/SearchAlertContactRequest.cc Normal file
View File

@@ -0,0 +1,93 @@
/*
* 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/arms/model/SearchAlertContactRequest.h>
using AlibabaCloud::ARMS::Model::SearchAlertContactRequest;
SearchAlertContactRequest::SearchAlertContactRequest() :
RpcServiceRequest("arms", "2019-08-08", "SearchAlertContact")
{}
SearchAlertContactRequest::~SearchAlertContactRequest()
{}
std::string SearchAlertContactRequest::getContactName()const
{
return contactName_;
}
void SearchAlertContactRequest::setContactName(const std::string& contactName)
{
contactName_ = contactName;
setCoreParameter("ContactName", contactName);
}
std::string SearchAlertContactRequest::getPhone()const
{
return phone_;
}
void SearchAlertContactRequest::setPhone(const std::string& phone)
{
phone_ = phone;
setCoreParameter("Phone", phone);
}
std::string SearchAlertContactRequest::getRegionId()const
{
return regionId_;
}
void SearchAlertContactRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string SearchAlertContactRequest::getPageSize()const
{
return pageSize_;
}
void SearchAlertContactRequest::setPageSize(const std::string& pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", pageSize);
}
std::string SearchAlertContactRequest::getCurrentPage()const
{
return currentPage_;
}
void SearchAlertContactRequest::setCurrentPage(const std::string& currentPage)
{
currentPage_ = currentPage;
setCoreParameter("CurrentPage", currentPage);
}
std::string SearchAlertContactRequest::getEmail()const
{
return email_;
}
void SearchAlertContactRequest::setEmail(const std::string& email)
{
email_ = email;
setCoreParameter("Email", email);
}

81
arms/src/model/SearchAlertContactResult.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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/arms/model/SearchAlertContactResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
SearchAlertContactResult::SearchAlertContactResult() :
ServiceResult()
{}
SearchAlertContactResult::SearchAlertContactResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SearchAlertContactResult::~SearchAlertContactResult()
{}
void SearchAlertContactResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto pageBeanNode = value["PageBean"];
if(!pageBeanNode["TotalCount"].isNull())
pageBean_.totalCount = std::stoi(pageBeanNode["TotalCount"].asString());
if(!pageBeanNode["PageNumber"].isNull())
pageBean_.pageNumber = std::stoi(pageBeanNode["PageNumber"].asString());
if(!pageBeanNode["PageSize"].isNull())
pageBean_.pageSize = std::stoi(pageBeanNode["PageSize"].asString());
auto allContacts = value["Contacts"]["Contact"];
for (auto value : allContacts)
{
PageBean::Contact contactObject;
if(!value["ContactId"].isNull())
contactObject.contactId = std::stol(value["ContactId"].asString());
if(!value["ContactName"].isNull())
contactObject.contactName = value["ContactName"].asString();
if(!value["Phone"].isNull())
contactObject.phone = value["Phone"].asString();
if(!value["Email"].isNull())
contactObject.email = value["Email"].asString();
if(!value["UserId"].isNull())
contactObject.userId = value["UserId"].asString();
if(!value["DingRobot"].isNull())
contactObject.dingRobot = value["DingRobot"].asString();
if(!value["CreateTime"].isNull())
contactObject.createTime = std::stol(value["CreateTime"].asString());
if(!value["UpdateTime"].isNull())
contactObject.updateTime = std::stol(value["UpdateTime"].asString());
if(!value["SystemNoc"].isNull())
contactObject.systemNoc = value["SystemNoc"].asString() == "true";
pageBean_.contacts.push_back(contactObject);
}
}
SearchAlertContactResult::PageBean SearchAlertContactResult::getPageBean()const
{
return pageBean_;
}

71
arms/src/model/SearchRetcodeAppByPageRequest.cc Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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/arms/model/SearchRetcodeAppByPageRequest.h>
using AlibabaCloud::ARMS::Model::SearchRetcodeAppByPageRequest;
SearchRetcodeAppByPageRequest::SearchRetcodeAppByPageRequest() :
RpcServiceRequest("arms", "2019-08-08", "SearchRetcodeAppByPage")
{}
SearchRetcodeAppByPageRequest::~SearchRetcodeAppByPageRequest()
{}
std::string SearchRetcodeAppByPageRequest::getRegionId()const
{
return regionId_;
}
void SearchRetcodeAppByPageRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string SearchRetcodeAppByPageRequest::getRetcodeAppName()const
{
return retcodeAppName_;
}
void SearchRetcodeAppByPageRequest::setRetcodeAppName(const std::string& retcodeAppName)
{
retcodeAppName_ = retcodeAppName;
setCoreParameter("RetcodeAppName", retcodeAppName);
}
int SearchRetcodeAppByPageRequest::getPageSize()const
{
return pageSize_;
}
void SearchRetcodeAppByPageRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
int SearchRetcodeAppByPageRequest::getPageNumber()const
{
return pageNumber_;
}
void SearchRetcodeAppByPageRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
}

79
arms/src/model/SearchRetcodeAppByPageResult.cc Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/SearchRetcodeAppByPageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
SearchRetcodeAppByPageResult::SearchRetcodeAppByPageResult() :
ServiceResult()
{}
SearchRetcodeAppByPageResult::SearchRetcodeAppByPageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SearchRetcodeAppByPageResult::~SearchRetcodeAppByPageResult()
{}
void SearchRetcodeAppByPageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto pageBeanNode = value["PageBean"];
if(!pageBeanNode["TotalCount"].isNull())
pageBean_.totalCount = std::stoi(pageBeanNode["TotalCount"].asString());
if(!pageBeanNode["PageNumber"].isNull())
pageBean_.pageNumber = std::stoi(pageBeanNode["PageNumber"].asString());
if(!pageBeanNode["PageSize"].isNull())
pageBean_.pageSize = std::stoi(pageBeanNode["PageSize"].asString());
auto allRetcodeApps = value["RetcodeApps"]["RetcodeApp"];
for (auto value : allRetcodeApps)
{
PageBean::RetcodeApp retcodeAppObject;
if(!value["AppId"].isNull())
retcodeAppObject.appId = std::stol(value["AppId"].asString());
if(!value["Pid"].isNull())
retcodeAppObject.pid = value["Pid"].asString();
if(!value["AppName"].isNull())
retcodeAppObject.appName = value["AppName"].asString();
if(!value["Type"].isNull())
retcodeAppObject.type = value["Type"].asString();
if(!value["UserId"].isNull())
retcodeAppObject.userId = value["UserId"].asString();
if(!value["RegionId"].isNull())
retcodeAppObject.regionId = value["RegionId"].asString();
if(!value["CreateTime"].isNull())
retcodeAppObject.createTime = std::stol(value["CreateTime"].asString());
if(!value["UpdateTime"].isNull())
retcodeAppObject.updateTime = std::stol(value["UpdateTime"].asString());
pageBean_.retcodeApps.push_back(retcodeAppObject);
}
}
SearchRetcodeAppByPageResult::PageBean SearchRetcodeAppByPageResult::getPageBean()const
{
return pageBean_;
}

49
arms/src/model/SearchTraceAppByNameRequest.cc Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/SearchTraceAppByNameRequest.h>
using AlibabaCloud::ARMS::Model::SearchTraceAppByNameRequest;
SearchTraceAppByNameRequest::SearchTraceAppByNameRequest() :
RpcServiceRequest("arms", "2019-08-08", "SearchTraceAppByName")
{}
SearchTraceAppByNameRequest::~SearchTraceAppByNameRequest()
{}
std::string SearchTraceAppByNameRequest::getRegionId()const
{
return regionId_;
}
void SearchTraceAppByNameRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string SearchTraceAppByNameRequest::getTraceAppName()const
{
return traceAppName_;
}
void SearchTraceAppByNameRequest::setTraceAppName(const std::string& traceAppName)
{
traceAppName_ = traceAppName;
setCoreParameter("TraceAppName", traceAppName);
}

72
arms/src/model/SearchTraceAppByNameResult.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/SearchTraceAppByNameResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
SearchTraceAppByNameResult::SearchTraceAppByNameResult() :
ServiceResult()
{}
SearchTraceAppByNameResult::SearchTraceAppByNameResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SearchTraceAppByNameResult::~SearchTraceAppByNameResult()
{}
void SearchTraceAppByNameResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTraceApps = value["TraceApps"]["TraceApp"];
for (auto value : allTraceApps)
{
TraceApp traceAppsObject;
if(!value["AppId"].isNull())
traceAppsObject.appId = std::stol(value["AppId"].asString());
if(!value["Pid"].isNull())
traceAppsObject.pid = value["Pid"].asString();
if(!value["AppName"].isNull())
traceAppsObject.appName = value["AppName"].asString();
if(!value["Type"].isNull())
traceAppsObject.type = value["Type"].asString();
if(!value["UserId"].isNull())
traceAppsObject.userId = value["UserId"].asString();
if(!value["RegionId"].isNull())
traceAppsObject.regionId = value["RegionId"].asString();
if(!value["CreateTime"].isNull())
traceAppsObject.createTime = std::stol(value["CreateTime"].asString());
if(!value["UpdateTime"].isNull())
traceAppsObject.updateTime = std::stol(value["UpdateTime"].asString());
traceApps_.push_back(traceAppsObject);
}
}
std::vector<SearchTraceAppByNameResult::TraceApp> SearchTraceAppByNameResult::getTraceApps()const
{
return traceApps_;
}

71
arms/src/model/SearchTraceAppByPageRequest.cc Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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/arms/model/SearchTraceAppByPageRequest.h>
using AlibabaCloud::ARMS::Model::SearchTraceAppByPageRequest;
SearchTraceAppByPageRequest::SearchTraceAppByPageRequest() :
RpcServiceRequest("arms", "2019-08-08", "SearchTraceAppByPage")
{}
SearchTraceAppByPageRequest::~SearchTraceAppByPageRequest()
{}
std::string SearchTraceAppByPageRequest::getRegionId()const
{
return regionId_;
}
void SearchTraceAppByPageRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string SearchTraceAppByPageRequest::getTraceAppName()const
{
return traceAppName_;
}
void SearchTraceAppByPageRequest::setTraceAppName(const std::string& traceAppName)
{
traceAppName_ = traceAppName;
setCoreParameter("TraceAppName", traceAppName);
}
int SearchTraceAppByPageRequest::getPageSize()const
{
return pageSize_;
}
void SearchTraceAppByPageRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
int SearchTraceAppByPageRequest::getPageNumber()const
{
return pageNumber_;
}
void SearchTraceAppByPageRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
}

79
arms/src/model/SearchTraceAppByPageResult.cc Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/SearchTraceAppByPageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
SearchTraceAppByPageResult::SearchTraceAppByPageResult() :
ServiceResult()
{}
SearchTraceAppByPageResult::SearchTraceAppByPageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SearchTraceAppByPageResult::~SearchTraceAppByPageResult()
{}
void SearchTraceAppByPageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto pageBeanNode = value["PageBean"];
if(!pageBeanNode["TotalCount"].isNull())
pageBean_.totalCount = std::stoi(pageBeanNode["TotalCount"].asString());
if(!pageBeanNode["PageNumber"].isNull())
pageBean_.pageNumber = std::stoi(pageBeanNode["PageNumber"].asString());
if(!pageBeanNode["PageSize"].isNull())
pageBean_.pageSize = std::stoi(pageBeanNode["PageSize"].asString());
auto allTraceApps = value["TraceApps"]["TraceApp"];
for (auto value : allTraceApps)
{
PageBean::TraceApp traceAppObject;
if(!value["AppId"].isNull())
traceAppObject.appId = std::stol(value["AppId"].asString());
if(!value["Pid"].isNull())
traceAppObject.pid = value["Pid"].asString();
if(!value["AppName"].isNull())
traceAppObject.appName = value["AppName"].asString();
if(!value["Type"].isNull())
traceAppObject.type = value["Type"].asString();
if(!value["UserId"].isNull())
traceAppObject.userId = value["UserId"].asString();
if(!value["RegionId"].isNull())
traceAppObject.regionId = value["RegionId"].asString();
if(!value["CreateTime"].isNull())
traceAppObject.createTime = std::stol(value["CreateTime"].asString());
if(!value["UpdateTime"].isNull())
traceAppObject.updateTime = std::stol(value["UpdateTime"].asString());
pageBean_.traceApps.push_back(traceAppObject);
}
}
SearchTraceAppByPageResult::PageBean SearchTraceAppByPageResult::getPageBean()const
{
return pageBean_;
}