Supported new features for outbound.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-11-25 Version: 1.36.948
+- Supported new features for outbound.
+
 2021-11-25 Version: 1.36.947
 - Delete some abandoned interface.
 - Add some interfaces.

VERSION

@@ -1 +1 @@
-1.36.947
+1.36.948

outboundbot/CMakeLists.txt

@@ -33,6 +33,8 @@ set(outboundbot_public_header_model
 	include/alibabacloud/outboundbot/model/CreateBatchRepeatJobResult.h
 	include/alibabacloud/outboundbot/model/CreateDialogueFlowRequest.h
 	include/alibabacloud/outboundbot/model/CreateDialogueFlowResult.h
+	include/alibabacloud/outboundbot/model/CreateDownloadUrlRequest.h
+	include/alibabacloud/outboundbot/model/CreateDownloadUrlResult.h
 	include/alibabacloud/outboundbot/model/CreateGlobalQuestionRequest.h
 	include/alibabacloud/outboundbot/model/CreateGlobalQuestionResult.h
 	include/alibabacloud/outboundbot/model/CreateInstanceRequest.h
@@ -131,6 +133,8 @@ set(outboundbot_public_header_model
 	include/alibabacloud/outboundbot/model/GetEffectiveDaysResult.h
 	include/alibabacloud/outboundbot/model/GetEmptyNumberNoMoreCallsInfoRequest.h
 	include/alibabacloud/outboundbot/model/GetEmptyNumberNoMoreCallsInfoResult.h
+	include/alibabacloud/outboundbot/model/GetInstanceConfigRequest.h
+	include/alibabacloud/outboundbot/model/GetInstanceConfigResult.h
 	include/alibabacloud/outboundbot/model/GetMaxAttemptsPerDayRequest.h
 	include/alibabacloud/outboundbot/model/GetMaxAttemptsPerDayResult.h
 	include/alibabacloud/outboundbot/model/GetSummaryInfoRequest.h
@@ -145,6 +149,8 @@ set(outboundbot_public_header_model
 	include/alibabacloud/outboundbot/model/InflightTaskTimeoutResult.h
 	include/alibabacloud/outboundbot/model/ListDialogueFlowsRequest.h
 	include/alibabacloud/outboundbot/model/ListDialogueFlowsResult.h
+	include/alibabacloud/outboundbot/model/ListDownloadTasksRequest.h
+	include/alibabacloud/outboundbot/model/ListDownloadTasksResult.h
 	include/alibabacloud/outboundbot/model/ListGlobalQuestionsRequest.h
 	include/alibabacloud/outboundbot/model/ListGlobalQuestionsResult.h
 	include/alibabacloud/outboundbot/model/ListInstancesRequest.h
@@ -229,6 +235,8 @@ set(outboundbot_public_header_model
 	include/alibabacloud/outboundbot/model/SaveEffectiveDaysResult.h
 	include/alibabacloud/outboundbot/model/SaveMaxAttemptsPerDayRequest.h
 	include/alibabacloud/outboundbot/model/SaveMaxAttemptsPerDayResult.h
+	include/alibabacloud/outboundbot/model/SearchTaskRequest.h
+	include/alibabacloud/outboundbot/model/SearchTaskResult.h
 	include/alibabacloud/outboundbot/model/StartJobRequest.h
 	include/alibabacloud/outboundbot/model/StartJobResult.h
 	include/alibabacloud/outboundbot/model/SubmitBatchJobsRequest.h
@@ -268,6 +276,8 @@ set(outboundbot_src
 	src/model/CreateBatchRepeatJobResult.cc
 	src/model/CreateDialogueFlowRequest.cc
 	src/model/CreateDialogueFlowResult.cc
+	src/model/CreateDownloadUrlRequest.cc
+	src/model/CreateDownloadUrlResult.cc
 	src/model/CreateGlobalQuestionRequest.cc
 	src/model/CreateGlobalQuestionResult.cc
 	src/model/CreateInstanceRequest.cc
@@ -366,6 +376,8 @@ set(outboundbot_src
 	src/model/GetEffectiveDaysResult.cc
 	src/model/GetEmptyNumberNoMoreCallsInfoRequest.cc
 	src/model/GetEmptyNumberNoMoreCallsInfoResult.cc
+	src/model/GetInstanceConfigRequest.cc
+	src/model/GetInstanceConfigResult.cc
 	src/model/GetMaxAttemptsPerDayRequest.cc
 	src/model/GetMaxAttemptsPerDayResult.cc
 	src/model/GetSummaryInfoRequest.cc
@@ -380,6 +392,8 @@ set(outboundbot_src
 	src/model/InflightTaskTimeoutResult.cc
 	src/model/ListDialogueFlowsRequest.cc
 	src/model/ListDialogueFlowsResult.cc
+	src/model/ListDownloadTasksRequest.cc
+	src/model/ListDownloadTasksResult.cc
 	src/model/ListGlobalQuestionsRequest.cc
 	src/model/ListGlobalQuestionsResult.cc
 	src/model/ListInstancesRequest.cc
@@ -464,6 +478,8 @@ set(outboundbot_src
 	src/model/SaveEffectiveDaysResult.cc
 	src/model/SaveMaxAttemptsPerDayRequest.cc
 	src/model/SaveMaxAttemptsPerDayResult.cc
+	src/model/SearchTaskRequest.cc
+	src/model/SearchTaskResult.cc
 	src/model/StartJobRequest.cc
 	src/model/StartJobResult.cc
 	src/model/SubmitBatchJobsRequest.cc

outboundbot/include/alibabacloud/outboundbot/OutboundBotClient.h

@@ -34,6 +34,8 @@
 #include "model/CreateBatchRepeatJobResult.h"
 #include "model/CreateDialogueFlowRequest.h"
 #include "model/CreateDialogueFlowResult.h"
+#include "model/CreateDownloadUrlRequest.h"
+#include "model/CreateDownloadUrlResult.h"
 #include "model/CreateGlobalQuestionRequest.h"
 #include "model/CreateGlobalQuestionResult.h"
 #include "model/CreateInstanceRequest.h"
@@ -132,6 +134,8 @@
 #include "model/GetEffectiveDaysResult.h"
 #include "model/GetEmptyNumberNoMoreCallsInfoRequest.h"
 #include "model/GetEmptyNumberNoMoreCallsInfoResult.h"
+#include "model/GetInstanceConfigRequest.h"
+#include "model/GetInstanceConfigResult.h"
 #include "model/GetMaxAttemptsPerDayRequest.h"
 #include "model/GetMaxAttemptsPerDayResult.h"
 #include "model/GetSummaryInfoRequest.h"
@@ -146,6 +150,8 @@
 #include "model/InflightTaskTimeoutResult.h"
 #include "model/ListDialogueFlowsRequest.h"
 #include "model/ListDialogueFlowsResult.h"
+#include "model/ListDownloadTasksRequest.h"
+#include "model/ListDownloadTasksResult.h"
 #include "model/ListGlobalQuestionsRequest.h"
 #include "model/ListGlobalQuestionsResult.h"
 #include "model/ListInstancesRequest.h"
@@ -230,6 +236,8 @@
 #include "model/SaveEffectiveDaysResult.h"
 #include "model/SaveMaxAttemptsPerDayRequest.h"
 #include "model/SaveMaxAttemptsPerDayResult.h"
+#include "model/SearchTaskRequest.h"
+#include "model/SearchTaskResult.h"
 #include "model/StartJobRequest.h"
 #include "model/StartJobResult.h"
 #include "model/SubmitBatchJobsRequest.h"
@@ -281,6 +289,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateDialogueFlowResult> CreateDialogueFlowOutcome;
 			typedef std::future<CreateDialogueFlowOutcome> CreateDialogueFlowOutcomeCallable;
 			typedef std::function<void(const OutboundBotClient*, const Model::CreateDialogueFlowRequest&, const CreateDialogueFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDialogueFlowAsyncHandler;
+			typedef Outcome<Error, Model::CreateDownloadUrlResult> CreateDownloadUrlOutcome;
+			typedef std::future<CreateDownloadUrlOutcome> CreateDownloadUrlOutcomeCallable;
+			typedef std::function<void(const OutboundBotClient*, const Model::CreateDownloadUrlRequest&, const CreateDownloadUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDownloadUrlAsyncHandler;
 			typedef Outcome<Error, Model::CreateGlobalQuestionResult> CreateGlobalQuestionOutcome;
 			typedef std::future<CreateGlobalQuestionOutcome> CreateGlobalQuestionOutcomeCallable;
 			typedef std::function<void(const OutboundBotClient*, const Model::CreateGlobalQuestionRequest&, const CreateGlobalQuestionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGlobalQuestionAsyncHandler;
@@ -428,6 +439,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetEmptyNumberNoMoreCallsInfoResult> GetEmptyNumberNoMoreCallsInfoOutcome;
 			typedef std::future<GetEmptyNumberNoMoreCallsInfoOutcome> GetEmptyNumberNoMoreCallsInfoOutcomeCallable;
 			typedef std::function<void(const OutboundBotClient*, const Model::GetEmptyNumberNoMoreCallsInfoRequest&, const GetEmptyNumberNoMoreCallsInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetEmptyNumberNoMoreCallsInfoAsyncHandler;
+			typedef Outcome<Error, Model::GetInstanceConfigResult> GetInstanceConfigOutcome;
+			typedef std::future<GetInstanceConfigOutcome> GetInstanceConfigOutcomeCallable;
+			typedef std::function<void(const OutboundBotClient*, const Model::GetInstanceConfigRequest&, const GetInstanceConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceConfigAsyncHandler;
 			typedef Outcome<Error, Model::GetMaxAttemptsPerDayResult> GetMaxAttemptsPerDayOutcome;
 			typedef std::future<GetMaxAttemptsPerDayOutcome> GetMaxAttemptsPerDayOutcomeCallable;
 			typedef std::function<void(const OutboundBotClient*, const Model::GetMaxAttemptsPerDayRequest&, const GetMaxAttemptsPerDayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMaxAttemptsPerDayAsyncHandler;
@@ -449,6 +463,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListDialogueFlowsResult> ListDialogueFlowsOutcome;
 			typedef std::future<ListDialogueFlowsOutcome> ListDialogueFlowsOutcomeCallable;
 			typedef std::function<void(const OutboundBotClient*, const Model::ListDialogueFlowsRequest&, const ListDialogueFlowsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDialogueFlowsAsyncHandler;
+			typedef Outcome<Error, Model::ListDownloadTasksResult> ListDownloadTasksOutcome;
+			typedef std::future<ListDownloadTasksOutcome> ListDownloadTasksOutcomeCallable;
+			typedef std::function<void(const OutboundBotClient*, const Model::ListDownloadTasksRequest&, const ListDownloadTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDownloadTasksAsyncHandler;
 			typedef Outcome<Error, Model::ListGlobalQuestionsResult> ListGlobalQuestionsOutcome;
 			typedef std::future<ListGlobalQuestionsOutcome> ListGlobalQuestionsOutcomeCallable;
 			typedef std::function<void(const OutboundBotClient*, const Model::ListGlobalQuestionsRequest&, const ListGlobalQuestionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGlobalQuestionsAsyncHandler;
@@ -575,6 +592,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SaveMaxAttemptsPerDayResult> SaveMaxAttemptsPerDayOutcome;
 			typedef std::future<SaveMaxAttemptsPerDayOutcome> SaveMaxAttemptsPerDayOutcomeCallable;
 			typedef std::function<void(const OutboundBotClient*, const Model::SaveMaxAttemptsPerDayRequest&, const SaveMaxAttemptsPerDayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SaveMaxAttemptsPerDayAsyncHandler;
+			typedef Outcome<Error, Model::SearchTaskResult> SearchTaskOutcome;
+			typedef std::future<SearchTaskOutcome> SearchTaskOutcomeCallable;
+			typedef std::function<void(const OutboundBotClient*, const Model::SearchTaskRequest&, const SearchTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchTaskAsyncHandler;
 			typedef Outcome<Error, Model::StartJobResult> StartJobOutcome;
 			typedef std::future<StartJobOutcome> StartJobOutcomeCallable;
 			typedef std::function<void(const OutboundBotClient*, const Model::StartJobRequest&, const StartJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartJobAsyncHandler;
@@ -634,6 +654,9 @@ namespace AlibabaCloud
 			CreateDialogueFlowOutcome createDialogueFlow(const Model::CreateDialogueFlowRequest &request)const;
 			void createDialogueFlowAsync(const Model::CreateDialogueFlowRequest& request, const CreateDialogueFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDialogueFlowOutcomeCallable createDialogueFlowCallable(const Model::CreateDialogueFlowRequest& request) const;
+			CreateDownloadUrlOutcome createDownloadUrl(const Model::CreateDownloadUrlRequest &request)const;
+			void createDownloadUrlAsync(const Model::CreateDownloadUrlRequest& request, const CreateDownloadUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDownloadUrlOutcomeCallable createDownloadUrlCallable(const Model::CreateDownloadUrlRequest& request) const;
 			CreateGlobalQuestionOutcome createGlobalQuestion(const Model::CreateGlobalQuestionRequest &request)const;
 			void createGlobalQuestionAsync(const Model::CreateGlobalQuestionRequest& request, const CreateGlobalQuestionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateGlobalQuestionOutcomeCallable createGlobalQuestionCallable(const Model::CreateGlobalQuestionRequest& request) const;
@@ -781,6 +804,9 @@ namespace AlibabaCloud
 			GetEmptyNumberNoMoreCallsInfoOutcome getEmptyNumberNoMoreCallsInfo(const Model::GetEmptyNumberNoMoreCallsInfoRequest &request)const;
 			void getEmptyNumberNoMoreCallsInfoAsync(const Model::GetEmptyNumberNoMoreCallsInfoRequest& request, const GetEmptyNumberNoMoreCallsInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetEmptyNumberNoMoreCallsInfoOutcomeCallable getEmptyNumberNoMoreCallsInfoCallable(const Model::GetEmptyNumberNoMoreCallsInfoRequest& request) const;
+			GetInstanceConfigOutcome getInstanceConfig(const Model::GetInstanceConfigRequest &request)const;
+			void getInstanceConfigAsync(const Model::GetInstanceConfigRequest& request, const GetInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetInstanceConfigOutcomeCallable getInstanceConfigCallable(const Model::GetInstanceConfigRequest& request) const;
 			GetMaxAttemptsPerDayOutcome getMaxAttemptsPerDay(const Model::GetMaxAttemptsPerDayRequest &request)const;
 			void getMaxAttemptsPerDayAsync(const Model::GetMaxAttemptsPerDayRequest& request, const GetMaxAttemptsPerDayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetMaxAttemptsPerDayOutcomeCallable getMaxAttemptsPerDayCallable(const Model::GetMaxAttemptsPerDayRequest& request) const;
@@ -802,6 +828,9 @@ namespace AlibabaCloud
 			ListDialogueFlowsOutcome listDialogueFlows(const Model::ListDialogueFlowsRequest &request)const;
 			void listDialogueFlowsAsync(const Model::ListDialogueFlowsRequest& request, const ListDialogueFlowsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListDialogueFlowsOutcomeCallable listDialogueFlowsCallable(const Model::ListDialogueFlowsRequest& request) const;
+			ListDownloadTasksOutcome listDownloadTasks(const Model::ListDownloadTasksRequest &request)const;
+			void listDownloadTasksAsync(const Model::ListDownloadTasksRequest& request, const ListDownloadTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDownloadTasksOutcomeCallable listDownloadTasksCallable(const Model::ListDownloadTasksRequest& request) const;
 			ListGlobalQuestionsOutcome listGlobalQuestions(const Model::ListGlobalQuestionsRequest &request)const;
 			void listGlobalQuestionsAsync(const Model::ListGlobalQuestionsRequest& request, const ListGlobalQuestionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListGlobalQuestionsOutcomeCallable listGlobalQuestionsCallable(const Model::ListGlobalQuestionsRequest& request) const;
@@ -928,6 +957,9 @@ namespace AlibabaCloud
 			SaveMaxAttemptsPerDayOutcome saveMaxAttemptsPerDay(const Model::SaveMaxAttemptsPerDayRequest &request)const;
 			void saveMaxAttemptsPerDayAsync(const Model::SaveMaxAttemptsPerDayRequest& request, const SaveMaxAttemptsPerDayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SaveMaxAttemptsPerDayOutcomeCallable saveMaxAttemptsPerDayCallable(const Model::SaveMaxAttemptsPerDayRequest& request) const;
+			SearchTaskOutcome searchTask(const Model::SearchTaskRequest &request)const;
+			void searchTaskAsync(const Model::SearchTaskRequest& request, const SearchTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SearchTaskOutcomeCallable searchTaskCallable(const Model::SearchTaskRequest& request) const;
 			StartJobOutcome startJob(const Model::StartJobRequest &request)const;
 			void startJobAsync(const Model::StartJobRequest& request, const StartJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartJobOutcomeCallable startJobCallable(const Model::StartJobRequest& request) const;

outboundbot/include/alibabacloud/outboundbot/model/CreateDownloadUrlRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OUTBOUNDBOT_MODEL_CREATEDOWNLOADURLREQUEST_H_
+#define ALIBABACLOUD_OUTBOUNDBOT_MODEL_CREATEDOWNLOADURLREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/outboundbot/OutboundBotExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OutboundBot
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OUTBOUNDBOT_EXPORT CreateDownloadUrlRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateDownloadUrlRequest();
+				~CreateDownloadUrlRequest();
+
+				std::string getDownloadTaskId()const;
+				void setDownloadTaskId(const std::string& downloadTaskId);
+				std::string getFileId()const;
+				void setFileId(const std::string& fileId);
+
+            private:
+				std::string downloadTaskId_;
+				std::string fileId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OUTBOUNDBOT_MODEL_CREATEDOWNLOADURLREQUEST_H_

outboundbot/include/alibabacloud/outboundbot/model/CreateDownloadUrlResult.h

@@ -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_OUTBOUNDBOT_MODEL_CREATEDOWNLOADURLRESULT_H_
+#define ALIBABACLOUD_OUTBOUNDBOT_MODEL_CREATEDOWNLOADURLRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/outboundbot/OutboundBotExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OutboundBot
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OUTBOUNDBOT_EXPORT CreateDownloadUrlResult : public ServiceResult
+			{
+			public:
+
+
+				CreateDownloadUrlResult();
+				explicit CreateDownloadUrlResult(const std::string &payload);
+				~CreateDownloadUrlResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getFileHttpUrl()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string fileHttpUrl_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OUTBOUNDBOT_MODEL_CREATEDOWNLOADURLRESULT_H_

outboundbot/include/alibabacloud/outboundbot/model/DescribeJobResult.h

@@ -85,8 +85,8 @@ namespace AlibabaCloud
 							std::string speaker;
 						};
 						std::string status;
-						std::string chatbotId;
 						long planedTime;
+						std::string chatbotId;
 						std::string calledNumber;
 						std::string scenarioId;
 						std::string taskId;
@@ -99,6 +99,7 @@ namespace AlibabaCloud
 						std::string callingNumber;
 						std::string endReason;
 						Contact3 contact3;
+						std::string hangUpDirection;
 						std::string jobId;
 					};
 					std::string status;
@@ -106,8 +107,8 @@ namespace AlibabaCloud
 					std::vector<Task> tasks;
 					std::string scenarioId;
 					std::string instanceId;
-					int priority;
 					long actualTime;
+					int priority;
 					std::string strategyId;
 					std::vector<KeyValuePair> extras;
 					std::string dsReport;

outboundbot/include/alibabacloud/outboundbot/model/GetInstanceConfigRequest.h

@@ -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_OUTBOUNDBOT_MODEL_GETINSTANCECONFIGREQUEST_H_
+#define ALIBABACLOUD_OUTBOUNDBOT_MODEL_GETINSTANCECONFIGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/outboundbot/OutboundBotExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OutboundBot
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OUTBOUNDBOT_EXPORT GetInstanceConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetInstanceConfigRequest();
+				~GetInstanceConfigRequest();
+
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OUTBOUNDBOT_MODEL_GETINSTANCECONFIGREQUEST_H_

outboundbot/include/alibabacloud/outboundbot/model/GetInstanceConfigResult.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OUTBOUNDBOT_MODEL_GETINSTANCECONFIGRESULT_H_
+#define ALIBABACLOUD_OUTBOUNDBOT_MODEL_GETINSTANCECONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/outboundbot/OutboundBotExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OutboundBot
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OUTBOUNDBOT_EXPORT GetInstanceConfigResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct InstanceConfig
+					{
+						bool newBargeInSystemSwitch;
+						bool searchTaskFunctionSwitch;
+						bool miniPlaybackSystemSwitch;
+					};
+					InstanceConfig instanceConfig;
+				};
+
+
+				GetInstanceConfigResult();
+				explicit GetInstanceConfigResult(const std::string &payload);
+				~GetInstanceConfigResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OUTBOUNDBOT_MODEL_GETINSTANCECONFIGRESULT_H_

outboundbot/include/alibabacloud/outboundbot/model/ListDownloadTasksRequest.h

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

outboundbot/include/alibabacloud/outboundbot/model/ListDownloadTasksResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_OUTBOUNDBOT_MODEL_LISTDOWNLOADTASKSRESULT_H_
+#define ALIBABACLOUD_OUTBOUNDBOT_MODEL_LISTDOWNLOADTASKSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/outboundbot/OutboundBotExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OutboundBot
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OUTBOUNDBOT_EXPORT ListDownloadTasksResult : public ServiceResult
+			{
+			public:
+				struct DownloadTasks
+				{
+					struct DownloadTask
+					{
+						struct DownloadTaskFile0
+						{
+							std::string status;
+							int progress;
+							std::string title;
+							std::string fileId;
+						};
+						std::string status;
+						std::string taskId;
+						std::vector<DownloadTask::DownloadTaskFile0> downloadTaskFiles;
+						std::string title;
+						long expireTime;
+					};
+					int totalCount;
+					int pageSize;
+					int pageNumber;
+					std::vector<DownloadTask> list;
+				};
+
+
+				ListDownloadTasksResult();
+				explicit ListDownloadTasksResult(const std::string &payload);
+				~ListDownloadTasksResult();
+				DownloadTasks getDownloadTasks()const;
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				DownloadTasks downloadTasks_;
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OUTBOUNDBOT_MODEL_LISTDOWNLOADTASKSRESULT_H_

outboundbot/include/alibabacloud/outboundbot/model/QueryJobsWithResultResult.h

@@ -44,8 +44,8 @@ namespace AlibabaCloud
 								std::string honorific;
 								std::string referenceId;
 								std::string state;
-								std::string phoneNumber;
 								int round;
+								std::string phoneNumber;
 								std::string id;
 								std::string jobUuid;
 								std::string preferredPhoneNumber;
@@ -61,18 +61,24 @@ namespace AlibabaCloud
 								std::string tagName;
 								std::string tagGroup;
 							};
-							bool hasAnswered;
+							struct ExceptionCode
+							{
+								std::string hint;
+								std::string code;
+							};
 							std::string status;
+							bool hasAnswered;
 							bool hasHangUpByRejection;
-							std::string taskEndReason;
 							std::vector<TagHit> tagHits;
-							std::string callDurationDisplay;
+							std::vector<ExceptionCode> dialExceptionCodes;
 							std::string statusName;
-							long callTime;
 							std::vector<Extra> extras;
 							int callDuration;
 							bool hasReachedEndOfFlow;
 							Contact contact;
+							std::string taskEndReason;
+							std::string callDurationDisplay;
+							long callTime;
 						};
 						std::string status;
 						std::string statusName;
@@ -80,8 +86,8 @@ namespace AlibabaCloud
 						LatestTask latestTask;
 						std::string jobFailureReason;
 					};
-					int pageCount;
 					int pageSize;
+					int pageCount;
 					int pageNumber;
 					std::vector<Job> list;
 					int rowCount;

outboundbot/include/alibabacloud/outboundbot/model/RecordFailureRequest.h

@@ -51,6 +51,8 @@ namespace AlibabaCloud
 				void setInstanceOwnerId(const std::string& instanceOwnerId);
 				std::string getTaskId()const;
 				void setTaskId(const std::string& taskId);
+				std::string getExceptionCodes()const;
+				void setExceptionCodes(const std::string& exceptionCodes);
 
             private:
 				std::string callId_;
@@ -61,6 +63,7 @@ namespace AlibabaCloud
 				std::string calledNumber_;
 				std::string instanceOwnerId_;
 				std::string taskId_;
+				std::string exceptionCodes_;
 
 			};
 		}

outboundbot/include/alibabacloud/outboundbot/model/SearchTaskRequest.h

@@ -0,0 +1,111 @@
+/*
+ * 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_OUTBOUNDBOT_MODEL_SEARCHTASKREQUEST_H_
+#define ALIBABACLOUD_OUTBOUNDBOT_MODEL_SEARCHTASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/outboundbot/OutboundBotExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OutboundBot
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OUTBOUNDBOT_EXPORT SearchTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				SearchTaskRequest();
+				~SearchTaskRequest();
+
+				long getActualTimeLte()const;
+				void setActualTimeLte(long actualTimeLte);
+				std::string getOtherId()const;
+				void setOtherId(const std::string& otherId);
+				long getTaskCreateTimeLte()const;
+				void setTaskCreateTimeLte(long taskCreateTimeLte);
+				std::string getJobId()const;
+				void setJobId(const std::string& jobId);
+				long getTaskCreateTimeGte()const;
+				void setTaskCreateTimeGte(long taskCreateTimeGte);
+				std::string getCalledNumber()const;
+				void setCalledNumber(const std::string& calledNumber);
+				std::string getUserIdMatch()const;
+				void setUserIdMatch(const std::string& userIdMatch);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageIndex()const;
+				void setPageIndex(int pageIndex);
+				std::string getSortOrder()const;
+				void setSortOrder(const std::string& sortOrder);
+				std::string getTaskStatusStringList()const;
+				void setTaskStatusStringList(const std::string& taskStatusStringList);
+				std::string getJobGroupNameQuery()const;
+				void setJobGroupNameQuery(const std::string& jobGroupNameQuery);
+				std::string getTaskId()const;
+				void setTaskId(const std::string& taskId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				long getRecordingDurationGte()const;
+				void setRecordingDurationGte(long recordingDurationGte);
+				long getCallDurationLte()const;
+				void setCallDurationLte(long callDurationLte);
+				std::string getJobGroupId()const;
+				void setJobGroupId(const std::string& jobGroupId);
+				std::string getSortBy()const;
+				void setSortBy(const std::string& sortBy);
+				std::string getJobStatusStringList()const;
+				void setJobStatusStringList(const std::string& jobStatusStringList);
+				long getActualTimeGte()const;
+				void setActualTimeGte(long actualTimeGte);
+				long getCallDurationGte()const;
+				void setCallDurationGte(long callDurationGte);
+				long getRecordingDurationLte()const;
+				void setRecordingDurationLte(long recordingDurationLte);
+
+            private:
+				long actualTimeLte_;
+				std::string otherId_;
+				long taskCreateTimeLte_;
+				std::string jobId_;
+				long taskCreateTimeGte_;
+				std::string calledNumber_;
+				std::string userIdMatch_;
+				int pageSize_;
+				int pageIndex_;
+				std::string sortOrder_;
+				std::string taskStatusStringList_;
+				std::string jobGroupNameQuery_;
+				std::string taskId_;
+				std::string instanceId_;
+				long recordingDurationGte_;
+				long callDurationLte_;
+				std::string jobGroupId_;
+				std::string sortBy_;
+				std::string jobStatusStringList_;
+				long actualTimeGte_;
+				long callDurationGte_;
+				long recordingDurationLte_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OUTBOUNDBOT_MODEL_SEARCHTASKREQUEST_H_

outboundbot/include/alibabacloud/outboundbot/model/SearchTaskResult.h

@@ -0,0 +1,95 @@
+/*
+ * 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_OUTBOUNDBOT_MODEL_SEARCHTASKRESULT_H_
+#define ALIBABACLOUD_OUTBOUNDBOT_MODEL_SEARCHTASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/outboundbot/OutboundBotExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OutboundBot
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OUTBOUNDBOT_EXPORT SearchTaskResult : public ServiceResult
+			{
+			public:
+				struct SearchTaskInfo
+				{
+					bool hasAnswered;
+					bool hasHangUpByRejection;
+					std::string calledNumber;
+					std::string taskId;
+					std::string taskStatusName;
+					std::vector<std::string> dialExceptionCodes;
+					bool hasReachedEndOfFlow;
+					int jobStatus;
+					std::string dialException;
+					std::string jobStatusName;
+					long taskCreateTime;
+					std::string jobGroupId;
+					bool hasLastPlaybackCompleted;
+					int taskEndReason;
+					std::string dialExceptionOld;
+					std::string callDurationDisplay;
+					std::string jobId;
+					std::string userName;
+					std::string instanceId;
+					std::string jobGroupName;
+					long actualTime;
+					int taskStatus;
+					std::string taskStatusString;
+					int callDuration;
+					std::string userId;
+					std::string jobStatusString;
+					int recordingDuration;
+				};
+
+
+				SearchTaskResult();
+				explicit SearchTaskResult(const std::string &payload);
+				~SearchTaskResult();
+				std::string getMessage()const;
+				int getPageSize()const;
+				long getTotal()const;
+				int getHttpStatusCode()const;
+				int getPageIndex()const;
+				std::string getCode()const;
+				std::vector<SearchTaskInfo> getSearchTaskInfoList()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int pageSize_;
+				long total_;
+				int httpStatusCode_;
+				int pageIndex_;
+				std::string code_;
+				std::vector<SearchTaskInfo> searchTaskInfoList_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OUTBOUNDBOT_MODEL_SEARCHTASKRESULT_H_

outboundbot/src/OutboundBotClient.cc

@@ -267,6 +267,42 @@ OutboundBotClient::CreateDialogueFlowOutcomeCallable OutboundBotClient::createDi
 	return task->get_future();
 }
 
+OutboundBotClient::CreateDownloadUrlOutcome OutboundBotClient::createDownloadUrl(const CreateDownloadUrlRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDownloadUrlOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDownloadUrlOutcome(CreateDownloadUrlResult(outcome.result()));
+	else
+		return CreateDownloadUrlOutcome(outcome.error());
+}
+
+void OutboundBotClient::createDownloadUrlAsync(const CreateDownloadUrlRequest& request, const CreateDownloadUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDownloadUrl(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OutboundBotClient::CreateDownloadUrlOutcomeCallable OutboundBotClient::createDownloadUrlCallable(const CreateDownloadUrlRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDownloadUrlOutcome()>>(
+			[this, request]()
+			{
+			return this->createDownloadUrl(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OutboundBotClient::CreateGlobalQuestionOutcome OutboundBotClient::createGlobalQuestion(const CreateGlobalQuestionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2031,6 +2067,42 @@ OutboundBotClient::GetEmptyNumberNoMoreCallsInfoOutcomeCallable OutboundBotClien
 	return task->get_future();
 }
 
+OutboundBotClient::GetInstanceConfigOutcome OutboundBotClient::getInstanceConfig(const GetInstanceConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetInstanceConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetInstanceConfigOutcome(GetInstanceConfigResult(outcome.result()));
+	else
+		return GetInstanceConfigOutcome(outcome.error());
+}
+
+void OutboundBotClient::getInstanceConfigAsync(const GetInstanceConfigRequest& request, const GetInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getInstanceConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OutboundBotClient::GetInstanceConfigOutcomeCallable OutboundBotClient::getInstanceConfigCallable(const GetInstanceConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetInstanceConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->getInstanceConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OutboundBotClient::GetMaxAttemptsPerDayOutcome OutboundBotClient::getMaxAttemptsPerDay(const GetMaxAttemptsPerDayRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2355,42 @@ OutboundBotClient::ListDialogueFlowsOutcomeCallable OutboundBotClient::listDialo
 	return task->get_future();
 }
 
+OutboundBotClient::ListDownloadTasksOutcome OutboundBotClient::listDownloadTasks(const ListDownloadTasksRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListDownloadTasksOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListDownloadTasksOutcome(ListDownloadTasksResult(outcome.result()));
+	else
+		return ListDownloadTasksOutcome(outcome.error());
+}
+
+void OutboundBotClient::listDownloadTasksAsync(const ListDownloadTasksRequest& request, const ListDownloadTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listDownloadTasks(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OutboundBotClient::ListDownloadTasksOutcomeCallable OutboundBotClient::listDownloadTasksCallable(const ListDownloadTasksRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListDownloadTasksOutcome()>>(
+			[this, request]()
+			{
+			return this->listDownloadTasks(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OutboundBotClient::ListGlobalQuestionsOutcome OutboundBotClient::listGlobalQuestions(const ListGlobalQuestionsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3795,6 +3903,42 @@ OutboundBotClient::SaveMaxAttemptsPerDayOutcomeCallable OutboundBotClient::saveM
 	return task->get_future();
 }
 
+OutboundBotClient::SearchTaskOutcome OutboundBotClient::searchTask(const SearchTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SearchTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SearchTaskOutcome(SearchTaskResult(outcome.result()));
+	else
+		return SearchTaskOutcome(outcome.error());
+}
+
+void OutboundBotClient::searchTaskAsync(const SearchTaskRequest& request, const SearchTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, searchTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OutboundBotClient::SearchTaskOutcomeCallable OutboundBotClient::searchTaskCallable(const SearchTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SearchTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->searchTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OutboundBotClient::StartJobOutcome OutboundBotClient::startJob(const StartJobRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

outboundbot/src/model/CreateDownloadUrlRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/outboundbot/model/CreateDownloadUrlRequest.h>
+
+using AlibabaCloud::OutboundBot::Model::CreateDownloadUrlRequest;
+
+CreateDownloadUrlRequest::CreateDownloadUrlRequest() :
+	RpcServiceRequest("outboundbot", "2019-12-26", "CreateDownloadUrl")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+CreateDownloadUrlRequest::~CreateDownloadUrlRequest()
+{}
+
+std::string CreateDownloadUrlRequest::getDownloadTaskId()const
+{
+	return downloadTaskId_;
+}
+
+void CreateDownloadUrlRequest::setDownloadTaskId(const std::string& downloadTaskId)
+{
+	downloadTaskId_ = downloadTaskId;
+	setParameter("DownloadTaskId", downloadTaskId);
+}
+
+std::string CreateDownloadUrlRequest::getFileId()const
+{
+	return fileId_;
+}
+
+void CreateDownloadUrlRequest::setFileId(const std::string& fileId)
+{
+	fileId_ = fileId;
+	setParameter("FileId", fileId);
+}
+

outboundbot/src/model/CreateDownloadUrlResult.cc

@@ -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/outboundbot/model/CreateDownloadUrlResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::OutboundBot;
+using namespace AlibabaCloud::OutboundBot::Model;
+
+CreateDownloadUrlResult::CreateDownloadUrlResult() :
+	ServiceResult()
+{}
+
+CreateDownloadUrlResult::CreateDownloadUrlResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDownloadUrlResult::~CreateDownloadUrlResult()
+{}
+
+void CreateDownloadUrlResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["FileHttpUrl"].isNull())
+		fileHttpUrl_ = value["FileHttpUrl"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string CreateDownloadUrlResult::getMessage()const
+{
+	return message_;
+}
+
+int CreateDownloadUrlResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string CreateDownloadUrlResult::getFileHttpUrl()const
+{
+	return fileHttpUrl_;
+}
+
+std::string CreateDownloadUrlResult::getCode()const
+{
+	return code_;
+}
+
+bool CreateDownloadUrlResult::getSuccess()const
+{
+	return success_;
+}
+

outboundbot/src/model/DescribeJobResult.cc

@@ -40,56 +40,56 @@ void DescribeJobResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto jobNode = value["Job"];
-	if(!jobNode["FailureReason"].isNull())
-		job_.failureReason = jobNode["FailureReason"].asString();
-	if(!jobNode["JobGroupId"].isNull())
-		job_.jobGroupId = jobNode["JobGroupId"].asString();
-	if(!jobNode["JobId"].isNull())
-		job_.jobId = jobNode["JobId"].asString();
+	if(!jobNode["Status"].isNull())
+		job_.status = jobNode["Status"].asString();
+	if(!jobNode["ActualTime"].isNull())
+		job_.actualTime = std::stol(jobNode["ActualTime"].asString());
 	if(!jobNode["Priority"].isNull())
 		job_.priority = std::stoi(jobNode["Priority"].asString());
+	if(!jobNode["DsReport"].isNull())
+		job_.dsReport = jobNode["DsReport"].asString();
+	if(!jobNode["NextExecutionTime"].isNull())
+		job_.nextExecutionTime = std::stol(jobNode["NextExecutionTime"].asString());
+	if(!jobNode["FailureReason"].isNull())
+		job_.failureReason = jobNode["FailureReason"].asString();
+	if(!jobNode["SystemPriority"].isNull())
+		job_.systemPriority = std::stoi(jobNode["SystemPriority"].asString());
+	if(!jobNode["InstanceId"].isNull())
+		job_.instanceId = jobNode["InstanceId"].asString();
+	if(!jobNode["CalledNumber"].isNull())
+		job_.calledNumber = jobNode["CalledNumber"].asString();
 	if(!jobNode["ReferenceId"].isNull())
 		job_.referenceId = jobNode["ReferenceId"].asString();
+	if(!jobNode["JobGroupId"].isNull())
+		job_.jobGroupId = jobNode["JobGroupId"].asString();
 	if(!jobNode["ScenarioId"].isNull())
 		job_.scenarioId = jobNode["ScenarioId"].asString();
-	if(!jobNode["Status"].isNull())
-		job_.status = jobNode["Status"].asString();
 	if(!jobNode["StrategyId"].isNull())
 		job_.strategyId = jobNode["StrategyId"].asString();
-	if(!jobNode["SystemPriority"].isNull())
-		job_.systemPriority = std::stoi(jobNode["SystemPriority"].asString());
-	if(!jobNode["InstanceId"].isNull())
-		job_.instanceId = jobNode["InstanceId"].asString();
-	if(!jobNode["DsReport"].isNull())
-		job_.dsReport = jobNode["DsReport"].asString();
 	if(!jobNode["EndReason"].isNull())
 		job_.endReason = std::stoi(jobNode["EndReason"].asString());
-	if(!jobNode["ActualTime"].isNull())
-		job_.actualTime = std::stol(jobNode["ActualTime"].asString());
-	if(!jobNode["CalledNumber"].isNull())
-		job_.calledNumber = jobNode["CalledNumber"].asString();
-	if(!jobNode["NextExecutionTime"].isNull())
-		job_.nextExecutionTime = std::stol(jobNode["NextExecutionTime"].asString());
+	if(!jobNode["JobId"].isNull())
+		job_.jobId = jobNode["JobId"].asString();
 	auto allContactsNode = jobNode["Contacts"]["Contact"];
 	for (auto jobNodeContactsContact : allContactsNode)
 	{
 		Job::Contact contactObject;
+		if(!jobNodeContactsContact["PhoneNumber"].isNull())
+			contactObject.phoneNumber = jobNodeContactsContact["PhoneNumber"].asString();
+		if(!jobNodeContactsContact["State"].isNull())
+			contactObject.state = jobNodeContactsContact["State"].asString();
 		if(!jobNodeContactsContact["ContactId"].isNull())
 			contactObject.contactId = jobNodeContactsContact["ContactId"].asString();
-		if(!jobNodeContactsContact["ContactName"].isNull())
-			contactObject.contactName = jobNodeContactsContact["ContactName"].asString();
 		if(!jobNodeContactsContact["Honorific"].isNull())
 			contactObject.honorific = jobNodeContactsContact["Honorific"].asString();
 		if(!jobNodeContactsContact["JobId"].isNull())
 			contactObject.jobId = jobNodeContactsContact["JobId"].asString();
-		if(!jobNodeContactsContact["PhoneNumber"].isNull())
-			contactObject.phoneNumber = jobNodeContactsContact["PhoneNumber"].asString();
-		if(!jobNodeContactsContact["ReferenceId"].isNull())
-			contactObject.referenceId = jobNodeContactsContact["ReferenceId"].asString();
+		if(!jobNodeContactsContact["ContactName"].isNull())
+			contactObject.contactName = jobNodeContactsContact["ContactName"].asString();
 		if(!jobNodeContactsContact["Role"].isNull())
 			contactObject.role = jobNodeContactsContact["Role"].asString();
-		if(!jobNodeContactsContact["State"].isNull())
-			contactObject.state = jobNodeContactsContact["State"].asString();
+		if(!jobNodeContactsContact["ReferenceId"].isNull())
+			contactObject.referenceId = jobNodeContactsContact["ReferenceId"].asString();
 		job_.contacts.push_back(contactObject);
 	}
 	auto allExtrasNode = jobNode["Extras"]["KeyValuePair"];
@@ -106,100 +106,102 @@ void DescribeJobResult::parse(const std::string &payload)
 	for (auto jobNodeSummarySummaryItem : allSummaryNode)
 	{
 		Job::SummaryItem summaryItemObject;
+		if(!jobNodeSummarySummaryItem["SummaryName"].isNull())
+			summaryItemObject.summaryName = jobNodeSummarySummaryItem["SummaryName"].asString();
 		if(!jobNodeSummarySummaryItem["Category"].isNull())
 			summaryItemObject.category = jobNodeSummarySummaryItem["Category"].asString();
 		if(!jobNodeSummarySummaryItem["Content"].isNull())
 			summaryItemObject.content = jobNodeSummarySummaryItem["Content"].asString();
-		if(!jobNodeSummarySummaryItem["SummaryName"].isNull())
-			summaryItemObject.summaryName = jobNodeSummarySummaryItem["SummaryName"].asString();
 		job_.summary.push_back(summaryItemObject);
 	}
 	auto allTasksNode = jobNode["Tasks"]["Task"];
 	for (auto jobNodeTasksTask : allTasksNode)
 	{
 		Job::Task taskObject;
+		if(!jobNodeTasksTask["Status"].isNull())
+			taskObject.status = jobNodeTasksTask["Status"].asString();
+		if(!jobNodeTasksTask["PlanedTime"].isNull())
+			taskObject.planedTime = std::stol(jobNodeTasksTask["PlanedTime"].asString());
+		if(!jobNodeTasksTask["ChatbotId"].isNull())
+			taskObject.chatbotId = jobNodeTasksTask["ChatbotId"].asString();
 		if(!jobNodeTasksTask["ActualTime"].isNull())
 			taskObject.actualTime = std::stol(jobNodeTasksTask["ActualTime"].asString());
-		if(!jobNodeTasksTask["Brief"].isNull())
-			taskObject.brief = jobNodeTasksTask["Brief"].asString();
-		if(!jobNodeTasksTask["CallId"].isNull())
-			taskObject.callId = jobNodeTasksTask["CallId"].asString();
 		if(!jobNodeTasksTask["CalledNumber"].isNull())
 			taskObject.calledNumber = jobNodeTasksTask["CalledNumber"].asString();
+		if(!jobNodeTasksTask["EndTime"].isNull())
+			taskObject.endTime = std::stol(jobNodeTasksTask["EndTime"].asString());
+		if(!jobNodeTasksTask["ScenarioId"].isNull())
+			taskObject.scenarioId = jobNodeTasksTask["ScenarioId"].asString();
+		if(!jobNodeTasksTask["EndReason"].isNull())
+			taskObject.endReason = jobNodeTasksTask["EndReason"].asString();
+		if(!jobNodeTasksTask["JobId"].isNull())
+			taskObject.jobId = jobNodeTasksTask["JobId"].asString();
+		if(!jobNodeTasksTask["CallId"].isNull())
+			taskObject.callId = jobNodeTasksTask["CallId"].asString();
 		if(!jobNodeTasksTask["CallingNumber"].isNull())
 			taskObject.callingNumber = jobNodeTasksTask["CallingNumber"].asString();
-		if(!jobNodeTasksTask["ChatbotId"].isNull())
-			taskObject.chatbotId = jobNodeTasksTask["ChatbotId"].asString();
+		if(!jobNodeTasksTask["Brief"].isNull())
+			taskObject.brief = jobNodeTasksTask["Brief"].asString();
 		if(!jobNodeTasksTask["Duration"].isNull())
 			taskObject.duration = std::stoi(jobNodeTasksTask["Duration"].asString());
-		if(!jobNodeTasksTask["JobId"].isNull())
-			taskObject.jobId = jobNodeTasksTask["JobId"].asString();
-		if(!jobNodeTasksTask["PlanedTime"].isNull())
-			taskObject.planedTime = std::stol(jobNodeTasksTask["PlanedTime"].asString());
-		if(!jobNodeTasksTask["ScenarioId"].isNull())
-			taskObject.scenarioId = jobNodeTasksTask["ScenarioId"].asString();
-		if(!jobNodeTasksTask["Status"].isNull())
-			taskObject.status = jobNodeTasksTask["Status"].asString();
 		if(!jobNodeTasksTask["TaskId"].isNull())
 			taskObject.taskId = jobNodeTasksTask["TaskId"].asString();
-		if(!jobNodeTasksTask["EndTime"].isNull())
-			taskObject.endTime = std::stol(jobNodeTasksTask["EndTime"].asString());
-		if(!jobNodeTasksTask["EndReason"].isNull())
-			taskObject.endReason = jobNodeTasksTask["EndReason"].asString();
+		if(!jobNodeTasksTask["HangUpDirection"].isNull())
+			taskObject.hangUpDirection = jobNodeTasksTask["HangUpDirection"].asString();
 		auto allConversationNode = jobNodeTasksTask["Conversation"]["ConversationDetail"];
 		for (auto jobNodeTasksTaskConversationConversationDetail : allConversationNode)
 		{
 			Job::Task::ConversationDetail conversationObject;
-			if(!jobNodeTasksTaskConversationConversationDetail["Script"].isNull())
-				conversationObject.script = jobNodeTasksTaskConversationConversationDetail["Script"].asString();
-			if(!jobNodeTasksTaskConversationConversationDetail["Speaker"].isNull())
-				conversationObject.speaker = jobNodeTasksTaskConversationConversationDetail["Speaker"].asString();
-			if(!jobNodeTasksTaskConversationConversationDetail["Timestamp"].isNull())
-				conversationObject.timestamp = std::stol(jobNodeTasksTaskConversationConversationDetail["Timestamp"].asString());
-			if(!jobNodeTasksTaskConversationConversationDetail["Action"].isNull())
-				conversationObject.action = jobNodeTasksTaskConversationConversationDetail["Action"].asString();
 			if(!jobNodeTasksTaskConversationConversationDetail["ActionParams"].isNull())
 				conversationObject.actionParams = jobNodeTasksTaskConversationConversationDetail["ActionParams"].asString();
+			if(!jobNodeTasksTaskConversationConversationDetail["Action"].isNull())
+				conversationObject.action = jobNodeTasksTaskConversationConversationDetail["Action"].asString();
+			if(!jobNodeTasksTaskConversationConversationDetail["Timestamp"].isNull())
+				conversationObject.timestamp = std::stol(jobNodeTasksTaskConversationConversationDetail["Timestamp"].asString());
+			if(!jobNodeTasksTaskConversationConversationDetail["Speaker"].isNull())
+				conversationObject.speaker = jobNodeTasksTaskConversationConversationDetail["Speaker"].asString();
+			if(!jobNodeTasksTaskConversationConversationDetail["Script"].isNull())
+				conversationObject.script = jobNodeTasksTaskConversationConversationDetail["Script"].asString();
 			auto allSummary1Node = jobNodeTasksTaskConversationConversationDetail["Summary"]["SummaryItem"];
 			for (auto jobNodeTasksTaskConversationConversationDetailSummarySummaryItem : allSummary1Node)
 			{
 				Job::Task::ConversationDetail::SummaryItem2 summary1Object;
+				if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["SummaryName"].isNull())
+					summary1Object.summaryName = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["SummaryName"].asString();
 				if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Category"].isNull())
 					summary1Object.category = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Category"].asString();
 				if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Content"].isNull())
 					summary1Object.content = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Content"].asString();
-				if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["SummaryName"].isNull())
-					summary1Object.summaryName = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["SummaryName"].asString();
 				conversationObject.summary1.push_back(summary1Object);
 			}
 			taskObject.conversation.push_back(conversationObject);
 		}
 		auto contact3Node = value["Contact"];
+		if(!contact3Node["PhoneNumber"].isNull())
+			taskObject.contact3.phoneNumber = contact3Node["PhoneNumber"].asString();
+		if(!contact3Node["State"].isNull())
+			taskObject.contact3.state = contact3Node["State"].asString();
 		if(!contact3Node["ContactId"].isNull())
 			taskObject.contact3.contactId = contact3Node["ContactId"].asString();
-		if(!contact3Node["ContactName"].isNull())
-			taskObject.contact3.contactName = contact3Node["ContactName"].asString();
 		if(!contact3Node["Honorific"].isNull())
 			taskObject.contact3.honorific = contact3Node["Honorific"].asString();
 		if(!contact3Node["JobId"].isNull())
 			taskObject.contact3.jobId = contact3Node["JobId"].asString();
-		if(!contact3Node["PhoneNumber"].isNull())
-			taskObject.contact3.phoneNumber = contact3Node["PhoneNumber"].asString();
-		if(!contact3Node["ReferenceId"].isNull())
-			taskObject.contact3.referenceId = contact3Node["ReferenceId"].asString();
+		if(!contact3Node["ContactName"].isNull())
+			taskObject.contact3.contactName = contact3Node["ContactName"].asString();
 		if(!contact3Node["Role"].isNull())
 			taskObject.contact3.role = contact3Node["Role"].asString();
-		if(!contact3Node["State"].isNull())
-			taskObject.contact3.state = contact3Node["State"].asString();
+		if(!contact3Node["ReferenceId"].isNull())
+			taskObject.contact3.referenceId = contact3Node["ReferenceId"].asString();
 		job_.tasks.push_back(taskObject);
 	}
 		auto allCallingNumbers = jobNode["CallingNumbers"]["String"];
 		for (auto value : allCallingNumbers)
 			job_.callingNumbers.push_back(value.asString());
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
 	if(!value["Success"].isNull())

outboundbot/src/model/GetInstanceConfigRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/outboundbot/model/GetInstanceConfigRequest.h>
+
+using AlibabaCloud::OutboundBot::Model::GetInstanceConfigRequest;
+
+GetInstanceConfigRequest::GetInstanceConfigRequest() :
+	RpcServiceRequest("outboundbot", "2019-12-26", "GetInstanceConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetInstanceConfigRequest::~GetInstanceConfigRequest()
+{}
+
+std::string GetInstanceConfigRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void GetInstanceConfigRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

outboundbot/src/model/GetInstanceConfigResult.cc

@@ -0,0 +1,85 @@
+/*
+ * 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/outboundbot/model/GetInstanceConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::OutboundBot;
+using namespace AlibabaCloud::OutboundBot::Model;
+
+GetInstanceConfigResult::GetInstanceConfigResult() :
+	ServiceResult()
+{}
+
+GetInstanceConfigResult::GetInstanceConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetInstanceConfigResult::~GetInstanceConfigResult()
+{}
+
+void GetInstanceConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto instanceConfigNode = dataNode["InstanceConfig"];
+	if(!instanceConfigNode["MiniPlaybackSystemSwitch"].isNull())
+		data_.instanceConfig.miniPlaybackSystemSwitch = instanceConfigNode["MiniPlaybackSystemSwitch"].asString() == "true";
+	if(!instanceConfigNode["NewBargeInSystemSwitch"].isNull())
+		data_.instanceConfig.newBargeInSystemSwitch = instanceConfigNode["NewBargeInSystemSwitch"].asString() == "true";
+	if(!instanceConfigNode["SearchTaskFunctionSwitch"].isNull())
+		data_.instanceConfig.searchTaskFunctionSwitch = instanceConfigNode["SearchTaskFunctionSwitch"].asString() == "true";
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string GetInstanceConfigResult::getMessage()const
+{
+	return message_;
+}
+
+int GetInstanceConfigResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+GetInstanceConfigResult::Data GetInstanceConfigResult::getData()const
+{
+	return data_;
+}
+
+std::string GetInstanceConfigResult::getCode()const
+{
+	return code_;
+}
+
+bool GetInstanceConfigResult::getSuccess()const
+{
+	return success_;
+}
+

outboundbot/src/model/ListDownloadTasksRequest.cc

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

outboundbot/src/model/ListDownloadTasksResult.cc

@@ -0,0 +1,112 @@
+/*
+ * 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/outboundbot/model/ListDownloadTasksResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::OutboundBot;
+using namespace AlibabaCloud::OutboundBot::Model;
+
+ListDownloadTasksResult::ListDownloadTasksResult() :
+	ServiceResult()
+{}
+
+ListDownloadTasksResult::ListDownloadTasksResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListDownloadTasksResult::~ListDownloadTasksResult()
+{}
+
+void ListDownloadTasksResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto downloadTasksNode = value["DownloadTasks"];
+	if(!downloadTasksNode["PageNumber"].isNull())
+		downloadTasks_.pageNumber = std::stoi(downloadTasksNode["PageNumber"].asString());
+	if(!downloadTasksNode["PageSize"].isNull())
+		downloadTasks_.pageSize = std::stoi(downloadTasksNode["PageSize"].asString());
+	if(!downloadTasksNode["TotalCount"].isNull())
+		downloadTasks_.totalCount = std::stoi(downloadTasksNode["TotalCount"].asString());
+	auto allListNode = downloadTasksNode["List"]["DownloadTask"];
+	for (auto downloadTasksNodeListDownloadTask : allListNode)
+	{
+		DownloadTasks::DownloadTask downloadTaskObject;
+		if(!downloadTasksNodeListDownloadTask["Status"].isNull())
+			downloadTaskObject.status = downloadTasksNodeListDownloadTask["Status"].asString();
+		if(!downloadTasksNodeListDownloadTask["Title"].isNull())
+			downloadTaskObject.title = downloadTasksNodeListDownloadTask["Title"].asString();
+		if(!downloadTasksNodeListDownloadTask["ExpireTime"].isNull())
+			downloadTaskObject.expireTime = std::stol(downloadTasksNodeListDownloadTask["ExpireTime"].asString());
+		if(!downloadTasksNodeListDownloadTask["TaskId"].isNull())
+			downloadTaskObject.taskId = downloadTasksNodeListDownloadTask["TaskId"].asString();
+		auto allDownloadTaskFilesNode = downloadTasksNodeListDownloadTask["DownloadTaskFiles"]["DownloadTaskFile0"];
+		for (auto downloadTasksNodeListDownloadTaskDownloadTaskFilesDownloadTaskFile0 : allDownloadTaskFilesNode)
+		{
+			DownloadTasks::DownloadTask::DownloadTaskFile0 downloadTaskFilesObject;
+			if(!downloadTasksNodeListDownloadTaskDownloadTaskFilesDownloadTaskFile0["Status"].isNull())
+				downloadTaskFilesObject.status = downloadTasksNodeListDownloadTaskDownloadTaskFilesDownloadTaskFile0["Status"].asString();
+			if(!downloadTasksNodeListDownloadTaskDownloadTaskFilesDownloadTaskFile0["Title"].isNull())
+				downloadTaskFilesObject.title = downloadTasksNodeListDownloadTaskDownloadTaskFilesDownloadTaskFile0["Title"].asString();
+			if(!downloadTasksNodeListDownloadTaskDownloadTaskFilesDownloadTaskFile0["Progress"].isNull())
+				downloadTaskFilesObject.progress = std::stoi(downloadTasksNodeListDownloadTaskDownloadTaskFilesDownloadTaskFile0["Progress"].asString());
+			if(!downloadTasksNodeListDownloadTaskDownloadTaskFilesDownloadTaskFile0["FileId"].isNull())
+				downloadTaskFilesObject.fileId = downloadTasksNodeListDownloadTaskDownloadTaskFilesDownloadTaskFile0["FileId"].asString();
+			downloadTaskObject.downloadTaskFiles.push_back(downloadTaskFilesObject);
+		}
+		downloadTasks_.list.push_back(downloadTaskObject);
+	}
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+ListDownloadTasksResult::DownloadTasks ListDownloadTasksResult::getDownloadTasks()const
+{
+	return downloadTasks_;
+}
+
+std::string ListDownloadTasksResult::getMessage()const
+{
+	return message_;
+}
+
+int ListDownloadTasksResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string ListDownloadTasksResult::getCode()const
+{
+	return code_;
+}
+
+bool ListDownloadTasksResult::getSuccess()const
+{
+	return success_;
+}
+

outboundbot/src/model/QueryJobsWithResultResult.cc

@@ -40,45 +40,45 @@ void QueryJobsWithResultResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto jobsNode = value["Jobs"];
-	if(!jobsNode["PageCount"].isNull())
-		jobs_.pageCount = std::stoi(jobsNode["PageCount"].asString());
 	if(!jobsNode["PageNumber"].isNull())
 		jobs_.pageNumber = std::stoi(jobsNode["PageNumber"].asString());
 	if(!jobsNode["PageSize"].isNull())
 		jobs_.pageSize = std::stoi(jobsNode["PageSize"].asString());
+	if(!jobsNode["PageCount"].isNull())
+		jobs_.pageCount = std::stoi(jobsNode["PageCount"].asString());
 	if(!jobsNode["RowCount"].isNull())
 		jobs_.rowCount = std::stoi(jobsNode["RowCount"].asString());
 	auto allListNode = jobsNode["List"]["Job"];
 	for (auto jobsNodeListJob : allListNode)
 	{
 		Jobs::Job jobObject;
-		if(!jobsNodeListJob["JobFailureReason"].isNull())
-			jobObject.jobFailureReason = jobsNodeListJob["JobFailureReason"].asString();
+		if(!jobsNodeListJob["Status"].isNull())
+			jobObject.status = jobsNodeListJob["Status"].asString();
 		if(!jobsNodeListJob["StatusName"].isNull())
 			jobObject.statusName = jobsNodeListJob["StatusName"].asString();
+		if(!jobsNodeListJob["JobFailureReason"].isNull())
+			jobObject.jobFailureReason = jobsNodeListJob["JobFailureReason"].asString();
 		if(!jobsNodeListJob["Id"].isNull())
 			jobObject.id = jobsNodeListJob["Id"].asString();
-		if(!jobsNodeListJob["Status"].isNull())
-			jobObject.status = jobsNodeListJob["Status"].asString();
 		auto latestTaskNode = value["LatestTask"];
+		if(!latestTaskNode["Status"].isNull())
+			jobObject.latestTask.status = latestTaskNode["Status"].asString();
 		if(!latestTaskNode["TaskEndReason"].isNull())
 			jobObject.latestTask.taskEndReason = latestTaskNode["TaskEndReason"].asString();
-		if(!latestTaskNode["CallDuration"].isNull())
-			jobObject.latestTask.callDuration = std::stoi(latestTaskNode["CallDuration"].asString());
-		if(!latestTaskNode["CallDurationDisplay"].isNull())
-			jobObject.latestTask.callDurationDisplay = latestTaskNode["CallDurationDisplay"].asString();
-		if(!latestTaskNode["StatusName"].isNull())
-			jobObject.latestTask.statusName = latestTaskNode["StatusName"].asString();
 		if(!latestTaskNode["HasAnswered"].isNull())
 			jobObject.latestTask.hasAnswered = latestTaskNode["HasAnswered"].asString() == "true";
+		if(!latestTaskNode["CallDuration"].isNull())
+			jobObject.latestTask.callDuration = std::stoi(latestTaskNode["CallDuration"].asString());
 		if(!latestTaskNode["HasReachedEndOfFlow"].isNull())
 			jobObject.latestTask.hasReachedEndOfFlow = latestTaskNode["HasReachedEndOfFlow"].asString() == "true";
+		if(!latestTaskNode["StatusName"].isNull())
+			jobObject.latestTask.statusName = latestTaskNode["StatusName"].asString();
 		if(!latestTaskNode["CallTime"].isNull())
 			jobObject.latestTask.callTime = std::stol(latestTaskNode["CallTime"].asString());
+		if(!latestTaskNode["CallDurationDisplay"].isNull())
+			jobObject.latestTask.callDurationDisplay = latestTaskNode["CallDurationDisplay"].asString();
 		if(!latestTaskNode["HasHangUpByRejection"].isNull())
 			jobObject.latestTask.hasHangUpByRejection = latestTaskNode["HasHangUpByRejection"].asString() == "true";
-		if(!latestTaskNode["Status"].isNull())
-			jobObject.latestTask.status = latestTaskNode["Status"].asString();
 		auto allExtrasNode = latestTaskNode["Extras"]["Extra"];
 		for (auto latestTaskNodeExtrasExtra : allExtrasNode)
 		{
@@ -93,46 +93,56 @@ void QueryJobsWithResultResult::parse(const std::string &payload)
 		for (auto latestTaskNodeTagHitsTagHit : allTagHitsNode)
 		{
 			Jobs::Job::LatestTask::TagHit tagHitObject;
-			if(!latestTaskNodeTagHitsTagHit["TagGroup"].isNull())
-				tagHitObject.tagGroup = latestTaskNodeTagHitsTagHit["TagGroup"].asString();
 			if(!latestTaskNodeTagHitsTagHit["TagName"].isNull())
 				tagHitObject.tagName = latestTaskNodeTagHitsTagHit["TagName"].asString();
+			if(!latestTaskNodeTagHitsTagHit["TagGroup"].isNull())
+				tagHitObject.tagGroup = latestTaskNodeTagHitsTagHit["TagGroup"].asString();
 			jobObject.latestTask.tagHits.push_back(tagHitObject);
 		}
+		auto allDialExceptionCodesNode = latestTaskNode["DialExceptionCodes"]["ExceptionCode"];
+		for (auto latestTaskNodeDialExceptionCodesExceptionCode : allDialExceptionCodesNode)
+		{
+			Jobs::Job::LatestTask::ExceptionCode exceptionCodeObject;
+			if(!latestTaskNodeDialExceptionCodesExceptionCode["Code"].isNull())
+				exceptionCodeObject.code = latestTaskNodeDialExceptionCodesExceptionCode["Code"].asString();
+			if(!latestTaskNodeDialExceptionCodesExceptionCode["Hint"].isNull())
+				exceptionCodeObject.hint = latestTaskNodeDialExceptionCodesExceptionCode["Hint"].asString();
+			jobObject.latestTask.dialExceptionCodes.push_back(exceptionCodeObject);
+		}
 		auto contactNode = latestTaskNode["Contact"];
-		if(!contactNode["PreferredPhoneNumber"].isNull())
-			jobObject.latestTask.contact.preferredPhoneNumber = contactNode["PreferredPhoneNumber"].asString();
+		if(!contactNode["Round"].isNull())
+			jobObject.latestTask.contact.round = std::stoi(contactNode["Round"].asString());
 		if(!contactNode["JobUuid"].isNull())
 			jobObject.latestTask.contact.jobUuid = contactNode["JobUuid"].asString();
+		if(!contactNode["PreferredPhoneNumber"].isNull())
+			jobObject.latestTask.contact.preferredPhoneNumber = contactNode["PreferredPhoneNumber"].asString();
 		if(!contactNode["PhoneNumber"].isNull())
 			jobObject.latestTask.contact.phoneNumber = contactNode["PhoneNumber"].asString();
-		if(!contactNode["Role"].isNull())
-			jobObject.latestTask.contact.role = contactNode["Role"].asString();
-		if(!contactNode["Round"].isNull())
-			jobObject.latestTask.contact.round = std::stoi(contactNode["Round"].asString());
+		if(!contactNode["State"].isNull())
+			jobObject.latestTask.contact.state = contactNode["State"].asString();
+		if(!contactNode["Honorific"].isNull())
+			jobObject.latestTask.contact.honorific = contactNode["Honorific"].asString();
 		if(!contactNode["Name"].isNull())
 			jobObject.latestTask.contact.name = contactNode["Name"].asString();
+		if(!contactNode["Role"].isNull())
+			jobObject.latestTask.contact.role = contactNode["Role"].asString();
 		if(!contactNode["Id"].isNull())
 			jobObject.latestTask.contact.id = contactNode["Id"].asString();
-		if(!contactNode["State"].isNull())
-			jobObject.latestTask.contact.state = contactNode["State"].asString();
 		if(!contactNode["ReferenceId"].isNull())
 			jobObject.latestTask.contact.referenceId = contactNode["ReferenceId"].asString();
-		if(!contactNode["Honorific"].isNull())
-			jobObject.latestTask.contact.honorific = contactNode["Honorific"].asString();
 		jobs_.list.push_back(jobObject);
 	}
 	auto allVariableNames = value["VariableNames"]["VariableName"];
 	for (const auto &item : allVariableNames)
 		variableNames_.push_back(item.asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
-	if(!value["HttpStatusCode"].isNull())
-		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

outboundbot/src/model/RecordFailureRequest.cc

@@ -115,3 +115,14 @@ void RecordFailureRequest::setTaskId(const std::string& taskId)
 	setParameter("TaskId", taskId);
 }
 
+std::string RecordFailureRequest::getExceptionCodes()const
+{
+	return exceptionCodes_;
+}
+
+void RecordFailureRequest::setExceptionCodes(const std::string& exceptionCodes)
+{
+	exceptionCodes_ = exceptionCodes;
+	setParameter("ExceptionCodes", exceptionCodes);
+}
+

outboundbot/src/model/RecordFailureResult.cc

@@ -39,10 +39,10 @@ void RecordFailureResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
 	if(!value["Success"].isNull())

outboundbot/src/model/SearchTaskRequest.cc

@@ -0,0 +1,271 @@
+/*
+ * 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/outboundbot/model/SearchTaskRequest.h>
+
+using AlibabaCloud::OutboundBot::Model::SearchTaskRequest;
+
+SearchTaskRequest::SearchTaskRequest() :
+	RpcServiceRequest("outboundbot", "2019-12-26", "SearchTask")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+SearchTaskRequest::~SearchTaskRequest()
+{}
+
+long SearchTaskRequest::getActualTimeLte()const
+{
+	return actualTimeLte_;
+}
+
+void SearchTaskRequest::setActualTimeLte(long actualTimeLte)
+{
+	actualTimeLte_ = actualTimeLte;
+	setParameter("ActualTimeLte", std::to_string(actualTimeLte));
+}
+
+std::string SearchTaskRequest::getOtherId()const
+{
+	return otherId_;
+}
+
+void SearchTaskRequest::setOtherId(const std::string& otherId)
+{
+	otherId_ = otherId;
+	setParameter("OtherId", otherId);
+}
+
+long SearchTaskRequest::getTaskCreateTimeLte()const
+{
+	return taskCreateTimeLte_;
+}
+
+void SearchTaskRequest::setTaskCreateTimeLte(long taskCreateTimeLte)
+{
+	taskCreateTimeLte_ = taskCreateTimeLte;
+	setParameter("TaskCreateTimeLte", std::to_string(taskCreateTimeLte));
+}
+
+std::string SearchTaskRequest::getJobId()const
+{
+	return jobId_;
+}
+
+void SearchTaskRequest::setJobId(const std::string& jobId)
+{
+	jobId_ = jobId;
+	setParameter("JobId", jobId);
+}
+
+long SearchTaskRequest::getTaskCreateTimeGte()const
+{
+	return taskCreateTimeGte_;
+}
+
+void SearchTaskRequest::setTaskCreateTimeGte(long taskCreateTimeGte)
+{
+	taskCreateTimeGte_ = taskCreateTimeGte;
+	setParameter("TaskCreateTimeGte", std::to_string(taskCreateTimeGte));
+}
+
+std::string SearchTaskRequest::getCalledNumber()const
+{
+	return calledNumber_;
+}
+
+void SearchTaskRequest::setCalledNumber(const std::string& calledNumber)
+{
+	calledNumber_ = calledNumber;
+	setParameter("CalledNumber", calledNumber);
+}
+
+std::string SearchTaskRequest::getUserIdMatch()const
+{
+	return userIdMatch_;
+}
+
+void SearchTaskRequest::setUserIdMatch(const std::string& userIdMatch)
+{
+	userIdMatch_ = userIdMatch;
+	setParameter("UserIdMatch", userIdMatch);
+}
+
+int SearchTaskRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void SearchTaskRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+int SearchTaskRequest::getPageIndex()const
+{
+	return pageIndex_;
+}
+
+void SearchTaskRequest::setPageIndex(int pageIndex)
+{
+	pageIndex_ = pageIndex;
+	setParameter("PageIndex", std::to_string(pageIndex));
+}
+
+std::string SearchTaskRequest::getSortOrder()const
+{
+	return sortOrder_;
+}
+
+void SearchTaskRequest::setSortOrder(const std::string& sortOrder)
+{
+	sortOrder_ = sortOrder;
+	setParameter("SortOrder", sortOrder);
+}
+
+std::string SearchTaskRequest::getTaskStatusStringList()const
+{
+	return taskStatusStringList_;
+}
+
+void SearchTaskRequest::setTaskStatusStringList(const std::string& taskStatusStringList)
+{
+	taskStatusStringList_ = taskStatusStringList;
+	setParameter("TaskStatusStringList", taskStatusStringList);
+}
+
+std::string SearchTaskRequest::getJobGroupNameQuery()const
+{
+	return jobGroupNameQuery_;
+}
+
+void SearchTaskRequest::setJobGroupNameQuery(const std::string& jobGroupNameQuery)
+{
+	jobGroupNameQuery_ = jobGroupNameQuery;
+	setParameter("JobGroupNameQuery", jobGroupNameQuery);
+}
+
+std::string SearchTaskRequest::getTaskId()const
+{
+	return taskId_;
+}
+
+void SearchTaskRequest::setTaskId(const std::string& taskId)
+{
+	taskId_ = taskId;
+	setParameter("TaskId", taskId);
+}
+
+std::string SearchTaskRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void SearchTaskRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+long SearchTaskRequest::getRecordingDurationGte()const
+{
+	return recordingDurationGte_;
+}
+
+void SearchTaskRequest::setRecordingDurationGte(long recordingDurationGte)
+{
+	recordingDurationGte_ = recordingDurationGte;
+	setParameter("RecordingDurationGte", std::to_string(recordingDurationGte));
+}
+
+long SearchTaskRequest::getCallDurationLte()const
+{
+	return callDurationLte_;
+}
+
+void SearchTaskRequest::setCallDurationLte(long callDurationLte)
+{
+	callDurationLte_ = callDurationLte;
+	setParameter("CallDurationLte", std::to_string(callDurationLte));
+}
+
+std::string SearchTaskRequest::getJobGroupId()const
+{
+	return jobGroupId_;
+}
+
+void SearchTaskRequest::setJobGroupId(const std::string& jobGroupId)
+{
+	jobGroupId_ = jobGroupId;
+	setParameter("JobGroupId", jobGroupId);
+}
+
+std::string SearchTaskRequest::getSortBy()const
+{
+	return sortBy_;
+}
+
+void SearchTaskRequest::setSortBy(const std::string& sortBy)
+{
+	sortBy_ = sortBy;
+	setParameter("SortBy", sortBy);
+}
+
+std::string SearchTaskRequest::getJobStatusStringList()const
+{
+	return jobStatusStringList_;
+}
+
+void SearchTaskRequest::setJobStatusStringList(const std::string& jobStatusStringList)
+{
+	jobStatusStringList_ = jobStatusStringList;
+	setParameter("JobStatusStringList", jobStatusStringList);
+}
+
+long SearchTaskRequest::getActualTimeGte()const
+{
+	return actualTimeGte_;
+}
+
+void SearchTaskRequest::setActualTimeGte(long actualTimeGte)
+{
+	actualTimeGte_ = actualTimeGte;
+	setParameter("ActualTimeGte", std::to_string(actualTimeGte));
+}
+
+long SearchTaskRequest::getCallDurationGte()const
+{
+	return callDurationGte_;
+}
+
+void SearchTaskRequest::setCallDurationGte(long callDurationGte)
+{
+	callDurationGte_ = callDurationGte;
+	setParameter("CallDurationGte", std::to_string(callDurationGte));
+}
+
+long SearchTaskRequest::getRecordingDurationLte()const
+{
+	return recordingDurationLte_;
+}
+
+void SearchTaskRequest::setRecordingDurationLte(long recordingDurationLte)
+{
+	recordingDurationLte_ = recordingDurationLte;
+	setParameter("RecordingDurationLte", std::to_string(recordingDurationLte));
+}
+

outboundbot/src/model/SearchTaskResult.cc

@@ -0,0 +1,159 @@
+/*
+ * 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/outboundbot/model/SearchTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::OutboundBot;
+using namespace AlibabaCloud::OutboundBot::Model;
+
+SearchTaskResult::SearchTaskResult() :
+	ServiceResult()
+{}
+
+SearchTaskResult::SearchTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SearchTaskResult::~SearchTaskResult()
+{}
+
+void SearchTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSearchTaskInfoListNode = value["SearchTaskInfoList"]["SearchTaskInfo"];
+	for (auto valueSearchTaskInfoListSearchTaskInfo : allSearchTaskInfoListNode)
+	{
+		SearchTaskInfo searchTaskInfoListObject;
+		if(!valueSearchTaskInfoListSearchTaskInfo["JobGroupName"].isNull())
+			searchTaskInfoListObject.jobGroupName = valueSearchTaskInfoListSearchTaskInfo["JobGroupName"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["UserId"].isNull())
+			searchTaskInfoListObject.userId = valueSearchTaskInfoListSearchTaskInfo["UserId"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["ActualTime"].isNull())
+			searchTaskInfoListObject.actualTime = std::stol(valueSearchTaskInfoListSearchTaskInfo["ActualTime"].asString());
+		if(!valueSearchTaskInfoListSearchTaskInfo["CalledNumber"].isNull())
+			searchTaskInfoListObject.calledNumber = valueSearchTaskInfoListSearchTaskInfo["CalledNumber"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["TaskStatusString"].isNull())
+			searchTaskInfoListObject.taskStatusString = valueSearchTaskInfoListSearchTaskInfo["TaskStatusString"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["TaskStatusName"].isNull())
+			searchTaskInfoListObject.taskStatusName = valueSearchTaskInfoListSearchTaskInfo["TaskStatusName"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["JobStatus"].isNull())
+			searchTaskInfoListObject.jobStatus = std::stoi(valueSearchTaskInfoListSearchTaskInfo["JobStatus"].asString());
+		if(!valueSearchTaskInfoListSearchTaskInfo["DialException"].isNull())
+			searchTaskInfoListObject.dialException = valueSearchTaskInfoListSearchTaskInfo["DialException"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["UserName"].isNull())
+			searchTaskInfoListObject.userName = valueSearchTaskInfoListSearchTaskInfo["UserName"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["CallDurationDisplay"].isNull())
+			searchTaskInfoListObject.callDurationDisplay = valueSearchTaskInfoListSearchTaskInfo["CallDurationDisplay"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["HasAnswered"].isNull())
+			searchTaskInfoListObject.hasAnswered = valueSearchTaskInfoListSearchTaskInfo["HasAnswered"].asString() == "true";
+		if(!valueSearchTaskInfoListSearchTaskInfo["JobStatusName"].isNull())
+			searchTaskInfoListObject.jobStatusName = valueSearchTaskInfoListSearchTaskInfo["JobStatusName"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["CallDuration"].isNull())
+			searchTaskInfoListObject.callDuration = std::stoi(valueSearchTaskInfoListSearchTaskInfo["CallDuration"].asString());
+		if(!valueSearchTaskInfoListSearchTaskInfo["TaskCreateTime"].isNull())
+			searchTaskInfoListObject.taskCreateTime = std::stol(valueSearchTaskInfoListSearchTaskInfo["TaskCreateTime"].asString());
+		if(!valueSearchTaskInfoListSearchTaskInfo["JobStatusString"].isNull())
+			searchTaskInfoListObject.jobStatusString = valueSearchTaskInfoListSearchTaskInfo["JobStatusString"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["HasReachedEndOfFlow"].isNull())
+			searchTaskInfoListObject.hasReachedEndOfFlow = valueSearchTaskInfoListSearchTaskInfo["HasReachedEndOfFlow"].asString() == "true";
+		if(!valueSearchTaskInfoListSearchTaskInfo["InstanceId"].isNull())
+			searchTaskInfoListObject.instanceId = valueSearchTaskInfoListSearchTaskInfo["InstanceId"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["HasHangUpByRejection"].isNull())
+			searchTaskInfoListObject.hasHangUpByRejection = valueSearchTaskInfoListSearchTaskInfo["HasHangUpByRejection"].asString() == "true";
+		if(!valueSearchTaskInfoListSearchTaskInfo["TaskEndReason"].isNull())
+			searchTaskInfoListObject.taskEndReason = std::stoi(valueSearchTaskInfoListSearchTaskInfo["TaskEndReason"].asString());
+		if(!valueSearchTaskInfoListSearchTaskInfo["JobGroupId"].isNull())
+			searchTaskInfoListObject.jobGroupId = valueSearchTaskInfoListSearchTaskInfo["JobGroupId"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["TaskStatus"].isNull())
+			searchTaskInfoListObject.taskStatus = std::stoi(valueSearchTaskInfoListSearchTaskInfo["TaskStatus"].asString());
+		if(!valueSearchTaskInfoListSearchTaskInfo["JobId"].isNull())
+			searchTaskInfoListObject.jobId = valueSearchTaskInfoListSearchTaskInfo["JobId"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["RecordingDuration"].isNull())
+			searchTaskInfoListObject.recordingDuration = std::stoi(valueSearchTaskInfoListSearchTaskInfo["RecordingDuration"].asString());
+		if(!valueSearchTaskInfoListSearchTaskInfo["TaskId"].isNull())
+			searchTaskInfoListObject.taskId = valueSearchTaskInfoListSearchTaskInfo["TaskId"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["DialExceptionOld"].isNull())
+			searchTaskInfoListObject.dialExceptionOld = valueSearchTaskInfoListSearchTaskInfo["DialExceptionOld"].asString();
+		if(!valueSearchTaskInfoListSearchTaskInfo["HasLastPlaybackCompleted"].isNull())
+			searchTaskInfoListObject.hasLastPlaybackCompleted = valueSearchTaskInfoListSearchTaskInfo["HasLastPlaybackCompleted"].asString() == "true";
+		auto allDialExceptionCodes = value["DialExceptionCodes"]["String"];
+		for (auto value : allDialExceptionCodes)
+			searchTaskInfoListObject.dialExceptionCodes.push_back(value.asString());
+		searchTaskInfoList_.push_back(searchTaskInfoListObject);
+	}
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["PageIndex"].isNull())
+		pageIndex_ = std::stoi(value["PageIndex"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["Total"].isNull())
+		total_ = std::stol(value["Total"].asString());
+
+}
+
+std::string SearchTaskResult::getMessage()const
+{
+	return message_;
+}
+
+int SearchTaskResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+long SearchTaskResult::getTotal()const
+{
+	return total_;
+}
+
+int SearchTaskResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+int SearchTaskResult::getPageIndex()const
+{
+	return pageIndex_;
+}
+
+std::string SearchTaskResult::getCode()const
+{
+	return code_;
+}
+
+std::vector<SearchTaskResult::SearchTaskInfo> SearchTaskResult::getSearchTaskInfoList()const
+{
+	return searchTaskInfoList_;
+}
+
+bool SearchTaskResult::getSuccess()const
+{
+	return success_;
+}
+