Supported CallerLocation, CalleeLocation in CDR API.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-09-13 Version: 1.36.872
+- Supported CallerLocation, CalleeLocation in CDR API.
+
 2021-09-10 Version: 1.36.871
 - Support crop face image.
 

VERSION

@@ -1 +1 @@
-1.36.871
+1.36.872

ccc/CMakeLists.txt

@@ -145,6 +145,8 @@ set(ccc_public_header_model
 	include/alibabacloud/ccc/model/ListSkillGroupsResult.h
 	include/alibabacloud/ccc/model/ListSkillLevelsOfUserRequest.h
 	include/alibabacloud/ccc/model/ListSkillLevelsOfUserResult.h
+	include/alibabacloud/ccc/model/ListUnassignedNumbersRequest.h
+	include/alibabacloud/ccc/model/ListUnassignedNumbersResult.h
 	include/alibabacloud/ccc/model/ListUserLevelsOfSkillGroupRequest.h
 	include/alibabacloud/ccc/model/ListUserLevelsOfSkillGroupResult.h
 	include/alibabacloud/ccc/model/ListUsersRequest.h
@@ -213,6 +215,8 @@ set(ccc_public_header_model
 	include/alibabacloud/ccc/model/SignOutGroupResult.h
 	include/alibabacloud/ccc/model/StartBack2BackCallRequest.h
 	include/alibabacloud/ccc/model/StartBack2BackCallResult.h
+	include/alibabacloud/ccc/model/StartPredictiveCallRequest.h
+	include/alibabacloud/ccc/model/StartPredictiveCallResult.h
 	include/alibabacloud/ccc/model/TakeBreakRequest.h
 	include/alibabacloud/ccc/model/TakeBreakResult.h
 	include/alibabacloud/ccc/model/UnmuteCallRequest.h
@@ -346,6 +350,8 @@ set(ccc_src
 	src/model/ListSkillGroupsResult.cc
 	src/model/ListSkillLevelsOfUserRequest.cc
 	src/model/ListSkillLevelsOfUserResult.cc
+	src/model/ListUnassignedNumbersRequest.cc
+	src/model/ListUnassignedNumbersResult.cc
 	src/model/ListUserLevelsOfSkillGroupRequest.cc
 	src/model/ListUserLevelsOfSkillGroupResult.cc
 	src/model/ListUsersRequest.cc
@@ -414,6 +420,8 @@ set(ccc_src
 	src/model/SignOutGroupResult.cc
 	src/model/StartBack2BackCallRequest.cc
 	src/model/StartBack2BackCallResult.cc
+	src/model/StartPredictiveCallRequest.cc
+	src/model/StartPredictiveCallResult.cc
 	src/model/TakeBreakRequest.cc
 	src/model/TakeBreakResult.cc
 	src/model/UnmuteCallRequest.cc

ccc/include/alibabacloud/ccc/CCCClient.h

@@ -146,6 +146,8 @@
 #include "model/ListSkillGroupsResult.h"
 #include "model/ListSkillLevelsOfUserRequest.h"
 #include "model/ListSkillLevelsOfUserResult.h"
+#include "model/ListUnassignedNumbersRequest.h"
+#include "model/ListUnassignedNumbersResult.h"
 #include "model/ListUserLevelsOfSkillGroupRequest.h"
 #include "model/ListUserLevelsOfSkillGroupResult.h"
 #include "model/ListUsersRequest.h"
@@ -214,6 +216,8 @@
 #include "model/SignOutGroupResult.h"
 #include "model/StartBack2BackCallRequest.h"
 #include "model/StartBack2BackCallResult.h"
+#include "model/StartPredictiveCallRequest.h"
+#include "model/StartPredictiveCallResult.h"
 #include "model/TakeBreakRequest.h"
 #include "model/TakeBreakResult.h"
 #include "model/UnmuteCallRequest.h"
@@ -415,6 +419,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListSkillLevelsOfUserResult> ListSkillLevelsOfUserOutcome;
 			typedef std::future<ListSkillLevelsOfUserOutcome> ListSkillLevelsOfUserOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::ListSkillLevelsOfUserRequest&, const ListSkillLevelsOfUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSkillLevelsOfUserAsyncHandler;
+			typedef Outcome<Error, Model::ListUnassignedNumbersResult> ListUnassignedNumbersOutcome;
+			typedef std::future<ListUnassignedNumbersOutcome> ListUnassignedNumbersOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::ListUnassignedNumbersRequest&, const ListUnassignedNumbersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUnassignedNumbersAsyncHandler;
 			typedef Outcome<Error, Model::ListUserLevelsOfSkillGroupResult> ListUserLevelsOfSkillGroupOutcome;
 			typedef std::future<ListUserLevelsOfSkillGroupOutcome> ListUserLevelsOfSkillGroupOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::ListUserLevelsOfSkillGroupRequest&, const ListUserLevelsOfSkillGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUserLevelsOfSkillGroupAsyncHandler;
@@ -517,6 +524,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::StartBack2BackCallResult> StartBack2BackCallOutcome;
 			typedef std::future<StartBack2BackCallOutcome> StartBack2BackCallOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::StartBack2BackCallRequest&, const StartBack2BackCallOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartBack2BackCallAsyncHandler;
+			typedef Outcome<Error, Model::StartPredictiveCallResult> StartPredictiveCallOutcome;
+			typedef std::future<StartPredictiveCallOutcome> StartPredictiveCallOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::StartPredictiveCallRequest&, const StartPredictiveCallOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartPredictiveCallAsyncHandler;
 			typedef Outcome<Error, Model::TakeBreakResult> TakeBreakOutcome;
 			typedef std::future<TakeBreakOutcome> TakeBreakOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::TakeBreakRequest&, const TakeBreakOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TakeBreakAsyncHandler;
@@ -717,6 +727,9 @@ namespace AlibabaCloud
 			ListSkillLevelsOfUserOutcome listSkillLevelsOfUser(const Model::ListSkillLevelsOfUserRequest &request)const;
 			void listSkillLevelsOfUserAsync(const Model::ListSkillLevelsOfUserRequest& request, const ListSkillLevelsOfUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListSkillLevelsOfUserOutcomeCallable listSkillLevelsOfUserCallable(const Model::ListSkillLevelsOfUserRequest& request) const;
+			ListUnassignedNumbersOutcome listUnassignedNumbers(const Model::ListUnassignedNumbersRequest &request)const;
+			void listUnassignedNumbersAsync(const Model::ListUnassignedNumbersRequest& request, const ListUnassignedNumbersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListUnassignedNumbersOutcomeCallable listUnassignedNumbersCallable(const Model::ListUnassignedNumbersRequest& request) const;
 			ListUserLevelsOfSkillGroupOutcome listUserLevelsOfSkillGroup(const Model::ListUserLevelsOfSkillGroupRequest &request)const;
 			void listUserLevelsOfSkillGroupAsync(const Model::ListUserLevelsOfSkillGroupRequest& request, const ListUserLevelsOfSkillGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListUserLevelsOfSkillGroupOutcomeCallable listUserLevelsOfSkillGroupCallable(const Model::ListUserLevelsOfSkillGroupRequest& request) const;
@@ -819,6 +832,9 @@ namespace AlibabaCloud
 			StartBack2BackCallOutcome startBack2BackCall(const Model::StartBack2BackCallRequest &request)const;
 			void startBack2BackCallAsync(const Model::StartBack2BackCallRequest& request, const StartBack2BackCallAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartBack2BackCallOutcomeCallable startBack2BackCallCallable(const Model::StartBack2BackCallRequest& request) const;
+			StartPredictiveCallOutcome startPredictiveCall(const Model::StartPredictiveCallRequest &request)const;
+			void startPredictiveCallAsync(const Model::StartPredictiveCallRequest& request, const StartPredictiveCallAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartPredictiveCallOutcomeCallable startPredictiveCallCallable(const Model::StartPredictiveCallRequest& request) const;
 			TakeBreakOutcome takeBreak(const Model::TakeBreakRequest &request)const;
 			void takeBreakAsync(const Model::TakeBreakRequest& request, const TakeBreakAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			TakeBreakOutcomeCallable takeBreakCallable(const Model::TakeBreakRequest& request) const;

ccc/include/alibabacloud/ccc/model/GetCallDetailRecordResult.h

@@ -42,8 +42,8 @@ namespace AlibabaCloud
 							std::string event;
 						};
 						std::vector<AgentEventsItem::EventSequenceItem> eventSequence;
-						std::string agentId;
 						std::string agentName;
+						std::string agentId;
 						std::string skillGroupId;
 					};
 					struct IvrEventsItem
@@ -73,22 +73,24 @@ namespace AlibabaCloud
 					std::string skillGroupIds;
 					std::string calledNumber;
 					std::string contactType;
+					std::string releaseInitiator;
 					std::string contactDisposition;
 					std::string instanceId;
-					std::string releaseInitiator;
 					int satisfaction;
 					long startTime;
 					std::string contactId;
 					long callDuration;
 					std::string callingNumber;
 					std::vector<QueueEventsItem> queueEvents;
-					long releaseTime;
+					std::string calleeLocation;
 					bool recordingReady;
+					long releaseTime;
 					std::string skillGroupNames;
 					std::string satisfactionSurveyChannel;
 					std::string agentIds;
 					bool satisfactionSurveyOffered;
 					long establishedTime;
+					std::string callerLocation;
 					std::string agentNames;
 					std::vector<IvrEventsItem> ivrEvents;
 				};

ccc/include/alibabacloud/ccc/model/GetHistoricalInstanceReportResult.h

@@ -36,43 +36,51 @@ namespace AlibabaCloud
 				{
 					struct Inbound
 					{
-						long callsAbandonedInQueue;
 						float serviceLevel20;
 						long totalWorkTime;
-						long callsRinged;
 						long totalHoldTime;
-						float averageHoldTime;
+						long callsRinged;
 						long maxAbandonedInIVRTime;
-						long callsAbandoned;
 						long callsOffered;
-						long maxRingTime;
-						long callsHold;
 						float satisfactionIndex;
-						long maxAbandonedInRingTime;
+						long callsHold;
 						long totalRingTime;
 						float handleRate;
 						float averageAbandonedInQueueTime;
-						long totalAbandonedInIVRTime;
-						float averageWaitTime;
 						long totalTalkTime;
+						float averageWaitTime;
 						long totalAbandonedInRingTime;
+						long callsQueuingOverflow;
+						long totalAbandonTime;
+						long callsQueuingFailed;
+						long callsBlindTransferred;
+						long maxAbandonedInQueueTime;
+						long satisfactionSurveysOffered;
+						long callsAbandonedInRing;
+						long callsAttendedTransferred;
+						float averageRingTime;
+						float abandonRate;
+						long callsIVRException;
+						long callsAbandonedInQueue;
+						float averageHoldTime;
+						long callsAbandoned;
+						long maxRingTime;
+						long maxAbandonedInRingTime;
+						long totalAbandonedInIVRTime;
+						long callsForwardToOutsideNumber;
 						long callsQueued;
 						long maxTalkTime;
 						float averageAbandonedInIVRTime;
 						float satisfactionRate;
-						long totalAbandonTime;
+						long callsQueuingTimeout;
 						float averageTalkTime;
 						long maxHoldTime;
 						long callsAbandonedInIVR;
-						long callsBlindTransferred;
-						long maxAbandonedInQueueTime;
-						long satisfactionSurveysOffered;
-						long callsAbandonedInRing;
+						long callsAbandonedInVoiceNavigator;
+						long callsVoicemail;
 						long callsHandled;
 						long maxWaitTime;
 						long satisfactionSurveysResponded;
-						long callsAttendedTransferred;
-						float averageRingTime;
 						long maxAbandonTime;
 						long totalWaitTime;
 						float averageAbandonTime;
@@ -80,18 +88,17 @@ namespace AlibabaCloud
 						float averageWorkTime;
 						long totalAbandonedInQueueTime;
 						long maxWorkTime;
-						float abandonRate;
 					};
 					struct Outbound
 					{
 						long totalDialingTime;
 						long totalWorkTime;
-						long callsRinged;
 						long totalHoldTime;
+						long callsRinged;
 						float averageHoldTime;
 						long maxRingTime;
-						int callsHold;
 						float satisfactionIndex;
+						int callsHold;
 						long totalRingTime;
 						float averageDialingTime;
 						long callsAnswered;
@@ -101,8 +108,8 @@ namespace AlibabaCloud
 						long maxTalkTime;
 						float satisfactionRate;
 						float answerRate;
-						float averageTalkTime;
 						long maxHoldTime;
+						float averageTalkTime;
 						long callsBlindTransferred;
 						long satisfactionSurveysOffered;
 						long satisfactionSurveysResponded;
@@ -118,8 +125,8 @@ namespace AlibabaCloud
 						long totalCalls;
 						long totalWorkTime;
 						long totalHoldTime;
-						float averageHoldTime;
 						long satisfactionSurveysOffered;
+						float averageHoldTime;
 						float satisfactionIndex;
 						float averageBreakTime;
 						long satisfactionSurveysResponded;
@@ -127,14 +134,14 @@ namespace AlibabaCloud
 						float averageReadyTime;
 						long totalLoggedInTime;
 						long maxTalkTime;
+						float satisfactionRate;
 						float averageWorkTime;
 						long maxReadyTime;
-						float satisfactionRate;
-						long maxBreakTime;
 						long maxWorkTime;
-						float averageTalkTime;
-						long maxHoldTime;
+						long maxBreakTime;
 						float occupancyRate;
+						long maxHoldTime;
+						float averageTalkTime;
 					};
 					Outbound outbound;
 					Overall overall;

ccc/include/alibabacloud/ccc/model/ListCallDetailRecordsResult.h

@@ -49,16 +49,20 @@ namespace AlibabaCloud
 						long establishedTime;
 						long queueTime;
 						std::string skillGroupIds;
-						std::string instanceId;
+						std::string broker;
 						std::string releaseInitiator;
+						std::string instanceId;
 						long startTime;
 						long ringTime;
 						std::string callDuration;
+						std::string calleeLocation;
 						long releaseTime;
 						std::string satisfactionSurveyChannel;
-						std::string agentIds;
+						std::string additionalBroker;
 						std::string satisfactionDescription;
+						std::string agentIds;
 						long waitTime;
+						std::string callerLocation;
 						std::string agentNames;
 						long recordingDuration;
 					};

ccc/include/alibabacloud/ccc/model/ListIntervalInstanceReportResult.h

@@ -36,43 +36,50 @@ namespace AlibabaCloud
 				{
 					struct Inbound
 					{
-						long callsAbandonedInQueue;
 						float serviceLevel20;
 						long totalWorkTime;
-						long callsRinged;
 						long totalHoldTime;
-						float averageHoldTime;
+						long callsRinged;
 						long maxAbandonedInIVRTime;
-						long callsAbandoned;
 						long callsOffered;
-						long maxRingTime;
-						long callsHold;
 						float satisfactionIndex;
-						long maxAbandonedInRingTime;
+						long callsHold;
 						long totalRingTime;
 						float handleRate;
 						float averageAbandonedInQueueTime;
-						long totalAbandonedInIVRTime;
-						float averageWaitTime;
 						long totalTalkTime;
+						float averageWaitTime;
 						long totalAbandonedInRingTime;
+						long callsQueuingOverflow;
+						long totalAbandonTime;
+						long callsQueuingFailed;
+						long callsBlindTransferred;
+						long maxAbandonedInQueueTime;
+						long satisfactionSurveysOffered;
+						long callsAbandonedInRing;
+						long callsAttendedTransferred;
+						float averageRingTime;
+						long callsIVRException;
+						long callsAbandonedInQueue;
+						float averageHoldTime;
+						long callsAbandoned;
+						long maxRingTime;
+						long maxAbandonedInRingTime;
+						long totalAbandonedInIVRTime;
+						long callsForwardToOutsideNumber;
 						long callsQueued;
 						long maxTalkTime;
 						float averageAbandonedInIVRTime;
 						float satisfactionRate;
-						long totalAbandonTime;
+						long callsQueuingTimeout;
 						float averageTalkTime;
 						long maxHoldTime;
 						long callsAbandonedInIVR;
-						long callsBlindTransferred;
-						long maxAbandonedInQueueTime;
-						long satisfactionSurveysOffered;
-						long callsAbandonedInRing;
+						long callsAbandonedInVoiceNavigator;
+						long callsVoicemail;
 						long callsHandled;
 						long maxWaitTime;
 						long satisfactionSurveysResponded;
-						long callsAttendedTransferred;
-						float averageRingTime;
 						long maxAbandonTime;
 						long totalWaitTime;
 						float averageAbandonTime;
@@ -86,12 +93,12 @@ namespace AlibabaCloud
 					{
 						long totalDialingTime;
 						long totalWorkTime;
-						long callsRinged;
 						long totalHoldTime;
+						long callsRinged;
 						float averageHoldTime;
 						long maxRingTime;
-						long callsHold;
 						float satisfactionIndex;
+						long callsHold;
 						long totalRingTime;
 						float averageDialingTime;
 						long callsAnswered;
@@ -101,8 +108,8 @@ namespace AlibabaCloud
 						long maxTalkTime;
 						float satisfactionRate;
 						float answerRate;
-						float averageTalkTime;
 						long maxHoldTime;
+						float averageTalkTime;
 						long callsBlindTransferred;
 						long satisfactionSurveysOffered;
 						long satisfactionSurveysResponded;
@@ -118,8 +125,8 @@ namespace AlibabaCloud
 						long totalCalls;
 						long totalWorkTime;
 						long totalHoldTime;
-						float averageHoldTime;
 						long satisfactionSurveysOffered;
+						float averageHoldTime;
 						float satisfactionIndex;
 						float averageBreakTime;
 						long satisfactionSurveysResponded;
@@ -127,14 +134,14 @@ namespace AlibabaCloud
 						float averageReadyTime;
 						long totalLoggedInTime;
 						long maxTalkTime;
+						float satisfactionRate;
 						float averageWorkTime;
 						long maxReadyTime;
-						float satisfactionRate;
-						long maxBreakTime;
 						long maxWorkTime;
-						float averageTalkTime;
-						long maxHoldTime;
+						long maxBreakTime;
 						float occupancyRate;
+						long maxHoldTime;
+						float averageTalkTime;
 					};
 					Outbound outbound;
 					Overall overall;

ccc/include/alibabacloud/ccc/model/ListUnassignedNumbersRequest.h

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

ccc/include/alibabacloud/ccc/model/ListUnassignedNumbersResult.h

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

ccc/include/alibabacloud/ccc/model/MakeCallRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setUserId(const std::string& userId);
 				std::string getDeviceId()const;
 				void setDeviceId(const std::string& deviceId);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
 				int getTimeoutSeconds()const;
 				void setTimeoutSeconds(int timeoutSeconds);
 				std::string getCaller()const;
@@ -52,6 +54,7 @@ namespace AlibabaCloud
 				std::string callee_;
 				std::string userId_;
 				std::string deviceId_;
+				std::string tags_;
 				int timeoutSeconds_;
 				std::string caller_;
 				std::string instanceId_;

ccc/include/alibabacloud/ccc/model/MakeCallResult.h

@@ -62,12 +62,12 @@ namespace AlibabaCloud
 						std::string extension;
 						std::string userState;
 						std::string instanceId;
-						std::string breakCode;
 						std::string deviceId;
 						std::string userId;
+						std::string breakCode;
 						bool outboundScenario;
-						std::string jobId;
 						std::string workMode;
+						std::string jobId;
 						std::vector<std::string> signedSkillGroupIdList;
 					};
 					UserContext userContext;

ccc/include/alibabacloud/ccc/model/PollUserStatusResult.h

@@ -43,8 +43,8 @@ namespace AlibabaCloud
 							std::string releaseInitiator;
 							std::string callType;
 							int index;
-							std::string associatedData;
 							std::string skillGroupId;
+							std::string associatedData;
 							std::string channelId;
 							long timestamp;
 							std::string channelVariables;
@@ -64,16 +64,16 @@ namespace AlibabaCloud
 					{
 						std::string userState;
 						std::string instanceId;
-						std::string breakCode;
 						std::string deviceId;
+						std::string breakCode;
 						bool outboundScenario;
 						std::string mobile;
 						std::vector<std::string> signedSkillGroupIdList;
 						std::string extension;
 						std::string userId;
 						long heartbeat;
-						std::string jobId;
 						std::string workMode;
+						std::string jobId;
 						long reserved;
 					};
 					UserContext userContext;

ccc/include/alibabacloud/ccc/model/StartBack2BackCallRequest.h

@@ -39,10 +39,6 @@ namespace AlibabaCloud
 				void setCallee(const std::string& callee);
 				std::string getBroker()const;
 				void setBroker(const std::string& broker);
-				std::string getUserId()const;
-				void setUserId(const std::string& userId);
-				std::string getDeviceId()const;
-				void setDeviceId(const std::string& deviceId);
 				std::string getAdditionalBroker()const;
 				void setAdditionalBroker(const std::string& additionalBroker);
 				std::string getTags()const;
@@ -57,8 +53,6 @@ namespace AlibabaCloud
             private:
 				std::string callee_;
 				std::string broker_;
-				std::string userId_;
-				std::string deviceId_;
 				std::string additionalBroker_;
 				std::string tags_;
 				int timeoutSeconds_;

ccc/include/alibabacloud/ccc/model/StartPredictiveCallRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CCC_MODEL_STARTPREDICTIVECALLREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_STARTPREDICTIVECALLREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT StartPredictiveCallRequest : public RpcServiceRequest
+			{
+
+			public:
+				StartPredictiveCallRequest();
+				~StartPredictiveCallRequest();
+
+				std::string getContactFlowId()const;
+				void setContactFlowId(const std::string& contactFlowId);
+				std::string getCallee()const;
+				void setCallee(const std::string& callee);
+				std::string getContactFlowVariables()const;
+				void setContactFlowVariables(const std::string& contactFlowVariables);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+				int getTimeoutSeconds()const;
+				void setTimeoutSeconds(int timeoutSeconds);
+				std::string getCaller()const;
+				void setCaller(const std::string& caller);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				std::string contactFlowId_;
+				std::string callee_;
+				std::string contactFlowVariables_;
+				std::string tags_;
+				int timeoutSeconds_;
+				std::string caller_;
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_STARTPREDICTIVECALLREQUEST_H_

ccc/include/alibabacloud/ccc/model/StartPredictiveCallResult.h

@@ -0,0 +1,104 @@
+/*
+ * 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_CCC_MODEL_STARTPREDICTIVECALLRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_STARTPREDICTIVECALLRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT StartPredictiveCallResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct CallContext
+					{
+						struct ChannelContext
+						{
+							std::string destination;
+							std::string channelState;
+							std::string releaseInitiator;
+							std::string callType;
+							std::string associatedData;
+							std::string channelId;
+							long timestamp;
+							std::string releaseReason;
+							std::string channelFlags;
+							std::string originator;
+							std::string userId;
+							std::string userExtension;
+							std::string jobId;
+						};
+						std::string instanceId;
+						std::string callType;
+						std::string jobId;
+						std::vector<ChannelContext> channelContexts;
+					};
+					struct UserContext
+					{
+						std::string userState;
+						std::string instanceId;
+						std::string deviceId;
+						std::string breakCode;
+						bool outboundScenario;
+						std::string mobile;
+						std::vector<std::string> signedSkillGroupIdList;
+						std::string extension;
+						std::string deviceState;
+						std::string userId;
+						long heartbeat;
+						std::string workMode;
+						std::string jobId;
+						long reserved;
+					};
+					UserContext userContext;
+					CallContext callContext;
+				};
+
+
+				StartPredictiveCallResult();
+				explicit StartPredictiveCallResult(const std::string &payload);
+				~StartPredictiveCallResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<std::string> getParams()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<std::string> params_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_STARTPREDICTIVECALLRESULT_H_

ccc/src/CCCClient.cc

@@ -2283,6 +2283,42 @@ CCCClient::ListSkillLevelsOfUserOutcomeCallable CCCClient::listSkillLevelsOfUser
 	return task->get_future();
 }
 
+CCCClient::ListUnassignedNumbersOutcome CCCClient::listUnassignedNumbers(const ListUnassignedNumbersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListUnassignedNumbersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListUnassignedNumbersOutcome(ListUnassignedNumbersResult(outcome.result()));
+	else
+		return ListUnassignedNumbersOutcome(outcome.error());
+}
+
+void CCCClient::listUnassignedNumbersAsync(const ListUnassignedNumbersRequest& request, const ListUnassignedNumbersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listUnassignedNumbers(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::ListUnassignedNumbersOutcomeCallable CCCClient::listUnassignedNumbersCallable(const ListUnassignedNumbersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListUnassignedNumbersOutcome()>>(
+			[this, request]()
+			{
+			return this->listUnassignedNumbers(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CCCClient::ListUserLevelsOfSkillGroupOutcome CCCClient::listUserLevelsOfSkillGroup(const ListUserLevelsOfSkillGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3507,6 +3543,42 @@ CCCClient::StartBack2BackCallOutcomeCallable CCCClient::startBack2BackCallCallab
 	return task->get_future();
 }
 
+CCCClient::StartPredictiveCallOutcome CCCClient::startPredictiveCall(const StartPredictiveCallRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartPredictiveCallOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartPredictiveCallOutcome(StartPredictiveCallResult(outcome.result()));
+	else
+		return StartPredictiveCallOutcome(outcome.error());
+}
+
+void CCCClient::startPredictiveCallAsync(const StartPredictiveCallRequest& request, const StartPredictiveCallAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startPredictiveCall(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::StartPredictiveCallOutcomeCallable CCCClient::startPredictiveCallCallable(const StartPredictiveCallRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartPredictiveCallOutcome()>>(
+			[this, request]()
+			{
+			return this->startPredictiveCall(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CCCClient::TakeBreakOutcome CCCClient::takeBreak(const TakeBreakRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ccc/src/model/GetCallDetailRecordResult.cc

@@ -40,52 +40,56 @@ void GetCallDetailRecordResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["AgentIds"].isNull())
-		data_.agentIds = dataNode["AgentIds"].asString();
-	if(!dataNode["AgentNames"].isNull())
-		data_.agentNames = dataNode["AgentNames"].asString();
-	if(!dataNode["CalledNumber"].isNull())
-		data_.calledNumber = dataNode["CalledNumber"].asString();
-	if(!dataNode["CallingNumber"].isNull())
-		data_.callingNumber = dataNode["CallingNumber"].asString();
+	if(!dataNode["ReleaseInitiator"].isNull())
+		data_.releaseInitiator = dataNode["ReleaseInitiator"].asString();
 	if(!dataNode["ContactDisposition"].isNull())
 		data_.contactDisposition = dataNode["ContactDisposition"].asString();
-	if(!dataNode["ContactId"].isNull())
-		data_.contactId = dataNode["ContactId"].asString();
 	if(!dataNode["ContactType"].isNull())
 		data_.contactType = dataNode["ContactType"].asString();
+	if(!dataNode["AgentIds"].isNull())
+		data_.agentIds = dataNode["AgentIds"].asString();
 	if(!dataNode["CallDuration"].isNull())
 		data_.callDuration = std::stol(dataNode["CallDuration"].asString());
+	if(!dataNode["RecordingReady"].isNull())
+		data_.recordingReady = dataNode["RecordingReady"].asString() == "true";
 	if(!dataNode["EstablishedTime"].isNull())
 		data_.establishedTime = std::stol(dataNode["EstablishedTime"].asString());
 	if(!dataNode["InstanceId"].isNull())
 		data_.instanceId = dataNode["InstanceId"].asString();
-	if(!dataNode["StartTime"].isNull())
-		data_.startTime = std::stol(dataNode["StartTime"].asString());
-	if(!dataNode["ReleaseTime"].isNull())
-		data_.releaseTime = std::stol(dataNode["ReleaseTime"].asString());
-	if(!dataNode["SkillGroupIds"].isNull())
-		data_.skillGroupIds = dataNode["SkillGroupIds"].asString();
-	if(!dataNode["SkillGroupNames"].isNull())
-		data_.skillGroupNames = dataNode["SkillGroupNames"].asString();
 	if(!dataNode["SatisfactionSurveyOffered"].isNull())
 		data_.satisfactionSurveyOffered = dataNode["SatisfactionSurveyOffered"].asString() == "true";
+	if(!dataNode["CalledNumber"].isNull())
+		data_.calledNumber = dataNode["CalledNumber"].asString();
+	if(!dataNode["AgentNames"].isNull())
+		data_.agentNames = dataNode["AgentNames"].asString();
 	if(!dataNode["Satisfaction"].isNull())
 		data_.satisfaction = std::stoi(dataNode["Satisfaction"].asString());
+	if(!dataNode["StartTime"].isNull())
+		data_.startTime = std::stol(dataNode["StartTime"].asString());
+	if(!dataNode["ContactId"].isNull())
+		data_.contactId = dataNode["ContactId"].asString();
 	if(!dataNode["SatisfactionSurveyChannel"].isNull())
 		data_.satisfactionSurveyChannel = dataNode["SatisfactionSurveyChannel"].asString();
-	if(!dataNode["ReleaseInitiator"].isNull())
-		data_.releaseInitiator = dataNode["ReleaseInitiator"].asString();
-	if(!dataNode["RecordingReady"].isNull())
-		data_.recordingReady = dataNode["RecordingReady"].asString() == "true";
+	if(!dataNode["ReleaseTime"].isNull())
+		data_.releaseTime = std::stol(dataNode["ReleaseTime"].asString());
+	if(!dataNode["CallingNumber"].isNull())
+		data_.callingNumber = dataNode["CallingNumber"].asString();
+	if(!dataNode["SkillGroupNames"].isNull())
+		data_.skillGroupNames = dataNode["SkillGroupNames"].asString();
+	if(!dataNode["SkillGroupIds"].isNull())
+		data_.skillGroupIds = dataNode["SkillGroupIds"].asString();
+	if(!dataNode["CallerLocation"].isNull())
+		data_.callerLocation = dataNode["CallerLocation"].asString();
+	if(!dataNode["CalleeLocation"].isNull())
+		data_.calleeLocation = dataNode["CalleeLocation"].asString();
 	auto allAgentEventsNode = dataNode["AgentEvents"]["AgentEventsItem"];
 	for (auto dataNodeAgentEventsAgentEventsItem : allAgentEventsNode)
 	{
 		Data::AgentEventsItem agentEventsItemObject;
-		if(!dataNodeAgentEventsAgentEventsItem["AgentId"].isNull())
-			agentEventsItemObject.agentId = dataNodeAgentEventsAgentEventsItem["AgentId"].asString();
 		if(!dataNodeAgentEventsAgentEventsItem["AgentName"].isNull())
 			agentEventsItemObject.agentName = dataNodeAgentEventsAgentEventsItem["AgentName"].asString();
+		if(!dataNodeAgentEventsAgentEventsItem["AgentId"].isNull())
+			agentEventsItemObject.agentId = dataNodeAgentEventsAgentEventsItem["AgentId"].asString();
 		if(!dataNodeAgentEventsAgentEventsItem["SkillGroupId"].isNull())
 			agentEventsItemObject.skillGroupId = dataNodeAgentEventsAgentEventsItem["SkillGroupId"].asString();
 		auto allEventSequenceNode = dataNodeAgentEventsAgentEventsItem["EventSequence"]["EventSequenceItem"];
@@ -122,12 +126,12 @@ void GetCallDetailRecordResult::parse(const std::string &payload)
 	for (auto dataNodeQueueEventsQueueEventsItem : allQueueEventsNode)
 	{
 		Data::QueueEventsItem queueEventsItemObject;
-		if(!dataNodeQueueEventsQueueEventsItem["FlowId"].isNull())
-			queueEventsItemObject.flowId = dataNodeQueueEventsQueueEventsItem["FlowId"].asString();
 		if(!dataNodeQueueEventsQueueEventsItem["QueueId"].isNull())
 			queueEventsItemObject.queueId = dataNodeQueueEventsQueueEventsItem["QueueId"].asString();
 		if(!dataNodeQueueEventsQueueEventsItem["QueueName"].isNull())
 			queueEventsItemObject.queueName = dataNodeQueueEventsQueueEventsItem["QueueName"].asString();
+		if(!dataNodeQueueEventsQueueEventsItem["FlowId"].isNull())
+			queueEventsItemObject.flowId = dataNodeQueueEventsQueueEventsItem["FlowId"].asString();
 		if(!dataNodeQueueEventsQueueEventsItem["QueueType"].isNull())
 			queueEventsItemObject.queueType = std::stoi(dataNodeQueueEventsQueueEventsItem["QueueType"].asString());
 		auto allEventSequence3Node = dataNodeQueueEventsQueueEventsItem["EventSequence"]["EventSequenceItem"];

ccc/src/model/GetHistoricalInstanceReportResult.cc

@@ -41,194 +41,208 @@ void GetHistoricalInstanceReportResult::parse(const std::string &payload)
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
 	auto inboundNode = dataNode["Inbound"];
-	if(!inboundNode["AbandonRate"].isNull())
-		data_.inbound.abandonRate = std::stof(inboundNode["AbandonRate"].asString());
+	if(!inboundNode["AverageRingTime"].isNull())
+		data_.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
+	if(!inboundNode["CallsVoicemail"].isNull())
+		data_.inbound.callsVoicemail = std::stol(inboundNode["CallsVoicemail"].asString());
+	if(!inboundNode["MaxAbandonedInIVRTime"].isNull())
+		data_.inbound.maxAbandonedInIVRTime = std::stol(inboundNode["MaxAbandonedInIVRTime"].asString());
+	if(!inboundNode["CallsHandled"].isNull())
+		data_.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
+	if(!inboundNode["CallsIVRException"].isNull())
+		data_.inbound.callsIVRException = std::stol(inboundNode["CallsIVRException"].asString());
+	if(!inboundNode["CallsAbandonedInIVR"].isNull())
+		data_.inbound.callsAbandonedInIVR = std::stol(inboundNode["CallsAbandonedInIVR"].asString());
+	if(!inboundNode["MaxWorkTime"].isNull())
+		data_.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
+	if(!inboundNode["TotalHoldTime"].isNull())
+		data_.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
+	if(!inboundNode["MaxAbandonTime"].isNull())
+		data_.inbound.maxAbandonTime = std::stol(inboundNode["MaxAbandonTime"].asString());
 	if(!inboundNode["AverageAbandonTime"].isNull())
 		data_.inbound.averageAbandonTime = std::stof(inboundNode["AverageAbandonTime"].asString());
+	if(!inboundNode["CallsRinged"].isNull())
+		data_.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
+	if(!inboundNode["CallsQueuingFailed"].isNull())
+		data_.inbound.callsQueuingFailed = std::stol(inboundNode["CallsQueuingFailed"].asString());
+	if(!inboundNode["TotalRingTime"].isNull())
+		data_.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
+	if(!inboundNode["AbandonRate"].isNull())
+		data_.inbound.abandonRate = std::stof(inboundNode["AbandonRate"].asString());
+	if(!inboundNode["TotalTalkTime"].isNull())
+		data_.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
+	if(!inboundNode["MaxAbandonedInRingTime"].isNull())
+		data_.inbound.maxAbandonedInRingTime = std::stol(inboundNode["MaxAbandonedInRingTime"].asString());
+	if(!inboundNode["CallsBlindTransferred"].isNull())
+		data_.inbound.callsBlindTransferred = std::stol(inboundNode["CallsBlindTransferred"].asString());
 	if(!inboundNode["AverageAbandonedInIVRTime"].isNull())
 		data_.inbound.averageAbandonedInIVRTime = std::stof(inboundNode["AverageAbandonedInIVRTime"].asString());
 	if(!inboundNode["AverageAbandonedInQueueTime"].isNull())
 		data_.inbound.averageAbandonedInQueueTime = std::stof(inboundNode["AverageAbandonedInQueueTime"].asString());
-	if(!inboundNode["AverageAbandonedInRingTime"].isNull())
-		data_.inbound.averageAbandonedInRingTime = std::stof(inboundNode["AverageAbandonedInRingTime"].asString());
-	if(!inboundNode["AverageHoldTime"].isNull())
-		data_.inbound.averageHoldTime = std::stof(inboundNode["AverageHoldTime"].asString());
-	if(!inboundNode["AverageRingTime"].isNull())
-		data_.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
+	if(!inboundNode["MaxWaitTime"].isNull())
+		data_.inbound.maxWaitTime = std::stol(inboundNode["MaxWaitTime"].asString());
 	if(!inboundNode["AverageTalkTime"].isNull())
 		data_.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].asString());
+	if(!inboundNode["CallsAttendedTransferred"].isNull())
+		data_.inbound.callsAttendedTransferred = std::stol(inboundNode["CallsAttendedTransferred"].asString());
+	if(!inboundNode["TotalAbandonedInIVRTime"].isNull())
+		data_.inbound.totalAbandonedInIVRTime = std::stol(inboundNode["TotalAbandonedInIVRTime"].asString());
+	if(!inboundNode["CallsQueuingOverflow"].isNull())
+		data_.inbound.callsQueuingOverflow = std::stol(inboundNode["CallsQueuingOverflow"].asString());
+	if(!inboundNode["CallsAbandonedInRing"].isNull())
+		data_.inbound.callsAbandonedInRing = std::stol(inboundNode["CallsAbandonedInRing"].asString());
+	if(!inboundNode["TotalAbandonedInRingTime"].isNull())
+		data_.inbound.totalAbandonedInRingTime = std::stol(inboundNode["TotalAbandonedInRingTime"].asString());
+	if(!inboundNode["TotalWorkTime"].isNull())
+		data_.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
 	if(!inboundNode["AverageWaitTime"].isNull())
 		data_.inbound.averageWaitTime = std::stof(inboundNode["AverageWaitTime"].asString());
 	if(!inboundNode["AverageWorkTime"].isNull())
 		data_.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
-	if(!inboundNode["CallsAbandoned"].isNull())
-		data_.inbound.callsAbandoned = std::stol(inboundNode["CallsAbandoned"].asString());
-	if(!inboundNode["CallsAbandonedInIVR"].isNull())
-		data_.inbound.callsAbandonedInIVR = std::stol(inboundNode["CallsAbandonedInIVR"].asString());
-	if(!inboundNode["CallsAbandonedInQueue"].isNull())
-		data_.inbound.callsAbandonedInQueue = std::stol(inboundNode["CallsAbandonedInQueue"].asString());
-	if(!inboundNode["CallsAbandonedInRing"].isNull())
-		data_.inbound.callsAbandonedInRing = std::stol(inboundNode["CallsAbandonedInRing"].asString());
-	if(!inboundNode["CallsAttendedTransferred"].isNull())
-		data_.inbound.callsAttendedTransferred = std::stol(inboundNode["CallsAttendedTransferred"].asString());
-	if(!inboundNode["CallsBlindTransferred"].isNull())
-		data_.inbound.callsBlindTransferred = std::stol(inboundNode["CallsBlindTransferred"].asString());
-	if(!inboundNode["CallsHandled"].isNull())
-		data_.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
-	if(!inboundNode["CallsHold"].isNull())
-		data_.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
-	if(!inboundNode["CallsOffered"].isNull())
-		data_.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
 	if(!inboundNode["CallsQueued"].isNull())
 		data_.inbound.callsQueued = std::stol(inboundNode["CallsQueued"].asString());
-	if(!inboundNode["CallsRinged"].isNull())
-		data_.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
-	if(!inboundNode["HandleRate"].isNull())
-		data_.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
-	if(!inboundNode["MaxAbandonTime"].isNull())
-		data_.inbound.maxAbandonTime = std::stol(inboundNode["MaxAbandonTime"].asString());
-	if(!inboundNode["MaxAbandonedInIVRTime"].isNull())
-		data_.inbound.maxAbandonedInIVRTime = std::stol(inboundNode["MaxAbandonedInIVRTime"].asString());
+	if(!inboundNode["AverageAbandonedInRingTime"].isNull())
+		data_.inbound.averageAbandonedInRingTime = std::stof(inboundNode["AverageAbandonedInRingTime"].asString());
+	if(!inboundNode["SatisfactionIndex"].isNull())
+		data_.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+	if(!inboundNode["CallsAbandoned"].isNull())
+		data_.inbound.callsAbandoned = std::stol(inboundNode["CallsAbandoned"].asString());
 	if(!inboundNode["MaxAbandonedInQueueTime"].isNull())
 		data_.inbound.maxAbandonedInQueueTime = std::stol(inboundNode["MaxAbandonedInQueueTime"].asString());
-	if(!inboundNode["MaxAbandonedInRingTime"].isNull())
-		data_.inbound.maxAbandonedInRingTime = std::stol(inboundNode["MaxAbandonedInRingTime"].asString());
-	if(!inboundNode["MaxHoldTime"].isNull())
-		data_.inbound.maxHoldTime = std::stol(inboundNode["MaxHoldTime"].asString());
-	if(!inboundNode["MaxRingTime"].isNull())
-		data_.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+	if(!inboundNode["CallsAbandonedInVoiceNavigator"].isNull())
+		data_.inbound.callsAbandonedInVoiceNavigator = std::stol(inboundNode["CallsAbandonedInVoiceNavigator"].asString());
+	if(!inboundNode["TotalWaitTime"].isNull())
+		data_.inbound.totalWaitTime = std::stol(inboundNode["TotalWaitTime"].asString());
 	if(!inboundNode["MaxTalkTime"].isNull())
 		data_.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].asString());
-	if(!inboundNode["MaxWaitTime"].isNull())
-		data_.inbound.maxWaitTime = std::stol(inboundNode["MaxWaitTime"].asString());
-	if(!inboundNode["MaxWorkTime"].isNull())
-		data_.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
-	if(!inboundNode["SatisfactionIndex"].isNull())
-		data_.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+	if(!inboundNode["MaxRingTime"].isNull())
+		data_.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+	if(!inboundNode["TotalAbandonTime"].isNull())
+		data_.inbound.totalAbandonTime = std::stol(inboundNode["TotalAbandonTime"].asString());
+	if(!inboundNode["CallsOffered"].isNull())
+		data_.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
+	if(!inboundNode["CallsQueuingTimeout"].isNull())
+		data_.inbound.callsQueuingTimeout = std::stol(inboundNode["CallsQueuingTimeout"].asString());
+	if(!inboundNode["ServiceLevel20"].isNull())
+		data_.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
+	if(!inboundNode["MaxHoldTime"].isNull())
+		data_.inbound.maxHoldTime = std::stol(inboundNode["MaxHoldTime"].asString());
+	if(!inboundNode["CallsForwardToOutsideNumber"].isNull())
+		data_.inbound.callsForwardToOutsideNumber = std::stol(inboundNode["CallsForwardToOutsideNumber"].asString());
 	if(!inboundNode["SatisfactionRate"].isNull())
 		data_.inbound.satisfactionRate = std::stof(inboundNode["SatisfactionRate"].asString());
+	if(!inboundNode["CallsHold"].isNull())
+		data_.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
 	if(!inboundNode["SatisfactionSurveysOffered"].isNull())
 		data_.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
+	if(!inboundNode["HandleRate"].isNull())
+		data_.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
 	if(!inboundNode["SatisfactionSurveysResponded"].isNull())
 		data_.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].asString());
-	if(!inboundNode["ServiceLevel20"].isNull())
-		data_.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
-	if(!inboundNode["TotalAbandonTime"].isNull())
-		data_.inbound.totalAbandonTime = std::stol(inboundNode["TotalAbandonTime"].asString());
-	if(!inboundNode["TotalAbandonedInIVRTime"].isNull())
-		data_.inbound.totalAbandonedInIVRTime = std::stol(inboundNode["TotalAbandonedInIVRTime"].asString());
+	if(!inboundNode["AverageHoldTime"].isNull())
+		data_.inbound.averageHoldTime = std::stof(inboundNode["AverageHoldTime"].asString());
+	if(!inboundNode["CallsAbandonedInQueue"].isNull())
+		data_.inbound.callsAbandonedInQueue = std::stol(inboundNode["CallsAbandonedInQueue"].asString());
 	if(!inboundNode["TotalAbandonedInQueueTime"].isNull())
 		data_.inbound.totalAbandonedInQueueTime = std::stol(inboundNode["TotalAbandonedInQueueTime"].asString());
-	if(!inboundNode["TotalAbandonedInRingTime"].isNull())
-		data_.inbound.totalAbandonedInRingTime = std::stol(inboundNode["TotalAbandonedInRingTime"].asString());
-	if(!inboundNode["TotalHoldTime"].isNull())
-		data_.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
-	if(!inboundNode["TotalRingTime"].isNull())
-		data_.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
-	if(!inboundNode["TotalTalkTime"].isNull())
-		data_.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
-	if(!inboundNode["TotalWaitTime"].isNull())
-		data_.inbound.totalWaitTime = std::stol(inboundNode["TotalWaitTime"].asString());
-	if(!inboundNode["TotalWorkTime"].isNull())
-		data_.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
 	auto outboundNode = dataNode["Outbound"];
-	if(!outboundNode["AnswerRate"].isNull())
-		data_.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
-	if(!outboundNode["AverageDialingTime"].isNull())
-		data_.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
-	if(!outboundNode["AverageHoldTime"].isNull())
-		data_.outbound.averageHoldTime = std::stof(outboundNode["AverageHoldTime"].asString());
 	if(!outboundNode["AverageRingTime"].isNull())
 		data_.outbound.averageRingTime = std::stof(outboundNode["AverageRingTime"].asString());
-	if(!outboundNode["AverageTalkTime"].isNull())
-		data_.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
-	if(!outboundNode["AverageWorkTime"].isNull())
-		data_.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
-	if(!outboundNode["CallsAnswered"].isNull())
-		data_.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
-	if(!outboundNode["CallsAttendedTransferred"].isNull())
-		data_.outbound.callsAttendedTransferred = std::stol(outboundNode["CallsAttendedTransferred"].asString());
-	if(!outboundNode["CallsBlindTransferred"].isNull())
-		data_.outbound.callsBlindTransferred = std::stol(outboundNode["CallsBlindTransferred"].asString());
 	if(!outboundNode["CallsDialed"].isNull())
 		data_.outbound.callsDialed = std::stol(outboundNode["CallsDialed"].asString());
-	if(!outboundNode["CallsHold"].isNull())
-		data_.outbound.callsHold = std::stoi(outboundNode["CallsHold"].asString());
+	if(!outboundNode["CallsAnswered"].isNull())
+		data_.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
+	if(!outboundNode["TotalWorkTime"].isNull())
+		data_.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+	if(!outboundNode["MaxWorkTime"].isNull())
+		data_.outbound.maxWorkTime = std::stol(outboundNode["MaxWorkTime"].asString());
+	if(!outboundNode["TotalDialingTime"].isNull())
+		data_.outbound.totalDialingTime = std::stol(outboundNode["TotalDialingTime"].asString());
+	if(!outboundNode["TotalHoldTime"].isNull())
+		data_.outbound.totalHoldTime = std::stol(outboundNode["TotalHoldTime"].asString());
+	if(!outboundNode["AverageWorkTime"].isNull())
+		data_.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
+	if(!outboundNode["SatisfactionIndex"].isNull())
+		data_.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
 	if(!outboundNode["CallsRinged"].isNull())
 		data_.outbound.callsRinged = std::stol(outboundNode["CallsRinged"].asString());
+	if(!outboundNode["TotalRingTime"].isNull())
+		data_.outbound.totalRingTime = std::stol(outboundNode["TotalRingTime"].asString());
+	if(!outboundNode["MaxTalkTime"].isNull())
+		data_.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
+	if(!outboundNode["MaxRingTime"].isNull())
+		data_.outbound.maxRingTime = std::stol(outboundNode["MaxRingTime"].asString());
+	if(!outboundNode["TotalTalkTime"].isNull())
+		data_.outbound.totalTalkTime = std::stol(outboundNode["TotalTalkTime"].asString());
 	if(!outboundNode["MaxDialingTime"].isNull())
 		data_.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].asString());
+	if(!outboundNode["CallsBlindTransferred"].isNull())
+		data_.outbound.callsBlindTransferred = std::stol(outboundNode["CallsBlindTransferred"].asString());
+	if(!outboundNode["AnswerRate"].isNull())
+		data_.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
 	if(!outboundNode["MaxHoldTime"].isNull())
 		data_.outbound.maxHoldTime = std::stol(outboundNode["MaxHoldTime"].asString());
-	if(!outboundNode["MaxRingTime"].isNull())
-		data_.outbound.maxRingTime = std::stol(outboundNode["MaxRingTime"].asString());
-	if(!outboundNode["MaxTalkTime"].isNull())
-		data_.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
-	if(!outboundNode["MaxWorkTime"].isNull())
-		data_.outbound.maxWorkTime = std::stol(outboundNode["MaxWorkTime"].asString());
-	if(!outboundNode["SatisfactionIndex"].isNull())
-		data_.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
+	if(!outboundNode["AverageTalkTime"].isNull())
+		data_.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
 	if(!outboundNode["SatisfactionRate"].isNull())
 		data_.outbound.satisfactionRate = std::stof(outboundNode["SatisfactionRate"].asString());
+	if(!outboundNode["CallsAttendedTransferred"].isNull())
+		data_.outbound.callsAttendedTransferred = std::stol(outboundNode["CallsAttendedTransferred"].asString());
+	if(!outboundNode["CallsHold"].isNull())
+		data_.outbound.callsHold = std::stoi(outboundNode["CallsHold"].asString());
 	if(!outboundNode["SatisfactionSurveysOffered"].isNull())
 		data_.outbound.satisfactionSurveysOffered = std::stol(outboundNode["SatisfactionSurveysOffered"].asString());
 	if(!outboundNode["SatisfactionSurveysResponded"].isNull())
 		data_.outbound.satisfactionSurveysResponded = std::stol(outboundNode["SatisfactionSurveysResponded"].asString());
-	if(!outboundNode["TotalDialingTime"].isNull())
-		data_.outbound.totalDialingTime = std::stol(outboundNode["TotalDialingTime"].asString());
-	if(!outboundNode["TotalHoldTime"].isNull())
-		data_.outbound.totalHoldTime = std::stol(outboundNode["TotalHoldTime"].asString());
-	if(!outboundNode["TotalRingTime"].isNull())
-		data_.outbound.totalRingTime = std::stol(outboundNode["TotalRingTime"].asString());
-	if(!outboundNode["TotalTalkTime"].isNull())
-		data_.outbound.totalTalkTime = std::stol(outboundNode["TotalTalkTime"].asString());
-	if(!outboundNode["TotalWorkTime"].isNull())
-		data_.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+	if(!outboundNode["AverageHoldTime"].isNull())
+		data_.outbound.averageHoldTime = std::stof(outboundNode["AverageHoldTime"].asString());
+	if(!outboundNode["AverageDialingTime"].isNull())
+		data_.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
 	auto overallNode = dataNode["Overall"];
-	if(!overallNode["AverageBreakTime"].isNull())
-		data_.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
-	if(!overallNode["AverageHoldTime"].isNull())
-		data_.overall.averageHoldTime = std::stof(overallNode["AverageHoldTime"].asString());
-	if(!overallNode["AverageReadyTime"].isNull())
-		data_.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
-	if(!overallNode["AverageTalkTime"].isNull())
-		data_.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
-	if(!overallNode["AverageWorkTime"].isNull())
-		data_.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
-	if(!overallNode["MaxBreakTime"].isNull())
-		data_.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
+	if(!overallNode["TotalTalkTime"].isNull())
+		data_.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
+	if(!overallNode["TotalLoggedInTime"].isNull())
+		data_.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
+	if(!overallNode["OccupancyRate"].isNull())
+		data_.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
+	if(!overallNode["TotalWorkTime"].isNull())
+		data_.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
 	if(!overallNode["MaxHoldTime"].isNull())
 		data_.overall.maxHoldTime = std::stol(overallNode["MaxHoldTime"].asString());
-	if(!overallNode["MaxReadyTime"].isNull())
-		data_.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
-	if(!overallNode["MaxTalkTime"].isNull())
-		data_.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
 	if(!overallNode["MaxWorkTime"].isNull())
 		data_.overall.maxWorkTime = std::stol(overallNode["MaxWorkTime"].asString());
-	if(!overallNode["OccupancyRate"].isNull())
-		data_.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
-	if(!overallNode["SatisfactionIndex"].isNull())
-		data_.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
+	if(!overallNode["AverageBreakTime"].isNull())
+		data_.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
+	if(!overallNode["TotalHoldTime"].isNull())
+		data_.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
 	if(!overallNode["SatisfactionRate"].isNull())
 		data_.overall.satisfactionRate = std::stof(overallNode["SatisfactionRate"].asString());
+	if(!overallNode["MaxBreakTime"].isNull())
+		data_.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
+	if(!overallNode["AverageWorkTime"].isNull())
+		data_.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
+	if(!overallNode["AverageTalkTime"].isNull())
+		data_.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
+	if(!overallNode["SatisfactionIndex"].isNull())
+		data_.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
 	if(!overallNode["SatisfactionSurveysOffered"].isNull())
 		data_.overall.satisfactionSurveysOffered = std::stol(overallNode["SatisfactionSurveysOffered"].asString());
 	if(!overallNode["SatisfactionSurveysResponded"].isNull())
 		data_.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].asString());
+	if(!overallNode["MaxReadyTime"].isNull())
+		data_.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
+	if(!overallNode["AverageReadyTime"].isNull())
+		data_.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
+	if(!overallNode["AverageHoldTime"].isNull())
+		data_.overall.averageHoldTime = std::stof(overallNode["AverageHoldTime"].asString());
+	if(!overallNode["TotalReadyTime"].isNull())
+		data_.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
 	if(!overallNode["TotalBreakTime"].isNull())
 		data_.overall.totalBreakTime = std::stol(overallNode["TotalBreakTime"].asString());
+	if(!overallNode["MaxTalkTime"].isNull())
+		data_.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
 	if(!overallNode["TotalCalls"].isNull())
 		data_.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString());
-	if(!overallNode["TotalHoldTime"].isNull())
-		data_.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
-	if(!overallNode["TotalLoggedInTime"].isNull())
-		data_.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
-	if(!overallNode["TotalReadyTime"].isNull())
-		data_.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
-	if(!overallNode["TotalTalkTime"].isNull())
-		data_.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
-	if(!overallNode["TotalWorkTime"].isNull())
-		data_.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
 	if(!value["HttpStatusCode"].isNull())

ccc/src/model/ListCallDetailRecordsResult.cc

@@ -50,56 +50,64 @@ void ListCallDetailRecordsResult::parse(const std::string &payload)
 	for (auto dataNodeListCallDetailRecord : allListNode)
 	{
 		Data::CallDetailRecord callDetailRecordObject;
-		if(!dataNodeListCallDetailRecord["AgentIds"].isNull())
-			callDetailRecordObject.agentIds = dataNodeListCallDetailRecord["AgentIds"].asString();
-		if(!dataNodeListCallDetailRecord["AgentNames"].isNull())
-			callDetailRecordObject.agentNames = dataNodeListCallDetailRecord["AgentNames"].asString();
-		if(!dataNodeListCallDetailRecord["CallDuration"].isNull())
-			callDetailRecordObject.callDuration = dataNodeListCallDetailRecord["CallDuration"].asString();
-		if(!dataNodeListCallDetailRecord["CalledNumber"].isNull())
-			callDetailRecordObject.calledNumber = dataNodeListCallDetailRecord["CalledNumber"].asString();
-		if(!dataNodeListCallDetailRecord["CallingNumber"].isNull())
-			callDetailRecordObject.callingNumber = dataNodeListCallDetailRecord["CallingNumber"].asString();
 		if(!dataNodeListCallDetailRecord["ContactDisposition"].isNull())
 			callDetailRecordObject.contactDisposition = dataNodeListCallDetailRecord["ContactDisposition"].asString();
-		if(!dataNodeListCallDetailRecord["ContactId"].isNull())
-			callDetailRecordObject.contactId = dataNodeListCallDetailRecord["ContactId"].asString();
 		if(!dataNodeListCallDetailRecord["ContactType"].isNull())
 			callDetailRecordObject.contactType = dataNodeListCallDetailRecord["ContactType"].asString();
 		if(!dataNodeListCallDetailRecord["EstablishedTime"].isNull())
 			callDetailRecordObject.establishedTime = std::stol(dataNodeListCallDetailRecord["EstablishedTime"].asString());
-		if(!dataNodeListCallDetailRecord["InstanceId"].isNull())
-			callDetailRecordObject.instanceId = dataNodeListCallDetailRecord["InstanceId"].asString();
+		if(!dataNodeListCallDetailRecord["CalledNumber"].isNull())
+			callDetailRecordObject.calledNumber = dataNodeListCallDetailRecord["CalledNumber"].asString();
+		if(!dataNodeListCallDetailRecord["AdditionalBroker"].isNull())
+			callDetailRecordObject.additionalBroker = dataNodeListCallDetailRecord["AdditionalBroker"].asString();
+		if(!dataNodeListCallDetailRecord["SatisfactionIndex"].isNull())
+			callDetailRecordObject.satisfactionIndex = std::stoi(dataNodeListCallDetailRecord["SatisfactionIndex"].asString());
+		if(!dataNodeListCallDetailRecord["SatisfactionSurveyChannel"].isNull())
+			callDetailRecordObject.satisfactionSurveyChannel = dataNodeListCallDetailRecord["SatisfactionSurveyChannel"].asString();
+		if(!dataNodeListCallDetailRecord["ReleaseTime"].isNull())
+			callDetailRecordObject.releaseTime = std::stol(dataNodeListCallDetailRecord["ReleaseTime"].asString());
+		if(!dataNodeListCallDetailRecord["WaitTime"].isNull())
+			callDetailRecordObject.waitTime = std::stol(dataNodeListCallDetailRecord["WaitTime"].asString());
+		if(!dataNodeListCallDetailRecord["SkillGroupNames"].isNull())
+			callDetailRecordObject.skillGroupNames = dataNodeListCallDetailRecord["SkillGroupNames"].asString();
 		if(!dataNodeListCallDetailRecord["IvrTime"].isNull())
 			callDetailRecordObject.ivrTime = std::stol(dataNodeListCallDetailRecord["IvrTime"].asString());
-		if(!dataNodeListCallDetailRecord["QueueTime"].isNull())
-			callDetailRecordObject.queueTime = std::stol(dataNodeListCallDetailRecord["QueueTime"].asString());
-		if(!dataNodeListCallDetailRecord["RecordingDuration"].isNull())
-			callDetailRecordObject.recordingDuration = std::stol(dataNodeListCallDetailRecord["RecordingDuration"].asString());
-		if(!dataNodeListCallDetailRecord["RecordingReady"].isNull())
-			callDetailRecordObject.recordingReady = dataNodeListCallDetailRecord["RecordingReady"].asString() == "true";
+		if(!dataNodeListCallDetailRecord["SatisfactionDescription"].isNull())
+			callDetailRecordObject.satisfactionDescription = dataNodeListCallDetailRecord["SatisfactionDescription"].asString();
 		if(!dataNodeListCallDetailRecord["ReleaseInitiator"].isNull())
 			callDetailRecordObject.releaseInitiator = dataNodeListCallDetailRecord["ReleaseInitiator"].asString();
-		if(!dataNodeListCallDetailRecord["ReleaseTime"].isNull())
-			callDetailRecordObject.releaseTime = std::stol(dataNodeListCallDetailRecord["ReleaseTime"].asString());
+		if(!dataNodeListCallDetailRecord["AgentIds"].isNull())
+			callDetailRecordObject.agentIds = dataNodeListCallDetailRecord["AgentIds"].asString();
+		if(!dataNodeListCallDetailRecord["CallDuration"].isNull())
+			callDetailRecordObject.callDuration = dataNodeListCallDetailRecord["CallDuration"].asString();
+		if(!dataNodeListCallDetailRecord["RecordingReady"].isNull())
+			callDetailRecordObject.recordingReady = dataNodeListCallDetailRecord["RecordingReady"].asString() == "true";
+		if(!dataNodeListCallDetailRecord["InstanceId"].isNull())
+			callDetailRecordObject.instanceId = dataNodeListCallDetailRecord["InstanceId"].asString();
 		if(!dataNodeListCallDetailRecord["RingTime"].isNull())
 			callDetailRecordObject.ringTime = std::stol(dataNodeListCallDetailRecord["RingTime"].asString());
-		if(!dataNodeListCallDetailRecord["SatisfactionDescription"].isNull())
-			callDetailRecordObject.satisfactionDescription = dataNodeListCallDetailRecord["SatisfactionDescription"].asString();
-		if(!dataNodeListCallDetailRecord["SatisfactionIndex"].isNull())
-			callDetailRecordObject.satisfactionIndex = std::stoi(dataNodeListCallDetailRecord["SatisfactionIndex"].asString());
-		if(!dataNodeListCallDetailRecord["SatisfactionSurveyChannel"].isNull())
-			callDetailRecordObject.satisfactionSurveyChannel = dataNodeListCallDetailRecord["SatisfactionSurveyChannel"].asString();
 		if(!dataNodeListCallDetailRecord["SatisfactionSurveyOffered"].isNull())
 			callDetailRecordObject.satisfactionSurveyOffered = dataNodeListCallDetailRecord["SatisfactionSurveyOffered"].asString() == "true";
-		if(!dataNodeListCallDetailRecord["SkillGroupIds"].isNull())
-			callDetailRecordObject.skillGroupIds = dataNodeListCallDetailRecord["SkillGroupIds"].asString();
-		if(!dataNodeListCallDetailRecord["SkillGroupNames"].isNull())
-			callDetailRecordObject.skillGroupNames = dataNodeListCallDetailRecord["SkillGroupNames"].asString();
+		if(!dataNodeListCallDetailRecord["AgentNames"].isNull())
+			callDetailRecordObject.agentNames = dataNodeListCallDetailRecord["AgentNames"].asString();
 		if(!dataNodeListCallDetailRecord["StartTime"].isNull())
 			callDetailRecordObject.startTime = std::stol(dataNodeListCallDetailRecord["StartTime"].asString());
-		if(!dataNodeListCallDetailRecord["WaitTime"].isNull())
-			callDetailRecordObject.waitTime = std::stol(dataNodeListCallDetailRecord["WaitTime"].asString());
+		if(!dataNodeListCallDetailRecord["ContactId"].isNull())
+			callDetailRecordObject.contactId = dataNodeListCallDetailRecord["ContactId"].asString();
+		if(!dataNodeListCallDetailRecord["RecordingDuration"].isNull())
+			callDetailRecordObject.recordingDuration = std::stol(dataNodeListCallDetailRecord["RecordingDuration"].asString());
+		if(!dataNodeListCallDetailRecord["CallingNumber"].isNull())
+			callDetailRecordObject.callingNumber = dataNodeListCallDetailRecord["CallingNumber"].asString();
+		if(!dataNodeListCallDetailRecord["QueueTime"].isNull())
+			callDetailRecordObject.queueTime = std::stol(dataNodeListCallDetailRecord["QueueTime"].asString());
+		if(!dataNodeListCallDetailRecord["Broker"].isNull())
+			callDetailRecordObject.broker = dataNodeListCallDetailRecord["Broker"].asString();
+		if(!dataNodeListCallDetailRecord["SkillGroupIds"].isNull())
+			callDetailRecordObject.skillGroupIds = dataNodeListCallDetailRecord["SkillGroupIds"].asString();
+		if(!dataNodeListCallDetailRecord["CallerLocation"].isNull())
+			callDetailRecordObject.callerLocation = dataNodeListCallDetailRecord["CallerLocation"].asString();
+		if(!dataNodeListCallDetailRecord["CalleeLocation"].isNull())
+			callDetailRecordObject.calleeLocation = dataNodeListCallDetailRecord["CalleeLocation"].asString();
 		data_.list.push_back(callDetailRecordObject);
 	}
 	if(!value["Code"].isNull())

ccc/src/model/ListIntervalInstanceReportResult.cc

@@ -46,194 +46,208 @@ void ListIntervalInstanceReportResult::parse(const std::string &payload)
 		if(!valueDataDataItem["StatsTime"].isNull())
 			dataObject.statsTime = std::stol(valueDataDataItem["StatsTime"].asString());
 		auto inboundNode = value["Inbound"];
-		if(!inboundNode["AbandonedRate"].isNull())
-			dataObject.inbound.abandonedRate = std::stof(inboundNode["AbandonedRate"].asString());
+		if(!inboundNode["AverageRingTime"].isNull())
+			dataObject.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
+		if(!inboundNode["CallsVoicemail"].isNull())
+			dataObject.inbound.callsVoicemail = std::stol(inboundNode["CallsVoicemail"].asString());
+		if(!inboundNode["MaxAbandonedInIVRTime"].isNull())
+			dataObject.inbound.maxAbandonedInIVRTime = std::stol(inboundNode["MaxAbandonedInIVRTime"].asString());
+		if(!inboundNode["CallsHandled"].isNull())
+			dataObject.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
+		if(!inboundNode["CallsIVRException"].isNull())
+			dataObject.inbound.callsIVRException = std::stol(inboundNode["CallsIVRException"].asString());
+		if(!inboundNode["CallsAbandonedInIVR"].isNull())
+			dataObject.inbound.callsAbandonedInIVR = std::stol(inboundNode["CallsAbandonedInIVR"].asString());
+		if(!inboundNode["MaxWorkTime"].isNull())
+			dataObject.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
+		if(!inboundNode["TotalHoldTime"].isNull())
+			dataObject.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
+		if(!inboundNode["MaxAbandonTime"].isNull())
+			dataObject.inbound.maxAbandonTime = std::stol(inboundNode["MaxAbandonTime"].asString());
 		if(!inboundNode["AverageAbandonTime"].isNull())
 			dataObject.inbound.averageAbandonTime = std::stof(inboundNode["AverageAbandonTime"].asString());
+		if(!inboundNode["AbandonedRate"].isNull())
+			dataObject.inbound.abandonedRate = std::stof(inboundNode["AbandonedRate"].asString());
+		if(!inboundNode["CallsRinged"].isNull())
+			dataObject.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
+		if(!inboundNode["CallsQueuingFailed"].isNull())
+			dataObject.inbound.callsQueuingFailed = std::stol(inboundNode["CallsQueuingFailed"].asString());
+		if(!inboundNode["TotalRingTime"].isNull())
+			dataObject.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
+		if(!inboundNode["TotalTalkTime"].isNull())
+			dataObject.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
+		if(!inboundNode["MaxAbandonedInRingTime"].isNull())
+			dataObject.inbound.maxAbandonedInRingTime = std::stol(inboundNode["MaxAbandonedInRingTime"].asString());
+		if(!inboundNode["CallsBlindTransferred"].isNull())
+			dataObject.inbound.callsBlindTransferred = std::stol(inboundNode["CallsBlindTransferred"].asString());
 		if(!inboundNode["AverageAbandonedInIVRTime"].isNull())
 			dataObject.inbound.averageAbandonedInIVRTime = std::stof(inboundNode["AverageAbandonedInIVRTime"].asString());
 		if(!inboundNode["AverageAbandonedInQueueTime"].isNull())
 			dataObject.inbound.averageAbandonedInQueueTime = std::stof(inboundNode["AverageAbandonedInQueueTime"].asString());
-		if(!inboundNode["AverageAbandonedInRingTime"].isNull())
-			dataObject.inbound.averageAbandonedInRingTime = std::stof(inboundNode["AverageAbandonedInRingTime"].asString());
-		if(!inboundNode["AverageHoldTime"].isNull())
-			dataObject.inbound.averageHoldTime = std::stof(inboundNode["AverageHoldTime"].asString());
-		if(!inboundNode["AverageRingTime"].isNull())
-			dataObject.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
+		if(!inboundNode["MaxWaitTime"].isNull())
+			dataObject.inbound.maxWaitTime = std::stol(inboundNode["MaxWaitTime"].asString());
 		if(!inboundNode["AverageTalkTime"].isNull())
 			dataObject.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].asString());
+		if(!inboundNode["CallsAttendedTransferred"].isNull())
+			dataObject.inbound.callsAttendedTransferred = std::stol(inboundNode["CallsAttendedTransferred"].asString());
+		if(!inboundNode["TotalAbandonedInIVRTime"].isNull())
+			dataObject.inbound.totalAbandonedInIVRTime = std::stol(inboundNode["TotalAbandonedInIVRTime"].asString());
+		if(!inboundNode["CallsQueuingOverflow"].isNull())
+			dataObject.inbound.callsQueuingOverflow = std::stol(inboundNode["CallsQueuingOverflow"].asString());
+		if(!inboundNode["CallsAbandonedInRing"].isNull())
+			dataObject.inbound.callsAbandonedInRing = std::stol(inboundNode["CallsAbandonedInRing"].asString());
+		if(!inboundNode["TotalAbandonedInRingTime"].isNull())
+			dataObject.inbound.totalAbandonedInRingTime = std::stol(inboundNode["TotalAbandonedInRingTime"].asString());
+		if(!inboundNode["TotalWorkTime"].isNull())
+			dataObject.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
 		if(!inboundNode["AverageWaitTime"].isNull())
 			dataObject.inbound.averageWaitTime = std::stof(inboundNode["AverageWaitTime"].asString());
 		if(!inboundNode["AverageWorkTime"].isNull())
 			dataObject.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
-		if(!inboundNode["CallsAbandoned"].isNull())
-			dataObject.inbound.callsAbandoned = std::stol(inboundNode["CallsAbandoned"].asString());
-		if(!inboundNode["CallsAbandonedInIVR"].isNull())
-			dataObject.inbound.callsAbandonedInIVR = std::stol(inboundNode["CallsAbandonedInIVR"].asString());
-		if(!inboundNode["CallsAbandonedInQueue"].isNull())
-			dataObject.inbound.callsAbandonedInQueue = std::stol(inboundNode["CallsAbandonedInQueue"].asString());
-		if(!inboundNode["CallsAbandonedInRing"].isNull())
-			dataObject.inbound.callsAbandonedInRing = std::stol(inboundNode["CallsAbandonedInRing"].asString());
-		if(!inboundNode["CallsAttendedTransferred"].isNull())
-			dataObject.inbound.callsAttendedTransferred = std::stol(inboundNode["CallsAttendedTransferred"].asString());
-		if(!inboundNode["CallsBlindTransferred"].isNull())
-			dataObject.inbound.callsBlindTransferred = std::stol(inboundNode["CallsBlindTransferred"].asString());
-		if(!inboundNode["CallsHandled"].isNull())
-			dataObject.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
-		if(!inboundNode["CallsHold"].isNull())
-			dataObject.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
-		if(!inboundNode["CallsOffered"].isNull())
-			dataObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
 		if(!inboundNode["CallsQueued"].isNull())
 			dataObject.inbound.callsQueued = std::stol(inboundNode["CallsQueued"].asString());
-		if(!inboundNode["CallsRinged"].isNull())
-			dataObject.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
-		if(!inboundNode["HandleRate"].isNull())
-			dataObject.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
-		if(!inboundNode["MaxAbandonTime"].isNull())
-			dataObject.inbound.maxAbandonTime = std::stol(inboundNode["MaxAbandonTime"].asString());
-		if(!inboundNode["MaxAbandonedInIVRTime"].isNull())
-			dataObject.inbound.maxAbandonedInIVRTime = std::stol(inboundNode["MaxAbandonedInIVRTime"].asString());
+		if(!inboundNode["AverageAbandonedInRingTime"].isNull())
+			dataObject.inbound.averageAbandonedInRingTime = std::stof(inboundNode["AverageAbandonedInRingTime"].asString());
+		if(!inboundNode["SatisfactionIndex"].isNull())
+			dataObject.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+		if(!inboundNode["CallsAbandoned"].isNull())
+			dataObject.inbound.callsAbandoned = std::stol(inboundNode["CallsAbandoned"].asString());
 		if(!inboundNode["MaxAbandonedInQueueTime"].isNull())
 			dataObject.inbound.maxAbandonedInQueueTime = std::stol(inboundNode["MaxAbandonedInQueueTime"].asString());
-		if(!inboundNode["MaxAbandonedInRingTime"].isNull())
-			dataObject.inbound.maxAbandonedInRingTime = std::stol(inboundNode["MaxAbandonedInRingTime"].asString());
-		if(!inboundNode["MaxHoldTime"].isNull())
-			dataObject.inbound.maxHoldTime = std::stol(inboundNode["MaxHoldTime"].asString());
-		if(!inboundNode["MaxRingTime"].isNull())
-			dataObject.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+		if(!inboundNode["CallsAbandonedInVoiceNavigator"].isNull())
+			dataObject.inbound.callsAbandonedInVoiceNavigator = std::stol(inboundNode["CallsAbandonedInVoiceNavigator"].asString());
+		if(!inboundNode["TotalWaitTime"].isNull())
+			dataObject.inbound.totalWaitTime = std::stol(inboundNode["TotalWaitTime"].asString());
 		if(!inboundNode["MaxTalkTime"].isNull())
 			dataObject.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].asString());
-		if(!inboundNode["MaxWaitTime"].isNull())
-			dataObject.inbound.maxWaitTime = std::stol(inboundNode["MaxWaitTime"].asString());
-		if(!inboundNode["MaxWorkTime"].isNull())
-			dataObject.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
-		if(!inboundNode["SatisfactionIndex"].isNull())
-			dataObject.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+		if(!inboundNode["MaxRingTime"].isNull())
+			dataObject.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+		if(!inboundNode["TotalAbandonTime"].isNull())
+			dataObject.inbound.totalAbandonTime = std::stol(inboundNode["TotalAbandonTime"].asString());
+		if(!inboundNode["CallsOffered"].isNull())
+			dataObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
+		if(!inboundNode["CallsQueuingTimeout"].isNull())
+			dataObject.inbound.callsQueuingTimeout = std::stol(inboundNode["CallsQueuingTimeout"].asString());
+		if(!inboundNode["ServiceLevel20"].isNull())
+			dataObject.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
+		if(!inboundNode["MaxHoldTime"].isNull())
+			dataObject.inbound.maxHoldTime = std::stol(inboundNode["MaxHoldTime"].asString());
+		if(!inboundNode["CallsForwardToOutsideNumber"].isNull())
+			dataObject.inbound.callsForwardToOutsideNumber = std::stol(inboundNode["CallsForwardToOutsideNumber"].asString());
 		if(!inboundNode["SatisfactionRate"].isNull())
 			dataObject.inbound.satisfactionRate = std::stof(inboundNode["SatisfactionRate"].asString());
+		if(!inboundNode["CallsHold"].isNull())
+			dataObject.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
 		if(!inboundNode["SatisfactionSurveysOffered"].isNull())
 			dataObject.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
+		if(!inboundNode["HandleRate"].isNull())
+			dataObject.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
 		if(!inboundNode["SatisfactionSurveysResponded"].isNull())
 			dataObject.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].asString());
-		if(!inboundNode["ServiceLevel20"].isNull())
-			dataObject.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
-		if(!inboundNode["TotalAbandonTime"].isNull())
-			dataObject.inbound.totalAbandonTime = std::stol(inboundNode["TotalAbandonTime"].asString());
-		if(!inboundNode["TotalAbandonedInIVRTime"].isNull())
-			dataObject.inbound.totalAbandonedInIVRTime = std::stol(inboundNode["TotalAbandonedInIVRTime"].asString());
+		if(!inboundNode["AverageHoldTime"].isNull())
+			dataObject.inbound.averageHoldTime = std::stof(inboundNode["AverageHoldTime"].asString());
+		if(!inboundNode["CallsAbandonedInQueue"].isNull())
+			dataObject.inbound.callsAbandonedInQueue = std::stol(inboundNode["CallsAbandonedInQueue"].asString());
 		if(!inboundNode["TotalAbandonedInQueueTime"].isNull())
 			dataObject.inbound.totalAbandonedInQueueTime = std::stol(inboundNode["TotalAbandonedInQueueTime"].asString());
-		if(!inboundNode["TotalAbandonedInRingTime"].isNull())
-			dataObject.inbound.totalAbandonedInRingTime = std::stol(inboundNode["TotalAbandonedInRingTime"].asString());
-		if(!inboundNode["TotalHoldTime"].isNull())
-			dataObject.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
-		if(!inboundNode["TotalRingTime"].isNull())
-			dataObject.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
-		if(!inboundNode["TotalTalkTime"].isNull())
-			dataObject.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
-		if(!inboundNode["TotalWaitTime"].isNull())
-			dataObject.inbound.totalWaitTime = std::stol(inboundNode["TotalWaitTime"].asString());
-		if(!inboundNode["TotalWorkTime"].isNull())
-			dataObject.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
 		auto outboundNode = value["Outbound"];
-		if(!outboundNode["AnswerRate"].isNull())
-			dataObject.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
-		if(!outboundNode["AverageDialingTime"].isNull())
-			dataObject.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
-		if(!outboundNode["AverageHoldTime"].isNull())
-			dataObject.outbound.averageHoldTime = std::stof(outboundNode["AverageHoldTime"].asString());
 		if(!outboundNode["AverageRingTime"].isNull())
 			dataObject.outbound.averageRingTime = std::stof(outboundNode["AverageRingTime"].asString());
-		if(!outboundNode["AverageTalkTime"].isNull())
-			dataObject.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
-		if(!outboundNode["AverageWorkTime"].isNull())
-			dataObject.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
-		if(!outboundNode["CallsAnswered"].isNull())
-			dataObject.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
-		if(!outboundNode["CallsAttendedTransferred"].isNull())
-			dataObject.outbound.callsAttendedTransferred = std::stol(outboundNode["CallsAttendedTransferred"].asString());
-		if(!outboundNode["CallsBlindTransferred"].isNull())
-			dataObject.outbound.callsBlindTransferred = std::stol(outboundNode["CallsBlindTransferred"].asString());
 		if(!outboundNode["CallsDialed"].isNull())
 			dataObject.outbound.callsDialed = std::stol(outboundNode["CallsDialed"].asString());
-		if(!outboundNode["CallsHold"].isNull())
-			dataObject.outbound.callsHold = std::stol(outboundNode["CallsHold"].asString());
+		if(!outboundNode["CallsAnswered"].isNull())
+			dataObject.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
+		if(!outboundNode["TotalWorkTime"].isNull())
+			dataObject.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+		if(!outboundNode["MaxWorkTime"].isNull())
+			dataObject.outbound.maxWorkTime = std::stol(outboundNode["MaxWorkTime"].asString());
+		if(!outboundNode["TotalDialingTime"].isNull())
+			dataObject.outbound.totalDialingTime = std::stol(outboundNode["TotalDialingTime"].asString());
+		if(!outboundNode["TotalHoldTime"].isNull())
+			dataObject.outbound.totalHoldTime = std::stol(outboundNode["TotalHoldTime"].asString());
+		if(!outboundNode["AverageWorkTime"].isNull())
+			dataObject.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
+		if(!outboundNode["SatisfactionIndex"].isNull())
+			dataObject.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
 		if(!outboundNode["CallsRinged"].isNull())
 			dataObject.outbound.callsRinged = std::stol(outboundNode["CallsRinged"].asString());
+		if(!outboundNode["TotalRingTime"].isNull())
+			dataObject.outbound.totalRingTime = std::stol(outboundNode["TotalRingTime"].asString());
+		if(!outboundNode["MaxTalkTime"].isNull())
+			dataObject.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
+		if(!outboundNode["MaxRingTime"].isNull())
+			dataObject.outbound.maxRingTime = std::stol(outboundNode["MaxRingTime"].asString());
+		if(!outboundNode["TotalTalkTime"].isNull())
+			dataObject.outbound.totalTalkTime = std::stol(outboundNode["TotalTalkTime"].asString());
 		if(!outboundNode["MaxDialingTime"].isNull())
 			dataObject.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].asString());
+		if(!outboundNode["CallsBlindTransferred"].isNull())
+			dataObject.outbound.callsBlindTransferred = std::stol(outboundNode["CallsBlindTransferred"].asString());
+		if(!outboundNode["AnswerRate"].isNull())
+			dataObject.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
 		if(!outboundNode["MaxHoldTime"].isNull())
 			dataObject.outbound.maxHoldTime = std::stol(outboundNode["MaxHoldTime"].asString());
-		if(!outboundNode["MaxRingTime"].isNull())
-			dataObject.outbound.maxRingTime = std::stol(outboundNode["MaxRingTime"].asString());
-		if(!outboundNode["MaxTalkTime"].isNull())
-			dataObject.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
-		if(!outboundNode["MaxWorkTime"].isNull())
-			dataObject.outbound.maxWorkTime = std::stol(outboundNode["MaxWorkTime"].asString());
-		if(!outboundNode["SatisfactionIndex"].isNull())
-			dataObject.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
+		if(!outboundNode["AverageTalkTime"].isNull())
+			dataObject.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
 		if(!outboundNode["SatisfactionRate"].isNull())
 			dataObject.outbound.satisfactionRate = std::stof(outboundNode["SatisfactionRate"].asString());
+		if(!outboundNode["CallsAttendedTransferred"].isNull())
+			dataObject.outbound.callsAttendedTransferred = std::stol(outboundNode["CallsAttendedTransferred"].asString());
+		if(!outboundNode["CallsHold"].isNull())
+			dataObject.outbound.callsHold = std::stol(outboundNode["CallsHold"].asString());
 		if(!outboundNode["SatisfactionSurveysOffered"].isNull())
 			dataObject.outbound.satisfactionSurveysOffered = std::stol(outboundNode["SatisfactionSurveysOffered"].asString());
 		if(!outboundNode["SatisfactionSurveysResponded"].isNull())
 			dataObject.outbound.satisfactionSurveysResponded = std::stol(outboundNode["SatisfactionSurveysResponded"].asString());
-		if(!outboundNode["TotalDialingTime"].isNull())
-			dataObject.outbound.totalDialingTime = std::stol(outboundNode["TotalDialingTime"].asString());
-		if(!outboundNode["TotalHoldTime"].isNull())
-			dataObject.outbound.totalHoldTime = std::stol(outboundNode["TotalHoldTime"].asString());
-		if(!outboundNode["TotalRingTime"].isNull())
-			dataObject.outbound.totalRingTime = std::stol(outboundNode["TotalRingTime"].asString());
-		if(!outboundNode["TotalTalkTime"].isNull())
-			dataObject.outbound.totalTalkTime = std::stol(outboundNode["TotalTalkTime"].asString());
-		if(!outboundNode["TotalWorkTime"].isNull())
-			dataObject.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+		if(!outboundNode["AverageHoldTime"].isNull())
+			dataObject.outbound.averageHoldTime = std::stof(outboundNode["AverageHoldTime"].asString());
+		if(!outboundNode["AverageDialingTime"].isNull())
+			dataObject.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
 		auto overallNode = value["Overall"];
-		if(!overallNode["AverageBreakTime"].isNull())
-			dataObject.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
-		if(!overallNode["AverageHoldTime"].isNull())
-			dataObject.overall.averageHoldTime = std::stof(overallNode["AverageHoldTime"].asString());
-		if(!overallNode["AverageReadyTime"].isNull())
-			dataObject.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
-		if(!overallNode["AverageTalkTime"].isNull())
-			dataObject.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
-		if(!overallNode["AverageWorkTime"].isNull())
-			dataObject.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
-		if(!overallNode["MaxBreakTime"].isNull())
-			dataObject.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
+		if(!overallNode["TotalTalkTime"].isNull())
+			dataObject.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
+		if(!overallNode["TotalLoggedInTime"].isNull())
+			dataObject.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
+		if(!overallNode["OccupancyRate"].isNull())
+			dataObject.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
+		if(!overallNode["TotalWorkTime"].isNull())
+			dataObject.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
 		if(!overallNode["MaxHoldTime"].isNull())
 			dataObject.overall.maxHoldTime = std::stol(overallNode["MaxHoldTime"].asString());
-		if(!overallNode["MaxReadyTime"].isNull())
-			dataObject.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
-		if(!overallNode["MaxTalkTime"].isNull())
-			dataObject.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
 		if(!overallNode["MaxWorkTime"].isNull())
 			dataObject.overall.maxWorkTime = std::stol(overallNode["MaxWorkTime"].asString());
-		if(!overallNode["OccupancyRate"].isNull())
-			dataObject.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
-		if(!overallNode["SatisfactionIndex"].isNull())
-			dataObject.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
+		if(!overallNode["AverageBreakTime"].isNull())
+			dataObject.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
+		if(!overallNode["TotalHoldTime"].isNull())
+			dataObject.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
 		if(!overallNode["SatisfactionRate"].isNull())
 			dataObject.overall.satisfactionRate = std::stof(overallNode["SatisfactionRate"].asString());
+		if(!overallNode["MaxBreakTime"].isNull())
+			dataObject.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
+		if(!overallNode["AverageWorkTime"].isNull())
+			dataObject.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
+		if(!overallNode["AverageTalkTime"].isNull())
+			dataObject.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
+		if(!overallNode["SatisfactionIndex"].isNull())
+			dataObject.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
 		if(!overallNode["SatisfactionSurveysOffered"].isNull())
 			dataObject.overall.satisfactionSurveysOffered = std::stol(overallNode["SatisfactionSurveysOffered"].asString());
 		if(!overallNode["SatisfactionSurveysResponded"].isNull())
 			dataObject.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].asString());
+		if(!overallNode["MaxReadyTime"].isNull())
+			dataObject.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
+		if(!overallNode["AverageReadyTime"].isNull())
+			dataObject.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
+		if(!overallNode["AverageHoldTime"].isNull())
+			dataObject.overall.averageHoldTime = std::stof(overallNode["AverageHoldTime"].asString());
+		if(!overallNode["TotalReadyTime"].isNull())
+			dataObject.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
 		if(!overallNode["TotalBreakTime"].isNull())
 			dataObject.overall.totalBreakTime = std::stol(overallNode["TotalBreakTime"].asString());
+		if(!overallNode["MaxTalkTime"].isNull())
+			dataObject.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
 		if(!overallNode["TotalCalls"].isNull())
 			dataObject.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString());
-		if(!overallNode["TotalHoldTime"].isNull())
-			dataObject.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
-		if(!overallNode["TotalLoggedInTime"].isNull())
-			dataObject.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
-		if(!overallNode["TotalReadyTime"].isNull())
-			dataObject.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
-		if(!overallNode["TotalTalkTime"].isNull())
-			dataObject.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
-		if(!overallNode["TotalWorkTime"].isNull())
-			dataObject.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
 		data_.push_back(dataObject);
 	}
 	if(!value["Code"].isNull())

ccc/src/model/ListUnassignedNumbersRequest.cc

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

ccc/src/model/ListUnassignedNumbersResult.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ccc/model/ListUnassignedNumbersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+ListUnassignedNumbersResult::ListUnassignedNumbersResult() :
+	ServiceResult()
+{}
+
+ListUnassignedNumbersResult::ListUnassignedNumbersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListUnassignedNumbersResult::~ListUnassignedNumbersResult()
+{}
+
+void ListUnassignedNumbersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["PageNumber"].isNull())
+		data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
+	if(!dataNode["PageSize"].isNull())
+		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stoi(dataNode["TotalCount"].asString());
+	auto allListNode = dataNode["List"]["PhoneNumber"];
+	for (auto dataNodeListPhoneNumber : allListNode)
+	{
+		Data::PhoneNumber phoneNumberObject;
+		if(!dataNodeListPhoneNumber["Active"].isNull())
+			phoneNumberObject.active = dataNodeListPhoneNumber["Active"].asString() == "true";
+		if(!dataNodeListPhoneNumber["City"].isNull())
+			phoneNumberObject.city = dataNodeListPhoneNumber["City"].asString();
+		if(!dataNodeListPhoneNumber["Number"].isNull())
+			phoneNumberObject.number = dataNodeListPhoneNumber["Number"].asString();
+		if(!dataNodeListPhoneNumber["Province"].isNull())
+			phoneNumberObject.province = dataNodeListPhoneNumber["Province"].asString();
+		if(!dataNodeListPhoneNumber["Usage"].isNull())
+			phoneNumberObject.usage = dataNodeListPhoneNumber["Usage"].asString() == "true";
+		data_.list.push_back(phoneNumberObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ListUnassignedNumbersResult::getMessage()const
+{
+	return message_;
+}
+
+int ListUnassignedNumbersResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+ListUnassignedNumbersResult::Data ListUnassignedNumbersResult::getData()const
+{
+	return data_;
+}
+
+std::string ListUnassignedNumbersResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/MakeCallRequest.cc

@@ -60,6 +60,17 @@ void MakeCallRequest::setDeviceId(const std::string& deviceId)
 	setParameter("DeviceId", deviceId);
 }
 
+std::string MakeCallRequest::getTags()const
+{
+	return tags_;
+}
+
+void MakeCallRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
 int MakeCallRequest::getTimeoutSeconds()const
 {
 	return timeoutSeconds_;

ccc/src/model/MakeCallResult.cc

@@ -53,53 +53,53 @@ void MakeCallResult::parse(const std::string &payload)
 	for (auto callContextNodeChannelContextsChannelContext : allChannelContextsNode)
 	{
 		Data::CallContext::ChannelContext channelContextObject;
-		if(!callContextNodeChannelContextsChannelContext["AssociatedData"].isNull())
-			channelContextObject.associatedData = callContextNodeChannelContextsChannelContext["AssociatedData"].asString();
-		if(!callContextNodeChannelContextsChannelContext["CallType"].isNull())
-			channelContextObject.callType = callContextNodeChannelContextsChannelContext["CallType"].asString();
-		if(!callContextNodeChannelContextsChannelContext["ChannelFlags"].isNull())
-			channelContextObject.channelFlags = callContextNodeChannelContextsChannelContext["ChannelFlags"].asString();
-		if(!callContextNodeChannelContextsChannelContext["ChannelId"].isNull())
-			channelContextObject.channelId = callContextNodeChannelContextsChannelContext["ChannelId"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ReleaseInitiator"].isNull())
+			channelContextObject.releaseInitiator = callContextNodeChannelContextsChannelContext["ReleaseInitiator"].asString();
 		if(!callContextNodeChannelContextsChannelContext["ChannelState"].isNull())
 			channelContextObject.channelState = callContextNodeChannelContextsChannelContext["ChannelState"].asString();
 		if(!callContextNodeChannelContextsChannelContext["Destination"].isNull())
 			channelContextObject.destination = callContextNodeChannelContextsChannelContext["Destination"].asString();
+		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
+			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ChannelFlags"].isNull())
+			channelContextObject.channelFlags = callContextNodeChannelContextsChannelContext["ChannelFlags"].asString();
+		if(!callContextNodeChannelContextsChannelContext["Timestamp"].isNull())
+			channelContextObject.timestamp = std::stol(callContextNodeChannelContextsChannelContext["Timestamp"].asString());
+		if(!callContextNodeChannelContextsChannelContext["AssociatedData"].isNull())
+			channelContextObject.associatedData = callContextNodeChannelContextsChannelContext["AssociatedData"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ReleaseReason"].isNull())
+			channelContextObject.releaseReason = callContextNodeChannelContextsChannelContext["ReleaseReason"].asString();
+		if(!callContextNodeChannelContextsChannelContext["CallType"].isNull())
+			channelContextObject.callType = callContextNodeChannelContextsChannelContext["CallType"].asString();
 		if(!callContextNodeChannelContextsChannelContext["JobId"].isNull())
 			channelContextObject.jobId = callContextNodeChannelContextsChannelContext["JobId"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ChannelId"].isNull())
+			channelContextObject.channelId = callContextNodeChannelContextsChannelContext["ChannelId"].asString();
 		if(!callContextNodeChannelContextsChannelContext["Originator"].isNull())
 			channelContextObject.originator = callContextNodeChannelContextsChannelContext["Originator"].asString();
-		if(!callContextNodeChannelContextsChannelContext["ReleaseInitiator"].isNull())
-			channelContextObject.releaseInitiator = callContextNodeChannelContextsChannelContext["ReleaseInitiator"].asString();
-		if(!callContextNodeChannelContextsChannelContext["ReleaseReason"].isNull())
-			channelContextObject.releaseReason = callContextNodeChannelContextsChannelContext["ReleaseReason"].asString();
-		if(!callContextNodeChannelContextsChannelContext["Timestamp"].isNull())
-			channelContextObject.timestamp = std::stol(callContextNodeChannelContextsChannelContext["Timestamp"].asString());
 		if(!callContextNodeChannelContextsChannelContext["UserExtension"].isNull())
 			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
-		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
-			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].asString();
 		data_.callContext.channelContexts.push_back(channelContextObject);
 	}
 	auto userContextNode = dataNode["UserContext"];
-	if(!userContextNode["BreakCode"].isNull())
-		data_.userContext.breakCode = userContextNode["BreakCode"].asString();
-	if(!userContextNode["DeviceId"].isNull())
-		data_.userContext.deviceId = userContextNode["DeviceId"].asString();
 	if(!userContextNode["Extension"].isNull())
 		data_.userContext.extension = userContextNode["Extension"].asString();
-	if(!userContextNode["InstanceId"].isNull())
-		data_.userContext.instanceId = userContextNode["InstanceId"].asString();
+	if(!userContextNode["WorkMode"].isNull())
+		data_.userContext.workMode = userContextNode["WorkMode"].asString();
+	if(!userContextNode["DeviceId"].isNull())
+		data_.userContext.deviceId = userContextNode["DeviceId"].asString();
 	if(!userContextNode["JobId"].isNull())
 		data_.userContext.jobId = userContextNode["JobId"].asString();
-	if(!userContextNode["OutboundScenario"].isNull())
-		data_.userContext.outboundScenario = userContextNode["OutboundScenario"].asString() == "true";
 	if(!userContextNode["UserId"].isNull())
 		data_.userContext.userId = userContextNode["UserId"].asString();
+	if(!userContextNode["BreakCode"].isNull())
+		data_.userContext.breakCode = userContextNode["BreakCode"].asString();
+	if(!userContextNode["InstanceId"].isNull())
+		data_.userContext.instanceId = userContextNode["InstanceId"].asString();
+	if(!userContextNode["OutboundScenario"].isNull())
+		data_.userContext.outboundScenario = userContextNode["OutboundScenario"].asString() == "true";
 	if(!userContextNode["UserState"].isNull())
 		data_.userContext.userState = userContextNode["UserState"].asString();
-	if(!userContextNode["WorkMode"].isNull())
-		data_.userContext.workMode = userContextNode["WorkMode"].asString();
 		auto allSignedSkillGroupIdList = userContextNode["SignedSkillGroupIdList"]["SkillGroupId"];
 		for (auto value : allSignedSkillGroupIdList)
 			data_.userContext.signedSkillGroupIdList.push_back(value.asString());

ccc/src/model/PollUserStatusResult.cc

@@ -53,65 +53,65 @@ void PollUserStatusResult::parse(const std::string &payload)
 	for (auto callContextNodeChannelContextsChannelContext : allChannelContextsNode)
 	{
 		Data::CallContext::ChannelContext channelContextObject;
-		if(!callContextNodeChannelContextsChannelContext["AssociatedData"].isNull())
-			channelContextObject.associatedData = callContextNodeChannelContextsChannelContext["AssociatedData"].asString();
-		if(!callContextNodeChannelContextsChannelContext["CallType"].isNull())
-			channelContextObject.callType = callContextNodeChannelContextsChannelContext["CallType"].asString();
-		if(!callContextNodeChannelContextsChannelContext["ChannelFlags"].isNull())
-			channelContextObject.channelFlags = callContextNodeChannelContextsChannelContext["ChannelFlags"].asString();
-		if(!callContextNodeChannelContextsChannelContext["ChannelId"].isNull())
-			channelContextObject.channelId = callContextNodeChannelContextsChannelContext["ChannelId"].asString();
-		if(!callContextNodeChannelContextsChannelContext["ChannelState"].isNull())
-			channelContextObject.channelState = callContextNodeChannelContextsChannelContext["ChannelState"].asString();
-		if(!callContextNodeChannelContextsChannelContext["Destination"].isNull())
-			channelContextObject.destination = callContextNodeChannelContextsChannelContext["Destination"].asString();
 		if(!callContextNodeChannelContextsChannelContext["Index"].isNull())
 			channelContextObject.index = std::stoi(callContextNodeChannelContextsChannelContext["Index"].asString());
-		if(!callContextNodeChannelContextsChannelContext["JobId"].isNull())
-			channelContextObject.jobId = callContextNodeChannelContextsChannelContext["JobId"].asString();
-		if(!callContextNodeChannelContextsChannelContext["Originator"].isNull())
-			channelContextObject.originator = callContextNodeChannelContextsChannelContext["Originator"].asString();
 		if(!callContextNodeChannelContextsChannelContext["ReleaseInitiator"].isNull())
 			channelContextObject.releaseInitiator = callContextNodeChannelContextsChannelContext["ReleaseInitiator"].asString();
-		if(!callContextNodeChannelContextsChannelContext["ReleaseReason"].isNull())
-			channelContextObject.releaseReason = callContextNodeChannelContextsChannelContext["ReleaseReason"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ChannelState"].isNull())
+			channelContextObject.channelState = callContextNodeChannelContextsChannelContext["ChannelState"].asString();
+		if(!callContextNodeChannelContextsChannelContext["Destination"].isNull())
+			channelContextObject.destination = callContextNodeChannelContextsChannelContext["Destination"].asString();
+		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
+			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ChannelFlags"].isNull())
+			channelContextObject.channelFlags = callContextNodeChannelContextsChannelContext["ChannelFlags"].asString();
 		if(!callContextNodeChannelContextsChannelContext["SkillGroupId"].isNull())
 			channelContextObject.skillGroupId = callContextNodeChannelContextsChannelContext["SkillGroupId"].asString();
 		if(!callContextNodeChannelContextsChannelContext["Timestamp"].isNull())
 			channelContextObject.timestamp = std::stol(callContextNodeChannelContextsChannelContext["Timestamp"].asString());
-		if(!callContextNodeChannelContextsChannelContext["UserExtension"].isNull())
-			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
-		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
-			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].asString();
+		if(!callContextNodeChannelContextsChannelContext["AssociatedData"].isNull())
+			channelContextObject.associatedData = callContextNodeChannelContextsChannelContext["AssociatedData"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ReleaseReason"].isNull())
+			channelContextObject.releaseReason = callContextNodeChannelContextsChannelContext["ReleaseReason"].asString();
+		if(!callContextNodeChannelContextsChannelContext["CallType"].isNull())
+			channelContextObject.callType = callContextNodeChannelContextsChannelContext["CallType"].asString();
 		if(!callContextNodeChannelContextsChannelContext["ChannelVariables"].isNull())
 			channelContextObject.channelVariables = callContextNodeChannelContextsChannelContext["ChannelVariables"].asString();
+		if(!callContextNodeChannelContextsChannelContext["JobId"].isNull())
+			channelContextObject.jobId = callContextNodeChannelContextsChannelContext["JobId"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ChannelId"].isNull())
+			channelContextObject.channelId = callContextNodeChannelContextsChannelContext["ChannelId"].asString();
+		if(!callContextNodeChannelContextsChannelContext["UserExtension"].isNull())
+			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
+		if(!callContextNodeChannelContextsChannelContext["Originator"].isNull())
+			channelContextObject.originator = callContextNodeChannelContextsChannelContext["Originator"].asString();
 		data_.callContext.channelContexts.push_back(channelContextObject);
 	}
 	auto userContextNode = dataNode["UserContext"];
-	if(!userContextNode["BreakCode"].isNull())
-		data_.userContext.breakCode = userContextNode["BreakCode"].asString();
-	if(!userContextNode["DeviceId"].isNull())
-		data_.userContext.deviceId = userContextNode["DeviceId"].asString();
 	if(!userContextNode["Extension"].isNull())
 		data_.userContext.extension = userContextNode["Extension"].asString();
 	if(!userContextNode["Heartbeat"].isNull())
 		data_.userContext.heartbeat = std::stol(userContextNode["Heartbeat"].asString());
+	if(!userContextNode["WorkMode"].isNull())
+		data_.userContext.workMode = userContextNode["WorkMode"].asString();
+	if(!userContextNode["DeviceId"].isNull())
+		data_.userContext.deviceId = userContextNode["DeviceId"].asString();
+	if(!userContextNode["UserId"].isNull())
+		data_.userContext.userId = userContextNode["UserId"].asString();
+	if(!userContextNode["Reserved"].isNull())
+		data_.userContext.reserved = std::stol(userContextNode["Reserved"].asString());
+	if(!userContextNode["BreakCode"].isNull())
+		data_.userContext.breakCode = userContextNode["BreakCode"].asString();
 	if(!userContextNode["InstanceId"].isNull())
 		data_.userContext.instanceId = userContextNode["InstanceId"].asString();
-	if(!userContextNode["JobId"].isNull())
-		data_.userContext.jobId = userContextNode["JobId"].asString();
-	if(!userContextNode["Mobile"].isNull())
-		data_.userContext.mobile = userContextNode["Mobile"].asString();
 	if(!userContextNode["OutboundScenario"].isNull())
 		data_.userContext.outboundScenario = userContextNode["OutboundScenario"].asString() == "true";
-	if(!userContextNode["Reserved"].isNull())
-		data_.userContext.reserved = std::stol(userContextNode["Reserved"].asString());
-	if(!userContextNode["UserId"].isNull())
-		data_.userContext.userId = userContextNode["UserId"].asString();
+	if(!userContextNode["Mobile"].isNull())
+		data_.userContext.mobile = userContextNode["Mobile"].asString();
+	if(!userContextNode["JobId"].isNull())
+		data_.userContext.jobId = userContextNode["JobId"].asString();
 	if(!userContextNode["UserState"].isNull())
 		data_.userContext.userState = userContextNode["UserState"].asString();
-	if(!userContextNode["WorkMode"].isNull())
-		data_.userContext.workMode = userContextNode["WorkMode"].asString();
 		auto allSignedSkillGroupIdList = userContextNode["SignedSkillGroupIdList"]["SkillGroupId"];
 		for (auto value : allSignedSkillGroupIdList)
 			data_.userContext.signedSkillGroupIdList.push_back(value.asString());

ccc/src/model/StartBack2BackCallRequest.cc

@@ -49,28 +49,6 @@ void StartBack2BackCallRequest::setBroker(const std::string& broker)
 	setParameter("Broker", broker);
 }
 
-std::string StartBack2BackCallRequest::getUserId()const
-{
-	return userId_;
-}
-
-void StartBack2BackCallRequest::setUserId(const std::string& userId)
-{
-	userId_ = userId;
-	setParameter("UserId", userId);
-}
-
-std::string StartBack2BackCallRequest::getDeviceId()const
-{
-	return deviceId_;
-}
-
-void StartBack2BackCallRequest::setDeviceId(const std::string& deviceId)
-{
-	deviceId_ = deviceId;
-	setParameter("DeviceId", deviceId);
-}
-
 std::string StartBack2BackCallRequest::getAdditionalBroker()const
 {
 	return additionalBroker_;

ccc/src/model/StartPredictiveCallRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * 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/ccc/model/StartPredictiveCallRequest.h>
+
+using AlibabaCloud::CCC::Model::StartPredictiveCallRequest;
+
+StartPredictiveCallRequest::StartPredictiveCallRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "StartPredictiveCall")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+StartPredictiveCallRequest::~StartPredictiveCallRequest()
+{}
+
+std::string StartPredictiveCallRequest::getContactFlowId()const
+{
+	return contactFlowId_;
+}
+
+void StartPredictiveCallRequest::setContactFlowId(const std::string& contactFlowId)
+{
+	contactFlowId_ = contactFlowId;
+	setParameter("ContactFlowId", contactFlowId);
+}
+
+std::string StartPredictiveCallRequest::getCallee()const
+{
+	return callee_;
+}
+
+void StartPredictiveCallRequest::setCallee(const std::string& callee)
+{
+	callee_ = callee;
+	setParameter("Callee", callee);
+}
+
+std::string StartPredictiveCallRequest::getContactFlowVariables()const
+{
+	return contactFlowVariables_;
+}
+
+void StartPredictiveCallRequest::setContactFlowVariables(const std::string& contactFlowVariables)
+{
+	contactFlowVariables_ = contactFlowVariables;
+	setParameter("ContactFlowVariables", contactFlowVariables);
+}
+
+std::string StartPredictiveCallRequest::getTags()const
+{
+	return tags_;
+}
+
+void StartPredictiveCallRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+int StartPredictiveCallRequest::getTimeoutSeconds()const
+{
+	return timeoutSeconds_;
+}
+
+void StartPredictiveCallRequest::setTimeoutSeconds(int timeoutSeconds)
+{
+	timeoutSeconds_ = timeoutSeconds;
+	setParameter("TimeoutSeconds", std::to_string(timeoutSeconds));
+}
+
+std::string StartPredictiveCallRequest::getCaller()const
+{
+	return caller_;
+}
+
+void StartPredictiveCallRequest::setCaller(const std::string& caller)
+{
+	caller_ = caller;
+	setParameter("Caller", caller);
+}
+
+std::string StartPredictiveCallRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void StartPredictiveCallRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

ccc/src/model/StartPredictiveCallResult.cc

@@ -0,0 +1,148 @@
+/*
+ * 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/ccc/model/StartPredictiveCallResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+StartPredictiveCallResult::StartPredictiveCallResult() :
+	ServiceResult()
+{}
+
+StartPredictiveCallResult::StartPredictiveCallResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+StartPredictiveCallResult::~StartPredictiveCallResult()
+{}
+
+void StartPredictiveCallResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto callContextNode = dataNode["CallContext"];
+	if(!callContextNode["CallType"].isNull())
+		data_.callContext.callType = callContextNode["CallType"].asString();
+	if(!callContextNode["InstanceId"].isNull())
+		data_.callContext.instanceId = callContextNode["InstanceId"].asString();
+	if(!callContextNode["JobId"].isNull())
+		data_.callContext.jobId = callContextNode["JobId"].asString();
+	auto allChannelContextsNode = callContextNode["ChannelContexts"]["ChannelContext"];
+	for (auto callContextNodeChannelContextsChannelContext : allChannelContextsNode)
+	{
+		Data::CallContext::ChannelContext channelContextObject;
+		if(!callContextNodeChannelContextsChannelContext["ReleaseInitiator"].isNull())
+			channelContextObject.releaseInitiator = callContextNodeChannelContextsChannelContext["ReleaseInitiator"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ChannelState"].isNull())
+			channelContextObject.channelState = callContextNodeChannelContextsChannelContext["ChannelState"].asString();
+		if(!callContextNodeChannelContextsChannelContext["Destination"].isNull())
+			channelContextObject.destination = callContextNodeChannelContextsChannelContext["Destination"].asString();
+		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
+			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ChannelFlags"].isNull())
+			channelContextObject.channelFlags = callContextNodeChannelContextsChannelContext["ChannelFlags"].asString();
+		if(!callContextNodeChannelContextsChannelContext["Timestamp"].isNull())
+			channelContextObject.timestamp = std::stol(callContextNodeChannelContextsChannelContext["Timestamp"].asString());
+		if(!callContextNodeChannelContextsChannelContext["AssociatedData"].isNull())
+			channelContextObject.associatedData = callContextNodeChannelContextsChannelContext["AssociatedData"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ReleaseReason"].isNull())
+			channelContextObject.releaseReason = callContextNodeChannelContextsChannelContext["ReleaseReason"].asString();
+		if(!callContextNodeChannelContextsChannelContext["CallType"].isNull())
+			channelContextObject.callType = callContextNodeChannelContextsChannelContext["CallType"].asString();
+		if(!callContextNodeChannelContextsChannelContext["JobId"].isNull())
+			channelContextObject.jobId = callContextNodeChannelContextsChannelContext["JobId"].asString();
+		if(!callContextNodeChannelContextsChannelContext["ChannelId"].isNull())
+			channelContextObject.channelId = callContextNodeChannelContextsChannelContext["ChannelId"].asString();
+		if(!callContextNodeChannelContextsChannelContext["Originator"].isNull())
+			channelContextObject.originator = callContextNodeChannelContextsChannelContext["Originator"].asString();
+		if(!callContextNodeChannelContextsChannelContext["UserExtension"].isNull())
+			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
+		data_.callContext.channelContexts.push_back(channelContextObject);
+	}
+	auto userContextNode = dataNode["UserContext"];
+	if(!userContextNode["Extension"].isNull())
+		data_.userContext.extension = userContextNode["Extension"].asString();
+	if(!userContextNode["Heartbeat"].isNull())
+		data_.userContext.heartbeat = std::stol(userContextNode["Heartbeat"].asString());
+	if(!userContextNode["WorkMode"].isNull())
+		data_.userContext.workMode = userContextNode["WorkMode"].asString();
+	if(!userContextNode["DeviceId"].isNull())
+		data_.userContext.deviceId = userContextNode["DeviceId"].asString();
+	if(!userContextNode["UserId"].isNull())
+		data_.userContext.userId = userContextNode["UserId"].asString();
+	if(!userContextNode["Reserved"].isNull())
+		data_.userContext.reserved = std::stol(userContextNode["Reserved"].asString());
+	if(!userContextNode["BreakCode"].isNull())
+		data_.userContext.breakCode = userContextNode["BreakCode"].asString();
+	if(!userContextNode["InstanceId"].isNull())
+		data_.userContext.instanceId = userContextNode["InstanceId"].asString();
+	if(!userContextNode["OutboundScenario"].isNull())
+		data_.userContext.outboundScenario = userContextNode["OutboundScenario"].asString() == "true";
+	if(!userContextNode["DeviceState"].isNull())
+		data_.userContext.deviceState = userContextNode["DeviceState"].asString();
+	if(!userContextNode["Mobile"].isNull())
+		data_.userContext.mobile = userContextNode["Mobile"].asString();
+	if(!userContextNode["JobId"].isNull())
+		data_.userContext.jobId = userContextNode["JobId"].asString();
+	if(!userContextNode["UserState"].isNull())
+		data_.userContext.userState = userContextNode["UserState"].asString();
+		auto allSignedSkillGroupIdList = userContextNode["SignedSkillGroupIdList"]["SkillGroupId"];
+		for (auto value : allSignedSkillGroupIdList)
+			data_.userContext.signedSkillGroupIdList.push_back(value.asString());
+	auto allParams = value["Params"]["Param"];
+	for (const auto &item : allParams)
+		params_.push_back(item.asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string StartPredictiveCallResult::getMessage()const
+{
+	return message_;
+}
+
+int StartPredictiveCallResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::vector<std::string> StartPredictiveCallResult::getParams()const
+{
+	return params_;
+}
+
+StartPredictiveCallResult::Data StartPredictiveCallResult::getData()const
+{
+	return data_;
+}
+
+std::string StartPredictiveCallResult::getCode()const
+{
+	return code_;
+}
+