Support folder for rule.

CHANGELOG

@@ -1,3 +1,82 @@
+2022-01-12 Version: 1.36.1024
+- Support folder for rule.
+
+2022-01-11 Version: 1.36.1023
+- Support  DeleteTransitRouter API.
+
+2022-01-11 Version: 1.36.1022
+- Fix bugs.
+
+2022-01-11 Version: 1.36.1021
+- Fix bugs.
+
+2022-01-11 Version: 1.36.1020
+- Added reserve price range.
+
+2022-01-07 Version: 1.36.1019
+- Support resource scheduler.
+
+2022-01-07 Version: 1.36.1018
+- Add or modify APIs, include, QueryEmbeddedStaus, QueryWorks, QueryWorksByWorkspace.
+
+2022-01-07 Version: 1.36.1017
+- Add or modify APIs, include, QueryEmbeddedStaus, QueryWorks, QueryWorksByWorkspace.
+
+2022-01-07 Version: 1.36.1016
+- Support Service name.
+
+2022-01-07 Version: 1.36.1015
+- Supported minReadyInstanceRatio parameter for deploy.
+
+2022-01-07 Version: 1.36.1014
+- Support New API for Dypnsapi.
+
+2022-01-06 Version: 1.36.1013
+- Fix bugs.
+
+2022-01-06 Version: 1.36.1012
+- Generated 2016-11-01 for `live`.
+
+2022-01-05 Version: 1.36.1011
+- Add new interface.
+
+2022-01-05 Version: 1.36.1010
+- Fix bugx.
+
+2021-12-31 Version: 1.36.1009
+- Update ErrorCode.
+
+2021-12-30 Version: 1.36.1008
+- Supported Get Worker List.
+- Execute Job Support Designate Machine.
+
+2021-12-30 Version: 1.36.1007
+- Create Lindorm Open api.
+
+2021-12-30 Version: 1.36.1006
+- Support AUTH for CreateEventSubscribe.
+
+2021-12-30 Version: 1.36.1005
+- Update by sdk platform.
+
+2021-12-30 Version: 1.36.1004
+- Add new interface.
+
+2021-12-29 Version: 1.36.1003
+- Supported new features etc.
+
+2021-12-29 Version: 1.36.1002
+- Supported new features for outbound.
+
+2021-12-29 Version: 1.36.1001
+- Add ListDcdnEsTemplateInfo.
+
+2021-12-29 Version: 1.36.1000
+- Add ListDcdnEsTemplateInfo.
+
+2021-12-28 Version: 1.36.999
+- Support managed rule query.
+
 2021-12-27 Version: 1.36.998
 - Support ACR EE, OSS, EIP for deploy.
 

VERSION

@@ -1 +1 @@
-1.36.998
+1.36.1024

alb/CMakeLists.txt

@@ -149,6 +149,8 @@ set(alb_public_header_model
 	include/alibabacloud/alb/model/UpdateListenerAttributeResult.h
 	include/alibabacloud/alb/model/UpdateListenerLogConfigRequest.h
 	include/alibabacloud/alb/model/UpdateListenerLogConfigResult.h
+	include/alibabacloud/alb/model/UpdateLoadBalancerAddressTypeConfigRequest.h
+	include/alibabacloud/alb/model/UpdateLoadBalancerAddressTypeConfigResult.h
 	include/alibabacloud/alb/model/UpdateLoadBalancerAttributeRequest.h
 	include/alibabacloud/alb/model/UpdateLoadBalancerAttributeResult.h
 	include/alibabacloud/alb/model/UpdateLoadBalancerEditionRequest.h
@@ -296,6 +298,8 @@ set(alb_src
 	src/model/UpdateListenerAttributeResult.cc
 	src/model/UpdateListenerLogConfigRequest.cc
 	src/model/UpdateListenerLogConfigResult.cc
+	src/model/UpdateLoadBalancerAddressTypeConfigRequest.cc
+	src/model/UpdateLoadBalancerAddressTypeConfigResult.cc
 	src/model/UpdateLoadBalancerAttributeRequest.cc
 	src/model/UpdateLoadBalancerAttributeResult.cc
 	src/model/UpdateLoadBalancerEditionRequest.cc

alb/include/alibabacloud/alb/AlbClient.h

@@ -150,6 +150,8 @@
 #include "model/UpdateListenerAttributeResult.h"
 #include "model/UpdateListenerLogConfigRequest.h"
 #include "model/UpdateListenerLogConfigResult.h"
+#include "model/UpdateLoadBalancerAddressTypeConfigRequest.h"
+#include "model/UpdateLoadBalancerAddressTypeConfigResult.h"
 #include "model/UpdateLoadBalancerAttributeRequest.h"
 #include "model/UpdateLoadBalancerAttributeResult.h"
 #include "model/UpdateLoadBalancerEditionRequest.h"
@@ -367,6 +369,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateListenerLogConfigResult> UpdateListenerLogConfigOutcome;
 			typedef std::future<UpdateListenerLogConfigOutcome> UpdateListenerLogConfigOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::UpdateListenerLogConfigRequest&, const UpdateListenerLogConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateListenerLogConfigAsyncHandler;
+			typedef Outcome<Error, Model::UpdateLoadBalancerAddressTypeConfigResult> UpdateLoadBalancerAddressTypeConfigOutcome;
+			typedef std::future<UpdateLoadBalancerAddressTypeConfigOutcome> UpdateLoadBalancerAddressTypeConfigOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::UpdateLoadBalancerAddressTypeConfigRequest&, const UpdateLoadBalancerAddressTypeConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerAddressTypeConfigAsyncHandler;
 			typedef Outcome<Error, Model::UpdateLoadBalancerAttributeResult> UpdateLoadBalancerAttributeOutcome;
 			typedef std::future<UpdateLoadBalancerAttributeOutcome> UpdateLoadBalancerAttributeOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::UpdateLoadBalancerAttributeRequest&, const UpdateLoadBalancerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerAttributeAsyncHandler;
@@ -588,6 +593,9 @@ namespace AlibabaCloud
 			UpdateListenerLogConfigOutcome updateListenerLogConfig(const Model::UpdateListenerLogConfigRequest &request)const;
 			void updateListenerLogConfigAsync(const Model::UpdateListenerLogConfigRequest& request, const UpdateListenerLogConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateListenerLogConfigOutcomeCallable updateListenerLogConfigCallable(const Model::UpdateListenerLogConfigRequest& request) const;
+			UpdateLoadBalancerAddressTypeConfigOutcome updateLoadBalancerAddressTypeConfig(const Model::UpdateLoadBalancerAddressTypeConfigRequest &request)const;
+			void updateLoadBalancerAddressTypeConfigAsync(const Model::UpdateLoadBalancerAddressTypeConfigRequest& request, const UpdateLoadBalancerAddressTypeConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateLoadBalancerAddressTypeConfigOutcomeCallable updateLoadBalancerAddressTypeConfigCallable(const Model::UpdateLoadBalancerAddressTypeConfigRequest& request) const;
 			UpdateLoadBalancerAttributeOutcome updateLoadBalancerAttribute(const Model::UpdateLoadBalancerAttributeRequest &request)const;
 			void updateLoadBalancerAttributeAsync(const Model::UpdateLoadBalancerAttributeRequest& request, const UpdateLoadBalancerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateLoadBalancerAttributeOutcomeCallable updateLoadBalancerAttributeCallable(const Model::UpdateLoadBalancerAttributeRequest& request) const;

alb/include/alibabacloud/alb/model/CreateServerGroupRequest.h

@@ -68,6 +68,8 @@ public:
 	void setProtocol(const std::string &protocol);
 	bool getUpstreamKeepaliveEnabled() const;
 	void setUpstreamKeepaliveEnabled(bool upstreamKeepaliveEnabled);
+	std::string getServiceName() const;
+	void setServiceName(const std::string &serviceName);
 	StickySessionConfig getStickySessionConfig() const;
 	void setStickySessionConfig(const StickySessionConfig &stickySessionConfig);
 	bool getDryRun() const;
@@ -87,6 +89,7 @@ private:
 	std::string resourceGroupId_;
 	std::string protocol_;
 	bool upstreamKeepaliveEnabled_;
+	std::string serviceName_;
 	StickySessionConfig stickySessionConfig_;
 	bool dryRun_;
 	bool ipv6Enabled_;

alb/include/alibabacloud/alb/model/ListServerGroupsResult.h

@@ -76,6 +76,7 @@ namespace AlibabaCloud
 					bool ipv6Enabled;
 					bool configManagedEnabled;
 					std::string vpcId;
+					std::string serviceName;
 					std::string serviceManagedMode;
 					HealthCheckConfig healthCheckConfig;
 					std::string protocol;

alb/include/alibabacloud/alb/model/UpdateLoadBalancerAddressTypeConfigRequest.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERADDRESSTYPECONFIGREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERADDRESSTYPECONFIGREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT UpdateLoadBalancerAddressTypeConfigRequest : public RpcServiceRequest {
+public:
+	struct ZoneMappings {
+		std::string vSwitchId;
+		std::string zoneId;
+		std::string allocationId;
+	};
+	UpdateLoadBalancerAddressTypeConfigRequest();
+	~UpdateLoadBalancerAddressTypeConfigRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getAddressType() const;
+	void setAddressType(const std::string &addressType);
+	std::string getDryRun() const;
+	void setDryRun(const std::string &dryRun);
+	std::vector<ZoneMappings> getZoneMappings() const;
+	void setZoneMappings(const std::vector<ZoneMappings> &zoneMappings);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string addressType_;
+	std::string dryRun_;
+	std::vector<ZoneMappings> zoneMappings_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERADDRESSTYPECONFIGREQUEST_H_

alb/include/alibabacloud/alb/model/UpdateLoadBalancerAddressTypeConfigResult.h

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

alb/include/alibabacloud/alb/model/UpdateServerGroupAttributeRequest.h

@@ -66,6 +66,8 @@ public:
 	void setServerGroupId(const std::string &serverGroupId);
 	bool getUpstreamKeepaliveEnabled() const;
 	void setUpstreamKeepaliveEnabled(bool upstreamKeepaliveEnabled);
+	std::string getServiceName() const;
+	void setServiceName(const std::string &serviceName);
 	StickySessionConfig getStickySessionConfig() const;
 	void setStickySessionConfig(const StickySessionConfig &stickySessionConfig);
 	bool getDryRun() const;
@@ -78,6 +80,7 @@ private:
 	std::string scheduler_;
 	std::string serverGroupId_;
 	bool upstreamKeepaliveEnabled_;
+	std::string serviceName_;
 	StickySessionConfig stickySessionConfig_;
 	bool dryRun_;
 };

alb/src/AlbClient.cc

@@ -2355,6 +2355,42 @@ AlbClient::UpdateListenerLogConfigOutcomeCallable AlbClient::updateListenerLogCo
 	return task->get_future();
 }
 
+AlbClient::UpdateLoadBalancerAddressTypeConfigOutcome AlbClient::updateLoadBalancerAddressTypeConfig(const UpdateLoadBalancerAddressTypeConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateLoadBalancerAddressTypeConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateLoadBalancerAddressTypeConfigOutcome(UpdateLoadBalancerAddressTypeConfigResult(outcome.result()));
+	else
+		return UpdateLoadBalancerAddressTypeConfigOutcome(outcome.error());
+}
+
+void AlbClient::updateLoadBalancerAddressTypeConfigAsync(const UpdateLoadBalancerAddressTypeConfigRequest& request, const UpdateLoadBalancerAddressTypeConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateLoadBalancerAddressTypeConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlbClient::UpdateLoadBalancerAddressTypeConfigOutcomeCallable AlbClient::updateLoadBalancerAddressTypeConfigCallable(const UpdateLoadBalancerAddressTypeConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateLoadBalancerAddressTypeConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->updateLoadBalancerAddressTypeConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlbClient::UpdateLoadBalancerAttributeOutcome AlbClient::updateLoadBalancerAttribute(const UpdateLoadBalancerAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

alb/src/model/CreateServerGroupRequest.cc

@@ -105,6 +105,15 @@ void CreateServerGroupRequest::setUpstreamKeepaliveEnabled(bool upstreamKeepaliv
   setParameter(std::string("UpstreamKeepaliveEnabled"), upstreamKeepaliveEnabled ? "true" : "false");
 }
 
+std::string CreateServerGroupRequest::getServiceName() const {
+  return serviceName_;
+}
+
+void CreateServerGroupRequest::setServiceName(const std::string &serviceName) {
+  serviceName_ = serviceName;
+  setParameter(std::string("ServiceName"), serviceName);
+}
+
 CreateServerGroupRequest::StickySessionConfig CreateServerGroupRequest::getStickySessionConfig() const {
   return stickySessionConfig_;
 }

alb/src/model/ListServerGroupsResult.cc

@@ -71,6 +71,8 @@ void ListServerGroupsResult::parse(const std::string &payload)
 			serverGroupsObject.ipv6Enabled = valueServerGroupsServerGroup["Ipv6Enabled"].asString() == "true";
 		if(!valueServerGroupsServerGroup["ServerCount"].isNull())
 			serverGroupsObject.serverCount = std::stoi(valueServerGroupsServerGroup["ServerCount"].asString());
+		if(!valueServerGroupsServerGroup["ServiceName"].isNull())
+			serverGroupsObject.serviceName = valueServerGroupsServerGroup["ServiceName"].asString();
 		auto allTagsNode = valueServerGroupsServerGroup["Tags"]["Tag"];
 		for (auto valueServerGroupsServerGroupTagsTag : allTagsNode)
 		{

alb/src/model/UpdateLoadBalancerAddressTypeConfigRequest.cc

@@ -0,0 +1,76 @@
+/*
+ * 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/alb/model/UpdateLoadBalancerAddressTypeConfigRequest.h>
+
+using AlibabaCloud::Alb::Model::UpdateLoadBalancerAddressTypeConfigRequest;
+
+UpdateLoadBalancerAddressTypeConfigRequest::UpdateLoadBalancerAddressTypeConfigRequest()
+    : RpcServiceRequest("alb", "2020-06-16", "UpdateLoadBalancerAddressTypeConfig") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateLoadBalancerAddressTypeConfigRequest::~UpdateLoadBalancerAddressTypeConfigRequest() {}
+
+std::string UpdateLoadBalancerAddressTypeConfigRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void UpdateLoadBalancerAddressTypeConfigRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string UpdateLoadBalancerAddressTypeConfigRequest::getAddressType() const {
+  return addressType_;
+}
+
+void UpdateLoadBalancerAddressTypeConfigRequest::setAddressType(const std::string &addressType) {
+  addressType_ = addressType;
+  setParameter(std::string("AddressType"), addressType);
+}
+
+std::string UpdateLoadBalancerAddressTypeConfigRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void UpdateLoadBalancerAddressTypeConfigRequest::setDryRun(const std::string &dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun);
+}
+
+std::vector<UpdateLoadBalancerAddressTypeConfigRequest::ZoneMappings> UpdateLoadBalancerAddressTypeConfigRequest::getZoneMappings() const {
+  return zoneMappings_;
+}
+
+void UpdateLoadBalancerAddressTypeConfigRequest::setZoneMappings(const std::vector<UpdateLoadBalancerAddressTypeConfigRequest::ZoneMappings> &zoneMappings) {
+  zoneMappings_ = zoneMappings;
+  for(int dep1 = 0; dep1 != zoneMappings.size(); dep1++) {
+    setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".VSwitchId", zoneMappings[dep1].vSwitchId);
+    setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".ZoneId", zoneMappings[dep1].zoneId);
+    setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".AllocationId", zoneMappings[dep1].allocationId);
+  }
+}
+
+std::string UpdateLoadBalancerAddressTypeConfigRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void UpdateLoadBalancerAddressTypeConfigRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

alb/src/model/UpdateLoadBalancerAddressTypeConfigResult.cc

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

alb/src/model/UpdateServerGroupAttributeRequest.cc

@@ -96,6 +96,15 @@ void UpdateServerGroupAttributeRequest::setUpstreamKeepaliveEnabled(bool upstrea
   setParameter(std::string("UpstreamKeepaliveEnabled"), upstreamKeepaliveEnabled ? "true" : "false");
 }
 
+std::string UpdateServerGroupAttributeRequest::getServiceName() const {
+  return serviceName_;
+}
+
+void UpdateServerGroupAttributeRequest::setServiceName(const std::string &serviceName) {
+  serviceName_ = serviceName;
+  setParameter(std::string("ServiceName"), serviceName);
+}
+
 UpdateServerGroupAttributeRequest::StickySessionConfig UpdateServerGroupAttributeRequest::getStickySessionConfig() const {
   return stickySessionConfig_;
 }

cbn/CMakeLists.txt

@@ -83,6 +83,8 @@ set(cbn_public_header_model
 	include/alibabacloud/cbn/model/DeleteRouteServiceInCenResult.h
 	include/alibabacloud/cbn/model/DeleteTrafficMarkingPolicyRequest.h
 	include/alibabacloud/cbn/model/DeleteTrafficMarkingPolicyResult.h
+	include/alibabacloud/cbn/model/DeleteTransitRouterRequest.h
+	include/alibabacloud/cbn/model/DeleteTransitRouterResult.h
 	include/alibabacloud/cbn/model/DeleteTransitRouterPeerAttachmentRequest.h
 	include/alibabacloud/cbn/model/DeleteTransitRouterPeerAttachmentResult.h
 	include/alibabacloud/cbn/model/DeleteTransitRouterRouteEntryRequest.h
@@ -294,6 +296,8 @@ set(cbn_src
 	src/model/DeleteRouteServiceInCenResult.cc
 	src/model/DeleteTrafficMarkingPolicyRequest.cc
 	src/model/DeleteTrafficMarkingPolicyResult.cc
+	src/model/DeleteTransitRouterRequest.cc
+	src/model/DeleteTransitRouterResult.cc
 	src/model/DeleteTransitRouterPeerAttachmentRequest.cc
 	src/model/DeleteTransitRouterPeerAttachmentResult.cc
 	src/model/DeleteTransitRouterRouteEntryRequest.cc

cbn/include/alibabacloud/cbn/CbnClient.h

@@ -84,6 +84,8 @@
 #include "model/DeleteRouteServiceInCenResult.h"
 #include "model/DeleteTrafficMarkingPolicyRequest.h"
 #include "model/DeleteTrafficMarkingPolicyResult.h"
+#include "model/DeleteTransitRouterRequest.h"
+#include "model/DeleteTransitRouterResult.h"
 #include "model/DeleteTransitRouterPeerAttachmentRequest.h"
 #include "model/DeleteTransitRouterPeerAttachmentResult.h"
 #include "model/DeleteTransitRouterRouteEntryRequest.h"
@@ -332,6 +334,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteTrafficMarkingPolicyResult> DeleteTrafficMarkingPolicyOutcome;
 			typedef std::future<DeleteTrafficMarkingPolicyOutcome> DeleteTrafficMarkingPolicyOutcomeCallable;
 			typedef std::function<void(const CbnClient*, const Model::DeleteTrafficMarkingPolicyRequest&, const DeleteTrafficMarkingPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTrafficMarkingPolicyAsyncHandler;
+			typedef Outcome<Error, Model::DeleteTransitRouterResult> DeleteTransitRouterOutcome;
+			typedef std::future<DeleteTransitRouterOutcome> DeleteTransitRouterOutcomeCallable;
+			typedef std::function<void(const CbnClient*, const Model::DeleteTransitRouterRequest&, const DeleteTransitRouterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTransitRouterAsyncHandler;
 			typedef Outcome<Error, Model::DeleteTransitRouterPeerAttachmentResult> DeleteTransitRouterPeerAttachmentOutcome;
 			typedef std::future<DeleteTransitRouterPeerAttachmentOutcome> DeleteTransitRouterPeerAttachmentOutcomeCallable;
 			typedef std::function<void(const CbnClient*, const Model::DeleteTransitRouterPeerAttachmentRequest&, const DeleteTransitRouterPeerAttachmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTransitRouterPeerAttachmentAsyncHandler;
@@ -649,6 +654,9 @@ namespace AlibabaCloud
 			DeleteTrafficMarkingPolicyOutcome deleteTrafficMarkingPolicy(const Model::DeleteTrafficMarkingPolicyRequest &request)const;
 			void deleteTrafficMarkingPolicyAsync(const Model::DeleteTrafficMarkingPolicyRequest& request, const DeleteTrafficMarkingPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteTrafficMarkingPolicyOutcomeCallable deleteTrafficMarkingPolicyCallable(const Model::DeleteTrafficMarkingPolicyRequest& request) const;
+			DeleteTransitRouterOutcome deleteTransitRouter(const Model::DeleteTransitRouterRequest &request)const;
+			void deleteTransitRouterAsync(const Model::DeleteTransitRouterRequest& request, const DeleteTransitRouterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteTransitRouterOutcomeCallable deleteTransitRouterCallable(const Model::DeleteTransitRouterRequest& request) const;
 			DeleteTransitRouterPeerAttachmentOutcome deleteTransitRouterPeerAttachment(const Model::DeleteTransitRouterPeerAttachmentRequest &request)const;
 			void deleteTransitRouterPeerAttachmentAsync(const Model::DeleteTransitRouterPeerAttachmentRequest& request, const DeleteTransitRouterPeerAttachmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteTransitRouterPeerAttachmentOutcomeCallable deleteTransitRouterPeerAttachmentCallable(const Model::DeleteTransitRouterPeerAttachmentRequest& request) const;

cbn/include/alibabacloud/cbn/model/CreateTransitRouterRequest.h

@@ -34,6 +34,8 @@ public:
 	void setTransitRouterName(const std::string &transitRouterName);
 	long getResourceOwnerId() const;
 	void setResourceOwnerId(long resourceOwnerId);
+	std::string getServiceMode() const;
+	void setServiceMode(const std::string &serviceMode);
 	std::string getClientToken() const;
 	void setClientToken(const std::string &clientToken);
 	std::string getCenId() const;
@@ -56,6 +58,7 @@ public:
 private:
 	std::string transitRouterName_;
 	long resourceOwnerId_;
+	std::string serviceMode_;
 	std::string clientToken_;
 	std::string cenId_;
 	std::string type_;

cbn/include/alibabacloud/cbn/model/CreateTransitRouterVpcAttachmentRequest.h

@@ -36,6 +36,8 @@ public:
 	~CreateTransitRouterVpcAttachmentRequest();
 	long getResourceOwnerId() const;
 	void setResourceOwnerId(long resourceOwnerId);
+	std::string getServiceMode() const;
+	void setServiceMode(const std::string &serviceMode);
 	long getVpcOwnerId() const;
 	void setVpcOwnerId(long vpcOwnerId);
 	std::string getClientToken() const;
@@ -75,6 +77,7 @@ public:
 
 private:
 	long resourceOwnerId_;
+	std::string serviceMode_;
 	long vpcOwnerId_;
 	std::string clientToken_;
 	std::string cenId_;

cbn/include/alibabacloud/cbn/model/DeleteTransitRouterRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CBN_MODEL_DELETETRANSITROUTERREQUEST_H_
+#define ALIBABACLOUD_CBN_MODEL_DELETETRANSITROUTERREQUEST_H_
+
+#include <alibabacloud/cbn/CbnExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cbn {
+namespace Model {
+class ALIBABACLOUD_CBN_EXPORT DeleteTransitRouterRequest : public RpcServiceRequest {
+public:
+	DeleteTransitRouterRequest();
+	~DeleteTransitRouterRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getTransitRouterId() const;
+	void setTransitRouterId(const std::string &transitRouterId);
+
+private:
+	long resourceOwnerId_;
+	std::string clientToken_;
+	bool dryRun_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+	std::string transitRouterId_;
+};
+} // namespace Model
+} // namespace Cbn
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CBN_MODEL_DELETETRANSITROUTERREQUEST_H_

cbn/include/alibabacloud/cbn/model/DeleteTransitRouterResult.h

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

cbn/include/alibabacloud/cbn/model/ListTransitRouterVpcAttachmentsResult.h

@@ -38,6 +38,7 @@ namespace AlibabaCloud
 					{
 						std::string zoneId;
 						std::string vSwitchId;
+						std::string networkInterfaceId;
 					};
 					std::string status;
 					std::string transitRouterAttachmentId;
@@ -47,6 +48,7 @@ namespace AlibabaCloud
 					std::string transitRouterAttachmentName;
 					std::string resourceType;
 					std::vector<TransitRouterAttachment::ZoneMapping> zoneMappings;
+					std::string serviceMode;
 					std::string transitRouterAttachmentDescription;
 					long vpcOwnerId;
 					std::string transitRouterId;

cbn/include/alibabacloud/cbn/model/ListTransitRoutersResult.h

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 					std::string transitRouterDescription;
 					std::string transitRouterName;
 					std::string regionId;
+					std::string serviceMode;
 					std::string transitRouterId;
 					long aliUid;
 				};

cbn/src/CbnClient.cc

@@ -1167,6 +1167,42 @@ CbnClient::DeleteTrafficMarkingPolicyOutcomeCallable CbnClient::deleteTrafficMar
 	return task->get_future();
 }
 
+CbnClient::DeleteTransitRouterOutcome CbnClient::deleteTransitRouter(const DeleteTransitRouterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteTransitRouterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteTransitRouterOutcome(DeleteTransitRouterResult(outcome.result()));
+	else
+		return DeleteTransitRouterOutcome(outcome.error());
+}
+
+void CbnClient::deleteTransitRouterAsync(const DeleteTransitRouterRequest& request, const DeleteTransitRouterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteTransitRouter(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CbnClient::DeleteTransitRouterOutcomeCallable CbnClient::deleteTransitRouterCallable(const DeleteTransitRouterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteTransitRouterOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteTransitRouter(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CbnClient::DeleteTransitRouterPeerAttachmentOutcome CbnClient::deleteTransitRouterPeerAttachment(const DeleteTransitRouterPeerAttachmentRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

cbn/src/model/CreateTransitRouterRequest.cc

@@ -43,6 +43,15 @@ void CreateTransitRouterRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+std::string CreateTransitRouterRequest::getServiceMode() const {
+  return serviceMode_;
+}
+
+void CreateTransitRouterRequest::setServiceMode(const std::string &serviceMode) {
+  serviceMode_ = serviceMode;
+  setParameter(std::string("ServiceMode"), serviceMode);
+}
+
 std::string CreateTransitRouterRequest::getClientToken() const {
   return clientToken_;
 }

cbn/src/model/CreateTransitRouterVpcAttachmentRequest.cc

@@ -34,6 +34,15 @@ void CreateTransitRouterVpcAttachmentRequest::setResourceOwnerId(long resourceOw
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+std::string CreateTransitRouterVpcAttachmentRequest::getServiceMode() const {
+  return serviceMode_;
+}
+
+void CreateTransitRouterVpcAttachmentRequest::setServiceMode(const std::string &serviceMode) {
+  serviceMode_ = serviceMode;
+  setParameter(std::string("ServiceMode"), serviceMode);
+}
+
 long CreateTransitRouterVpcAttachmentRequest::getVpcOwnerId() const {
   return vpcOwnerId_;
 }

cbn/src/model/DeleteTransitRouterRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cbn/model/DeleteTransitRouterRequest.h>
+
+using AlibabaCloud::Cbn::Model::DeleteTransitRouterRequest;
+
+DeleteTransitRouterRequest::DeleteTransitRouterRequest()
+    : RpcServiceRequest("cbn", "2017-09-12", "DeleteTransitRouter") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteTransitRouterRequest::~DeleteTransitRouterRequest() {}
+
+long DeleteTransitRouterRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteTransitRouterRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DeleteTransitRouterRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void DeleteTransitRouterRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+bool DeleteTransitRouterRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void DeleteTransitRouterRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string DeleteTransitRouterRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DeleteTransitRouterRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DeleteTransitRouterRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DeleteTransitRouterRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DeleteTransitRouterRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteTransitRouterRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DeleteTransitRouterRequest::getTransitRouterId() const {
+  return transitRouterId_;
+}
+
+void DeleteTransitRouterRequest::setTransitRouterId(const std::string &transitRouterId) {
+  transitRouterId_ = transitRouterId;
+  setParameter(std::string("TransitRouterId"), transitRouterId);
+}
+

cbn/src/model/DeleteTransitRouterResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/r-kvstore/model/DeleteUserClusterHostResult.h>
+#include <alibabacloud/cbn/model/DeleteTransitRouterResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::R_kvstore;
-using namespace AlibabaCloud::R_kvstore::Model;
+using namespace AlibabaCloud::Cbn;
+using namespace AlibabaCloud::Cbn::Model;
 
-DeleteUserClusterHostResult::DeleteUserClusterHostResult() :
+DeleteTransitRouterResult::DeleteTransitRouterResult() :
 	ServiceResult()
 {}
 
-DeleteUserClusterHostResult::DeleteUserClusterHostResult(const std::string &payload) :
+DeleteTransitRouterResult::DeleteTransitRouterResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DeleteUserClusterHostResult::~DeleteUserClusterHostResult()
+DeleteTransitRouterResult::~DeleteTransitRouterResult()
 {}
 
-void DeleteUserClusterHostResult::parse(const std::string &payload)
+void DeleteTransitRouterResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

cbn/src/model/ListTransitRouterVpcAttachmentsResult.cc

@@ -63,6 +63,8 @@ void ListTransitRouterVpcAttachmentsResult::parse(const std::string &payload)
 			transitRouterAttachmentsObject.vpcRegionId = valueTransitRouterAttachmentsTransitRouterAttachment["VpcRegionId"].asString();
 		if(!valueTransitRouterAttachmentsTransitRouterAttachment["TransitRouterAttachmentName"].isNull())
 			transitRouterAttachmentsObject.transitRouterAttachmentName = valueTransitRouterAttachmentsTransitRouterAttachment["TransitRouterAttachmentName"].asString();
+		if(!valueTransitRouterAttachmentsTransitRouterAttachment["ServiceMode"].isNull())
+			transitRouterAttachmentsObject.serviceMode = valueTransitRouterAttachmentsTransitRouterAttachment["ServiceMode"].asString();
 		auto allZoneMappingsNode = valueTransitRouterAttachmentsTransitRouterAttachment["ZoneMappings"]["ZoneMapping"];
 		for (auto valueTransitRouterAttachmentsTransitRouterAttachmentZoneMappingsZoneMapping : allZoneMappingsNode)
 		{
@@ -71,6 +73,8 @@ void ListTransitRouterVpcAttachmentsResult::parse(const std::string &payload)
 				zoneMappingsObject.zoneId = valueTransitRouterAttachmentsTransitRouterAttachmentZoneMappingsZoneMapping["ZoneId"].asString();
 			if(!valueTransitRouterAttachmentsTransitRouterAttachmentZoneMappingsZoneMapping["VSwitchId"].isNull())
 				zoneMappingsObject.vSwitchId = valueTransitRouterAttachmentsTransitRouterAttachmentZoneMappingsZoneMapping["VSwitchId"].asString();
+			if(!valueTransitRouterAttachmentsTransitRouterAttachmentZoneMappingsZoneMapping["NetworkInterfaceId"].isNull())
+				zoneMappingsObject.networkInterfaceId = valueTransitRouterAttachmentsTransitRouterAttachmentZoneMappingsZoneMapping["NetworkInterfaceId"].asString();
 			transitRouterAttachmentsObject.zoneMappings.push_back(zoneMappingsObject);
 		}
 		transitRouterAttachments_.push_back(transitRouterAttachmentsObject);

cbn/src/model/ListTransitRoutersResult.cc

@@ -61,6 +61,8 @@ void ListTransitRoutersResult::parse(const std::string &payload)
 			transitRoutersObject.aliUid = std::stol(valueTransitRoutersTransitRouter["AliUid"].asString());
 		if(!valueTransitRoutersTransitRouter["RegionId"].isNull())
 			transitRoutersObject.regionId = valueTransitRoutersTransitRouter["RegionId"].asString();
+		if(!valueTransitRoutersTransitRouter["ServiceMode"].isNull())
+			transitRoutersObject.serviceMode = valueTransitRoutersTransitRouter["ServiceMode"].asString();
 		transitRouters_.push_back(transitRoutersObject);
 	}
 	if(!value["PageSize"].isNull())

ccc/include/alibabacloud/ccc/model/BargeInCallResult.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 releaseReason;
@@ -63,16 +63,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/BlindTransferResult.h

@@ -61,16 +61,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/CancelAttendedTransferResult.h

@@ -62,16 +62,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/ChangeWorkModeResult.h

@@ -37,12 +37,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;
 				};
 

ccc/include/alibabacloud/ccc/model/CoachCallResult.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 releaseReason;
@@ -63,18 +63,18 @@ namespace AlibabaCloud
 					{
 						std::string userState;
 						std::string instanceId;
-						std::string breakCode;
 						std::string deviceId;
+						std::string breakCode;
 						bool outboundScenario;
-						std::string mobile;
 						std::string uri;
+						std::string mobile;
 						std::vector<std::string> signedSkillGroupIdList;
 						std::string extension;
 						std::string deviceState;
 						std::string userId;
 						long heartbeat;
-						std::string jobId;
 						std::string workMode;
+						std::string jobId;
 						long reserved;
 					};
 					UserContext userContext;

ccc/include/alibabacloud/ccc/model/CompleteAttendedTransferResult.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 releaseReason;
@@ -63,16 +63,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/GetCallDetailRecordRequest.h

@@ -35,14 +35,14 @@ namespace AlibabaCloud
 				GetCallDetailRecordRequest();
 				~GetCallDetailRecordRequest();
 
-				std::string getInstanceId()const;
-				void setInstanceId(const std::string& instanceId);
 				std::string getContactId()const;
 				void setContactId(const std::string& contactId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
 
             private:
-				std::string instanceId_;
 				std::string contactId_;
+				std::string instanceId_;
 
 			};
 		}

ccc/include/alibabacloud/ccc/model/GetInstanceResult.h

@@ -52,8 +52,8 @@ namespace AlibabaCloud
 						struct SkillGroup
 						{
 							std::string description;
-							std::string instanceId;
 							int phoneNumberCount;
+							std::string instanceId;
 							int userCount;
 							std::string displayName;
 							std::string skillGroupId;
@@ -62,8 +62,8 @@ namespace AlibabaCloud
 						bool active;
 						std::string usage;
 						std::string number;
-						std::string contactFlowId;
 						std::string instanceId;
+						std::string contactFlowId;
 						std::string userId;
 						std::vector<PhoneNumber::SkillGroup> skillGroups;
 						std::string city;

ccc/include/alibabacloud/ccc/model/GetInstanceTrendingReportResult.h

@@ -41,8 +41,8 @@ namespace AlibabaCloud
 						long callsQueued;
 						long callsAbandonedInRing;
 						long callsHandled;
-						long callsAbandonedInIVR;
 						long statsTime;
+						long callsAbandonedInIVR;
 					};
 					struct OutboundItem
 					{

ccc/include/alibabacloud/ccc/model/GetLoginDetailsResult.h

@@ -36,12 +36,13 @@ namespace AlibabaCloud
 				{
 					std::string extension;
 					std::string agentServerUrl;
-					std::string deviceId;
 					std::string sipServerUrl;
+					std::string deviceId;
 					std::string userId;
 					std::string signature;
 					std::string userKey;
 					std::string displayName;
+					std::string workMode;
 				};
 
 

ccc/include/alibabacloud/ccc/model/GetRealtimeInstanceStatesResult.h

@@ -41,8 +41,8 @@ namespace AlibabaCloud
 					long loggedInAgents;
 					long readyAgents;
 					long waitingCalls;
-					long interactiveCalls;
 					long totalAgents;
+					long interactiveCalls;
 					long workingAgents;
 				};
 

ccc/include/alibabacloud/ccc/model/HoldCallResult.h

@@ -42,8 +42,8 @@ namespace AlibabaCloud
 							std::string channelState;
 							std::string releaseInitiator;
 							std::string callType;
-							std::string associatedData;
 							std::string skillGroupId;
+							std::string associatedData;
 							std::string channelId;
 							long timestamp;
 							std::string releaseReason;
@@ -61,16 +61,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/InitiateAttendedTransferResult.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 releaseReason;
@@ -63,16 +63,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/InterceptCallResult.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 releaseReason;
@@ -63,16 +63,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/LaunchAuthenticationResult.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 releaseReason;
@@ -63,16 +63,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/LaunchSurveyResult.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 releaseReason;
@@ -63,16 +63,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/ListBriefSkillGroupsResult.h

@@ -38,8 +38,8 @@ namespace AlibabaCloud
 					{
 						std::string description;
 						std::string skillGroupName;
-						std::string instanceId;
 						int phoneNumberCount;
+						std::string instanceId;
 						int userCount;
 						std::string displayName;
 						std::string skillGroupId;

ccc/include/alibabacloud/ccc/model/ListConfigItemsResult.h

@@ -35,8 +35,8 @@ namespace AlibabaCloud
 				struct ConfigItem
 				{
 					std::string objectType;
-					std::string instanceId;
 					std::string objectId;
+					std::string instanceId;
 					std::string value;
 					std::string name;
 				};

ccc/include/alibabacloud/ccc/model/ListContactFlowsResult.h

@@ -37,10 +37,10 @@ namespace AlibabaCloud
 					struct ContactFlow
 					{
 						std::string type;
-						std::string createdTime;
 						std::string description;
-						std::string contactFlowId;
+						std::string createdTime;
 						std::string instanceId;
+						std::string contactFlowId;
 						std::string definition;
 						bool published;
 						std::vector<std::string> numberList;

ccc/include/alibabacloud/ccc/model/ListHistoricalSkillGroupReportResult.h

@@ -38,17 +38,17 @@ namespace AlibabaCloud
 					{
 						struct Inbound
 						{
-							long callsAbandonedInQueue;
 							float serviceLevel20;
+							long callsAbandonedInQueue;
 							long totalWorkTime;
-							long callsRinged;
 							long totalHoldTime;
+							long callsRinged;
 							float averageHoldTime;
 							long callsAbandoned;
-							long callsOffered;
 							long maxRingTime;
-							long callsHold;
+							long callsOffered;
 							float satisfactionIndex;
+							long callsHold;
 							long maxAbandonedInRingTime;
 							long totalRingTime;
 							float handleRate;
@@ -61,14 +61,14 @@ namespace AlibabaCloud
 							float satisfactionRate;
 							long callsAttendedTransferOut;
 							long totalAbandonTime;
-							float averageTalkTime;
 							long maxHoldTime;
+							float averageTalkTime;
 							long maxAbandonedInQueueTime;
 							long callsTimeout;
 							long satisfactionSurveysOffered;
 							long callsAbandonedInRing;
-							long callsHandled;
 							long callsOverflow;
+							long callsHandled;
 							long maxWaitTime;
 							long satisfactionSurveysResponded;
 							long callsAttendedTransferIn;
@@ -80,20 +80,20 @@ namespace AlibabaCloud
 							float averageWorkTime;
 							long callsBlindTransferOut;
 							long totalAbandonedInQueueTime;
-							long callsBlindTransferIn;
 							long maxWorkTime;
+							long callsBlindTransferIn;
 							float abandonRate;
 						};
 						struct Outbound
 						{
 							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;
@@ -104,16 +104,16 @@ namespace AlibabaCloud
 							float satisfactionRate;
 							long callsAttendedTransferOut;
 							float answerRate;
-							float averageTalkTime;
 							long maxHoldTime;
+							float averageTalkTime;
 							long satisfactionSurveysOffered;
 							long satisfactionSurveysResponded;
 							long callsAttendedTransferIn;
 							float averageRingTime;
 							float averageWorkTime;
 							long callsBlindTransferOut;
-							long callsBlindTransferIn;
 							long maxWorkTime;
+							long callsBlindTransferIn;
 						};
 						struct Overall
 						{
@@ -122,8 +122,8 @@ namespace AlibabaCloud
 							long totalCalls;
 							long totalWorkTime;
 							long totalHoldTime;
-							float averageHoldTime;
 							long satisfactionSurveysOffered;
+							float averageHoldTime;
 							float satisfactionIndex;
 							float averageBreakTime;
 							long satisfactionSurveysResponded;
@@ -131,14 +131,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/ListInstancesOfUserResult.h

@@ -54,8 +54,8 @@ namespace AlibabaCloud
 							struct SkillGroup
 							{
 								std::string description;
-								std::string instanceId;
 								int phoneNumberCount;
+								std::string instanceId;
 								int userCount;
 								std::string displayName;
 								std::string skillGroupId;
@@ -64,8 +64,8 @@ namespace AlibabaCloud
 							bool active;
 							std::string usage;
 							std::string number;
-							std::string contactFlowId;
 							std::string instanceId;
+							std::string contactFlowId;
 							std::string userId;
 							std::vector<PhoneNumber::SkillGroup> skillGroups;
 							std::string city;

ccc/include/alibabacloud/ccc/model/ListInstancesResult.h

@@ -58,8 +58,8 @@ namespace AlibabaCloud
 						std::string description;
 						std::string consoleUrl;
 						std::string domainName;
-						std::string aliyunUid;
 						long createTime;
+						std::string aliyunUid;
 						std::vector<CallCenterInstance::PhoneNumber> numberList;
 						std::string id;
 						std::string name;

ccc/include/alibabacloud/ccc/model/ListIntervalAgentReportResult.h

@@ -37,21 +37,21 @@ namespace AlibabaCloud
 					struct Inbound
 					{
 						long totalWorkTime;
-						long callsRinged;
 						long totalHoldTime;
+						long callsRinged;
 						float averageHoldTime;
-						long callsOffered;
 						long maxRingTime;
-						long callsHold;
+						long callsOffered;
 						float satisfactionIndex;
+						long callsHold;
 						long totalRingTime;
 						float handleRate;
 						long totalTalkTime;
 						long maxTalkTime;
 						float satisfactionRate;
 						long callsAttendedTransferOut;
-						float averageTalkTime;
 						long maxHoldTime;
+						float averageTalkTime;
 						long satisfactionSurveysOffered;
 						long callsHandled;
 						long satisfactionSurveysResponded;
@@ -59,19 +59,19 @@ namespace AlibabaCloud
 						float averageRingTime;
 						float averageWorkTime;
 						long callsBlindTransferOut;
-						long callsBlindTransferIn;
 						long maxWorkTime;
+						long callsBlindTransferIn;
 					};
 					struct Outbound
 					{
 						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;
@@ -82,27 +82,27 @@ namespace AlibabaCloud
 						float satisfactionRate;
 						long callsAttendedTransferOut;
 						float answerRate;
-						float averageTalkTime;
 						long maxHoldTime;
+						float averageTalkTime;
 						long satisfactionSurveysOffered;
 						long satisfactionSurveysResponded;
 						long callsAttendedTransferIn;
 						float averageRingTime;
 						float averageWorkTime;
 						long callsBlindTransferOut;
-						long callsBlindTransferIn;
 						long maxWorkTime;
+						long callsBlindTransferIn;
 					};
 					struct Overall
 					{
 						long totalReadyTime;
 						long lastCheckoutTime;
-						long totalBreakTime;
 						long totalCalls;
+						long totalBreakTime;
 						long totalWorkTime;
 						long totalHoldTime;
-						float averageHoldTime;
 						long satisfactionSurveysOffered;
+						float averageHoldTime;
 						float satisfactionIndex;
 						float averageBreakTime;
 						long firstCheckInTime;
@@ -114,11 +114,11 @@ namespace AlibabaCloud
 						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/ListIntervalSkillGroupReportResult.h

@@ -36,17 +36,17 @@ namespace AlibabaCloud
 				{
 					struct Inbound
 					{
-						long callsAbandonedInQueue;
 						float serviceLevel20;
+						long callsAbandonedInQueue;
 						long totalWorkTime;
-						long callsRinged;
 						long totalHoldTime;
+						long callsRinged;
 						float averageHoldTime;
 						long callsAbandoned;
-						long callsOffered;
 						long maxRingTime;
-						long callsHold;
+						long callsOffered;
 						float satisfactionIndex;
+						long callsHold;
 						long maxAbandonedInRingTime;
 						long totalRingTime;
 						float handleRate;
@@ -59,14 +59,14 @@ namespace AlibabaCloud
 						float satisfactionRate;
 						long callsAttendedTransferOut;
 						long totalAbandonTime;
-						float averageTalkTime;
 						long maxHoldTime;
+						float averageTalkTime;
 						long maxAbandonedInQueueTime;
 						long callsTimeout;
 						long satisfactionSurveysOffered;
 						long callsAbandonedInRing;
-						long callsHandled;
 						long callsOverflow;
+						long callsHandled;
 						long maxWaitTime;
 						long satisfactionSurveysResponded;
 						long callsAttendedTransferIn;
@@ -78,20 +78,20 @@ namespace AlibabaCloud
 						float averageWorkTime;
 						long callsBlindTransferOut;
 						long totalAbandonedInQueueTime;
-						long callsBlindTransferIn;
 						long maxWorkTime;
+						long callsBlindTransferIn;
 						float abandonRate;
 					};
 					struct Outbound
 					{
 						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;
@@ -102,16 +102,16 @@ namespace AlibabaCloud
 						float satisfactionRate;
 						long callsAttendedTransferOut;
 						float answerRate;
-						float averageTalkTime;
 						long maxHoldTime;
+						float averageTalkTime;
 						long satisfactionSurveysOffered;
 						long satisfactionSurveysResponded;
 						long callsAttendedTransferIn;
 						float averageRingTime;
 						float averageWorkTime;
 						long callsBlindTransferOut;
-						long callsBlindTransferIn;
 						long maxWorkTime;
+						long callsBlindTransferIn;
 					};
 					struct Overall
 					{
@@ -120,8 +120,8 @@ namespace AlibabaCloud
 						long totalCalls;
 						long totalWorkTime;
 						long totalHoldTime;
-						float averageHoldTime;
 						long satisfactionSurveysOffered;
+						float averageHoldTime;
 						float satisfactionIndex;
 						float averageBreakTime;
 						long satisfactionSurveysResponded;
@@ -129,14 +129,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/ListIvrTrackingDetailsResult.h

@@ -40,8 +40,8 @@ namespace AlibabaCloud
 						std::string instance;
 						std::string nodeName;
 						long enterTime;
-						std::string contactId;
 						std::string nodeExitCode;
+						std::string contactId;
 						std::string channelId;
 						std::string channelVariables;
 						std::string flowId;

ccc/include/alibabacloud/ccc/model/ListPersonalNumbersOfUserResult.h

@@ -38,8 +38,8 @@ namespace AlibabaCloud
 					{
 						bool active;
 						std::string number;
-						std::string contactFlowId;
 						std::string instanceId;
+						std::string contactFlowId;
 						std::string city;
 						std::string province;
 					};

ccc/include/alibabacloud/ccc/model/ListPhoneNumbersOfSkillGroupResult.h

@@ -39,8 +39,8 @@ namespace AlibabaCloud
 						bool active;
 						std::string usage;
 						std::string number;
-						std::string contactFlowId;
 						std::string instanceId;
+						std::string contactFlowId;
 						std::string city;
 						std::string province;
 					};

ccc/include/alibabacloud/ccc/model/ListPhoneNumbersResult.h

@@ -44,8 +44,8 @@ namespace AlibabaCloud
 							std::string name;
 						};
 						std::string usage;
-						std::string contactFlowId;
 						std::string instanceId;
+						std::string contactFlowId;
 						std::string createTime;
 						std::vector<PhoneNumber::SkillGroup> skillGroups;
 						std::string city;

ccc/include/alibabacloud/ccc/model/ListRecentCallDetailRecordsResult.h

@@ -41,8 +41,8 @@ namespace AlibabaCloud
 						std::string contactType;
 						std::string contactDisposition;
 						std::string instanceId;
-						std::string agentIds;
 						long startTime;
+						std::string agentIds;
 						long duration;
 						std::string contactId;
 						std::string callDuration;

ccc/include/alibabacloud/ccc/model/ListSipCallRecordsRequest.h

@@ -35,14 +35,14 @@ namespace AlibabaCloud
 				ListSipCallRecordsRequest();
 				~ListSipCallRecordsRequest();
 
-				std::string getInstanceId()const;
-				void setInstanceId(const std::string& instanceId);
 				std::string getContactIdList()const;
 				void setContactIdList(const std::string& contactIdList);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
 
             private:
-				std::string instanceId_;
 				std::string contactIdList_;
+				std::string instanceId_;
 
 			};
 		}

ccc/include/alibabacloud/ccc/model/ListSkillLevelsOfUserResult.h

@@ -36,8 +36,8 @@ namespace AlibabaCloud
 				{
 					struct UserSkillLevel
 					{
-						std::string skillGroupName;
 						std::string skillLevel;
+						std::string skillGroupName;
 						std::string skillGroupId;
 					};
 					int totalCount;

ccc/include/alibabacloud/ccc/model/ListUserLevelsOfSkillGroupResult.h

@@ -38,8 +38,8 @@ namespace AlibabaCloud
 					{
 						std::string loginName;
 						std::string roleName;
-						std::string skillGroupName;
 						int skillLevel;
+						std::string skillGroupName;
 						std::string userId;
 						std::string displayName;
 						std::string skillGroupId;

ccc/include/alibabacloud/ccc/model/MonitorCallResult.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 releaseReason;
@@ -63,16 +63,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/MuteCallResult.h

@@ -62,16 +62,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/ReadyForServiceResult.h

@@ -37,12 +37,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;
 				};
 

ccc/src/CCCClient.cc

@@ -31,21 +31,21 @@ CCCClient::CCCClient(const Credentials &credentials, const ClientConfiguration &
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "CCC");
 }
 
 CCCClient::CCCClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "CCC");
 }
 
 CCCClient::CCCClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "CCC");
 }
 
 CCCClient::~CCCClient()

ccc/src/model/AssignUsersResult.cc

@@ -39,18 +39,18 @@ void AssignUsersResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Data"].isNull())
-		data_ = value["Data"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
 	if(!value["Sync"].isNull())
 		sync_ = value["Sync"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
 	if(!value["WorkflowId"].isNull())
 		workflowId_ = value["WorkflowId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
 
 }
 

ccc/src/model/BargeInCallResult.cc

@@ -51,63 +51,63 @@ void BargeInCallResult::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["Index"].isNull())
+			channelContextObject.index = std::stoi(callContextNodeChannelContextsChannelContext["Index"].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["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["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["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["UserExtension"].isNull())
 			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
-		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
-			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].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["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["UserState"].isNull())
-		data_.userContext.userState = userContextNode["UserState"].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["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());

ccc/src/model/BlindTransferResult.cc

@@ -51,59 +51,59 @@ void BlindTransferResult::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["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["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["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["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["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["UserState"].isNull())
-		data_.userContext.userState = userContextNode["UserState"].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["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());

ccc/src/model/CancelAttendedTransferResult.cc

@@ -53,61 +53,61 @@ void CancelAttendedTransferResult::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["Index"].isNull())
+			channelContextObject.index = std::stoi(callContextNodeChannelContextsChannelContext["Index"].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["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["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["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["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["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["UserState"].isNull())
-		data_.userContext.userState = userContextNode["UserState"].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["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());

ccc/src/model/ChangeWorkModeResult.cc

@@ -40,24 +40,24 @@ void ChangeWorkModeResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["BreakCode"].isNull())
-		data_.breakCode = dataNode["BreakCode"].asString();
-	if(!dataNode["DeviceId"].isNull())
-		data_.deviceId = dataNode["DeviceId"].asString();
 	if(!dataNode["Extension"].isNull())
 		data_.extension = dataNode["Extension"].asString();
-	if(!dataNode["InstanceId"].isNull())
-		data_.instanceId = dataNode["InstanceId"].asString();
-	if(!dataNode["JobId"].isNull())
-		data_.jobId = dataNode["JobId"].asString();
-	if(!dataNode["OutboundScenario"].isNull())
-		data_.outboundScenario = dataNode["OutboundScenario"].asString() == "true";
-	if(!dataNode["UserId"].isNull())
-		data_.userId = dataNode["UserId"].asString();
-	if(!dataNode["UserState"].isNull())
-		data_.userState = dataNode["UserState"].asString();
 	if(!dataNode["WorkMode"].isNull())
 		data_.workMode = dataNode["WorkMode"].asString();
+	if(!dataNode["DeviceId"].isNull())
+		data_.deviceId = dataNode["DeviceId"].asString();
+	if(!dataNode["JobId"].isNull())
+		data_.jobId = dataNode["JobId"].asString();
+	if(!dataNode["UserId"].isNull())
+		data_.userId = dataNode["UserId"].asString();
+	if(!dataNode["BreakCode"].isNull())
+		data_.breakCode = dataNode["BreakCode"].asString();
+	if(!dataNode["InstanceId"].isNull())
+		data_.instanceId = dataNode["InstanceId"].asString();
+	if(!dataNode["OutboundScenario"].isNull())
+		data_.outboundScenario = dataNode["OutboundScenario"].asString() == "true";
+	if(!dataNode["UserState"].isNull())
+		data_.userState = dataNode["UserState"].asString();
 		auto allSignedSkillGroupIdList = dataNode["SignedSkillGroupIdList"]["SkillGroupId"];
 		for (auto value : allSignedSkillGroupIdList)
 			data_.signedSkillGroupIdList.push_back(value.asString());

ccc/src/model/CoachCallResult.cc

@@ -51,67 +51,67 @@ void CoachCallResult::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["Index"].isNull())
+			channelContextObject.index = std::stoi(callContextNodeChannelContextsChannelContext["Index"].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["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["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["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["UserExtension"].isNull())
 			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
-		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
-			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].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["DeviceState"].isNull())
-		data_.userContext.deviceState = userContextNode["DeviceState"].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["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["Uri"].isNull())
-		data_.userContext.uri = userContextNode["Uri"].asString();
-	if(!userContextNode["UserId"].isNull())
-		data_.userContext.userId = userContextNode["UserId"].asString();
-	if(!userContextNode["UserState"].isNull())
-		data_.userContext.userState = userContextNode["UserState"].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["Uri"].isNull())
+		data_.userContext.uri = userContextNode["Uri"].asString();
+	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());

ccc/src/model/CompleteAttendedTransferResult.cc

@@ -53,63 +53,63 @@ void CompleteAttendedTransferResult::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["Index"].isNull())
+			channelContextObject.index = std::stoi(callContextNodeChannelContextsChannelContext["Index"].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["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["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["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["UserExtension"].isNull())
 			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
-		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
-			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].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["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["UserState"].isNull())
-		data_.userContext.userState = userContextNode["UserState"].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["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());

ccc/src/model/CreateInstanceResult.cc

@@ -42,14 +42,14 @@ void CreateInstanceResult::parse(const std::string &payload)
 	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["Data"].isNull())
-		data_ = value["Data"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
 
 }
 

ccc/src/model/CreateSkillGroupResult.cc

@@ -40,10 +40,10 @@ void CreateSkillGroupResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["Description"].isNull())
-		data_.description = dataNode["Description"].asString();
 	if(!dataNode["InstanceId"].isNull())
 		data_.instanceId = dataNode["InstanceId"].asString();
+	if(!dataNode["Description"].isNull())
+		data_.description = dataNode["Description"].asString();
 	if(!dataNode["Name"].isNull())
 		data_.name = dataNode["Name"].asString();
 	if(!dataNode["SkillGroupId"].isNull())

ccc/src/model/CreateUserResult.cc

@@ -42,18 +42,18 @@ void CreateUserResult::parse(const std::string &payload)
 	auto dataNode = value["Data"];
 	if(!dataNode["DisplayName"].isNull())
 		data_.displayName = dataNode["DisplayName"].asString();
-	if(!dataNode["Email"].isNull())
-		data_.email = dataNode["Email"].asString();
 	if(!dataNode["Extension"].isNull())
 		data_.extension = dataNode["Extension"].asString();
+	if(!dataNode["Email"].isNull())
+		data_.email = dataNode["Email"].asString();
 	if(!dataNode["LoginName"].isNull())
 		data_.loginName = dataNode["LoginName"].asString();
+	if(!dataNode["WorkMode"].isNull())
+		data_.workMode = dataNode["WorkMode"].asString();
 	if(!dataNode["Mobile"].isNull())
 		data_.mobile = dataNode["Mobile"].asString();
 	if(!dataNode["UserId"].isNull())
 		data_.userId = dataNode["UserId"].asString();
-	if(!dataNode["WorkMode"].isNull())
-		data_.workMode = dataNode["WorkMode"].asString();
 	auto allParams = value["Params"]["Param"];
 	for (const auto &item : allParams)
 		params_.push_back(item.asString());

ccc/src/model/GetCallDetailRecordRequest.cc

@@ -27,17 +27,6 @@ GetCallDetailRecordRequest::GetCallDetailRecordRequest() :
 GetCallDetailRecordRequest::~GetCallDetailRecordRequest()
 {}
 
-std::string GetCallDetailRecordRequest::getInstanceId()const
-{
-	return instanceId_;
-}
-
-void GetCallDetailRecordRequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
-}
-
 std::string GetCallDetailRecordRequest::getContactId()const
 {
 	return contactId_;
@@ -49,3 +38,14 @@ void GetCallDetailRecordRequest::setContactId(const std::string& contactId)
 	setParameter("ContactId", contactId);
 }
 
+std::string GetCallDetailRecordRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void GetCallDetailRecordRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

ccc/src/model/GetInstanceResult.cc

@@ -40,44 +40,44 @@ void GetInstanceResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["AliyunUid"].isNull())
-		data_.aliyunUid = dataNode["AliyunUid"].asString();
+	if(!dataNode["Status"].isNull())
+		data_.status = dataNode["Status"].asString();
 	if(!dataNode["ConsoleUrl"].isNull())
 		data_.consoleUrl = dataNode["ConsoleUrl"].asString();
 	if(!dataNode["Description"].isNull())
 		data_.description = dataNode["Description"].asString();
+	if(!dataNode["AliyunUid"].isNull())
+		data_.aliyunUid = dataNode["AliyunUid"].asString();
+	if(!dataNode["Name"].isNull())
+		data_.name = dataNode["Name"].asString();
 	if(!dataNode["DomainName"].isNull())
 		data_.domainName = dataNode["DomainName"].asString();
 	if(!dataNode["Id"].isNull())
 		data_.id = dataNode["Id"].asString();
-	if(!dataNode["Name"].isNull())
-		data_.name = dataNode["Name"].asString();
-	if(!dataNode["Status"].isNull())
-		data_.status = dataNode["Status"].asString();
 	auto allAdminListNode = dataNode["AdminList"]["User"];
 	for (auto dataNodeAdminListUser : allAdminListNode)
 	{
 		Data::User userObject;
 		if(!dataNodeAdminListUser["DisplayName"].isNull())
 			userObject.displayName = dataNodeAdminListUser["DisplayName"].asString();
-		if(!dataNodeAdminListUser["Email"].isNull())
-			userObject.email = dataNodeAdminListUser["Email"].asString();
 		if(!dataNodeAdminListUser["Extension"].isNull())
 			userObject.extension = dataNodeAdminListUser["Extension"].asString();
-		if(!dataNodeAdminListUser["InstanceId"].isNull())
-			userObject.instanceId = dataNodeAdminListUser["InstanceId"].asString();
 		if(!dataNodeAdminListUser["LoginName"].isNull())
 			userObject.loginName = dataNodeAdminListUser["LoginName"].asString();
-		if(!dataNodeAdminListUser["Mobile"].isNull())
-			userObject.mobile = dataNodeAdminListUser["Mobile"].asString();
-		if(!dataNodeAdminListUser["RoleId"].isNull())
-			userObject.roleId = dataNodeAdminListUser["RoleId"].asString();
-		if(!dataNodeAdminListUser["RoleName"].isNull())
-			userObject.roleName = dataNodeAdminListUser["RoleName"].asString();
-		if(!dataNodeAdminListUser["UserId"].isNull())
-			userObject.userId = dataNodeAdminListUser["UserId"].asString();
+		if(!dataNodeAdminListUser["Email"].isNull())
+			userObject.email = dataNodeAdminListUser["Email"].asString();
 		if(!dataNodeAdminListUser["WorkMode"].isNull())
 			userObject.workMode = dataNodeAdminListUser["WorkMode"].asString();
+		if(!dataNodeAdminListUser["Mobile"].isNull())
+			userObject.mobile = dataNodeAdminListUser["Mobile"].asString();
+		if(!dataNodeAdminListUser["UserId"].isNull())
+			userObject.userId = dataNodeAdminListUser["UserId"].asString();
+		if(!dataNodeAdminListUser["RoleName"].isNull())
+			userObject.roleName = dataNodeAdminListUser["RoleName"].asString();
+		if(!dataNodeAdminListUser["InstanceId"].isNull())
+			userObject.instanceId = dataNodeAdminListUser["InstanceId"].asString();
+		if(!dataNodeAdminListUser["RoleId"].isNull())
+			userObject.roleId = dataNodeAdminListUser["RoleId"].asString();
 		data_.adminList.push_back(userObject);
 	}
 	auto allNumberListNode = dataNode["NumberList"]["PhoneNumber"];
@@ -86,38 +86,38 @@ void GetInstanceResult::parse(const std::string &payload)
 		Data::PhoneNumber phoneNumberObject;
 		if(!dataNodeNumberListPhoneNumber["Active"].isNull())
 			phoneNumberObject.active = dataNodeNumberListPhoneNumber["Active"].asString() == "true";
-		if(!dataNodeNumberListPhoneNumber["City"].isNull())
-			phoneNumberObject.city = dataNodeNumberListPhoneNumber["City"].asString();
-		if(!dataNodeNumberListPhoneNumber["ContactFlowId"].isNull())
-			phoneNumberObject.contactFlowId = dataNodeNumberListPhoneNumber["ContactFlowId"].asString();
-		if(!dataNodeNumberListPhoneNumber["InstanceId"].isNull())
-			phoneNumberObject.instanceId = dataNodeNumberListPhoneNumber["InstanceId"].asString();
-		if(!dataNodeNumberListPhoneNumber["Number"].isNull())
-			phoneNumberObject.number = dataNodeNumberListPhoneNumber["Number"].asString();
-		if(!dataNodeNumberListPhoneNumber["Province"].isNull())
-			phoneNumberObject.province = dataNodeNumberListPhoneNumber["Province"].asString();
-		if(!dataNodeNumberListPhoneNumber["Usage"].isNull())
-			phoneNumberObject.usage = dataNodeNumberListPhoneNumber["Usage"].asString();
 		if(!dataNodeNumberListPhoneNumber["UserId"].isNull())
 			phoneNumberObject.userId = dataNodeNumberListPhoneNumber["UserId"].asString();
+		if(!dataNodeNumberListPhoneNumber["Number"].isNull())
+			phoneNumberObject.number = dataNodeNumberListPhoneNumber["Number"].asString();
+		if(!dataNodeNumberListPhoneNumber["City"].isNull())
+			phoneNumberObject.city = dataNodeNumberListPhoneNumber["City"].asString();
+		if(!dataNodeNumberListPhoneNumber["InstanceId"].isNull())
+			phoneNumberObject.instanceId = dataNodeNumberListPhoneNumber["InstanceId"].asString();
+		if(!dataNodeNumberListPhoneNumber["Usage"].isNull())
+			phoneNumberObject.usage = dataNodeNumberListPhoneNumber["Usage"].asString();
+		if(!dataNodeNumberListPhoneNumber["ContactFlowId"].isNull())
+			phoneNumberObject.contactFlowId = dataNodeNumberListPhoneNumber["ContactFlowId"].asString();
+		if(!dataNodeNumberListPhoneNumber["Province"].isNull())
+			phoneNumberObject.province = dataNodeNumberListPhoneNumber["Province"].asString();
 		auto allSkillGroupsNode = dataNodeNumberListPhoneNumber["SkillGroups"]["SkillGroup"];
 		for (auto dataNodeNumberListPhoneNumberSkillGroupsSkillGroup : allSkillGroupsNode)
 		{
 			Data::PhoneNumber::SkillGroup skillGroupsObject;
-			if(!dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["Description"].isNull())
-				skillGroupsObject.description = dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["Description"].asString();
 			if(!dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["DisplayName"].isNull())
 				skillGroupsObject.displayName = dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["DisplayName"].asString();
-			if(!dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["InstanceId"].isNull())
-				skillGroupsObject.instanceId = dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["InstanceId"].asString();
-			if(!dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["Name"].isNull())
-				skillGroupsObject.name = dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["Name"].asString();
+			if(!dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["Description"].isNull())
+				skillGroupsObject.description = dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["Description"].asString();
 			if(!dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["PhoneNumberCount"].isNull())
 				skillGroupsObject.phoneNumberCount = std::stoi(dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["PhoneNumberCount"].asString());
 			if(!dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["SkillGroupId"].isNull())
 				skillGroupsObject.skillGroupId = dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["SkillGroupId"].asString();
 			if(!dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["UserCount"].isNull())
 				skillGroupsObject.userCount = std::stoi(dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["UserCount"].asString());
+			if(!dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["InstanceId"].isNull())
+				skillGroupsObject.instanceId = dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["InstanceId"].asString();
+			if(!dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["Name"].isNull())
+				skillGroupsObject.name = dataNodeNumberListPhoneNumberSkillGroupsSkillGroup["Name"].asString();
 			phoneNumberObject.skillGroups.push_back(skillGroupsObject);
 		}
 		data_.numberList.push_back(phoneNumberObject);

ccc/src/model/GetInstanceTrendingReportResult.cc

@@ -44,30 +44,30 @@ void GetInstanceTrendingReportResult::parse(const std::string &payload)
 	for (auto dataNodeInboundInboundItem : allInboundNode)
 	{
 		Data::InboundItem inboundItemObject;
-		if(!dataNodeInboundInboundItem["CallsAbandonedInIVR"].isNull())
-			inboundItemObject.callsAbandonedInIVR = std::stol(dataNodeInboundInboundItem["CallsAbandonedInIVR"].asString());
-		if(!dataNodeInboundInboundItem["CallsAbandonedInQueue"].isNull())
-			inboundItemObject.callsAbandonedInQueue = std::stol(dataNodeInboundInboundItem["CallsAbandonedInQueue"].asString());
+		if(!dataNodeInboundInboundItem["StatsTime"].isNull())
+			inboundItemObject.statsTime = std::stol(dataNodeInboundInboundItem["StatsTime"].asString());
+		if(!dataNodeInboundInboundItem["CallsQueued"].isNull())
+			inboundItemObject.callsQueued = std::stol(dataNodeInboundInboundItem["CallsQueued"].asString());
 		if(!dataNodeInboundInboundItem["CallsAbandonedInRing"].isNull())
 			inboundItemObject.callsAbandonedInRing = std::stol(dataNodeInboundInboundItem["CallsAbandonedInRing"].asString());
 		if(!dataNodeInboundInboundItem["CallsHandled"].isNull())
 			inboundItemObject.callsHandled = std::stol(dataNodeInboundInboundItem["CallsHandled"].asString());
-		if(!dataNodeInboundInboundItem["CallsQueued"].isNull())
-			inboundItemObject.callsQueued = std::stol(dataNodeInboundInboundItem["CallsQueued"].asString());
-		if(!dataNodeInboundInboundItem["StatsTime"].isNull())
-			inboundItemObject.statsTime = std::stol(dataNodeInboundInboundItem["StatsTime"].asString());
 		if(!dataNodeInboundInboundItem["TotalCalls"].isNull())
 			inboundItemObject.totalCalls = std::stol(dataNodeInboundInboundItem["TotalCalls"].asString());
+		if(!dataNodeInboundInboundItem["CallsAbandonedInIVR"].isNull())
+			inboundItemObject.callsAbandonedInIVR = std::stol(dataNodeInboundInboundItem["CallsAbandonedInIVR"].asString());
+		if(!dataNodeInboundInboundItem["CallsAbandonedInQueue"].isNull())
+			inboundItemObject.callsAbandonedInQueue = std::stol(dataNodeInboundInboundItem["CallsAbandonedInQueue"].asString());
 		data_.inbound.push_back(inboundItemObject);
 	}
 	auto allOutboundNode = dataNode["Outbound"]["OutboundItem"];
 	for (auto dataNodeOutboundOutboundItem : allOutboundNode)
 	{
 		Data::OutboundItem outboundItemObject;
-		if(!dataNodeOutboundOutboundItem["CallsAnswered"].isNull())
-			outboundItemObject.callsAnswered = std::stol(dataNodeOutboundOutboundItem["CallsAnswered"].asString());
 		if(!dataNodeOutboundOutboundItem["StatsTime"].isNull())
 			outboundItemObject.statsTime = std::stol(dataNodeOutboundOutboundItem["StatsTime"].asString());
+		if(!dataNodeOutboundOutboundItem["CallsAnswered"].isNull())
+			outboundItemObject.callsAnswered = std::stol(dataNodeOutboundOutboundItem["CallsAnswered"].asString());
 		if(!dataNodeOutboundOutboundItem["TotalCalls"].isNull())
 			outboundItemObject.totalCalls = std::stol(dataNodeOutboundOutboundItem["TotalCalls"].asString());
 		data_.outbound.push_back(outboundItemObject);

ccc/src/model/GetLoginDetailsResult.cc

@@ -40,8 +40,6 @@ void GetLoginDetailsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["DeviceId"].isNull())
-		data_.deviceId = dataNode["DeviceId"].asString();
 	if(!dataNode["DisplayName"].isNull())
 		data_.displayName = dataNode["DisplayName"].asString();
 	if(!dataNode["Extension"].isNull())
@@ -50,12 +48,16 @@ void GetLoginDetailsResult::parse(const std::string &payload)
 		data_.signature = dataNode["Signature"].asString();
 	if(!dataNode["SipServerUrl"].isNull())
 		data_.sipServerUrl = dataNode["SipServerUrl"].asString();
+	if(!dataNode["DeviceId"].isNull())
+		data_.deviceId = dataNode["DeviceId"].asString();
+	if(!dataNode["AgentServerUrl"].isNull())
+		data_.agentServerUrl = dataNode["AgentServerUrl"].asString();
 	if(!dataNode["UserId"].isNull())
 		data_.userId = dataNode["UserId"].asString();
 	if(!dataNode["UserKey"].isNull())
 		data_.userKey = dataNode["UserKey"].asString();
-	if(!dataNode["AgentServerUrl"].isNull())
-		data_.agentServerUrl = dataNode["AgentServerUrl"].asString();
+	if(!dataNode["WorkMode"].isNull())
+		data_.workMode = dataNode["WorkMode"].asString();
 	auto allParams = value["Params"]["Param"];
 	for (const auto &item : allParams)
 		params_.push_back(item.asString());

ccc/src/model/GetMultiChannelRecordingResult.cc

@@ -40,10 +40,10 @@ void GetMultiChannelRecordingResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["FileName"].isNull())
-		data_.fileName = dataNode["FileName"].asString();
 	if(!dataNode["FileUrl"].isNull())
 		data_.fileUrl = dataNode["FileUrl"].asString();
+	if(!dataNode["FileName"].isNull())
+		data_.fileName = dataNode["FileName"].asString();
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
 	if(!value["HttpStatusCode"].isNull())

ccc/src/model/GetNumberLocationResult.cc

@@ -40,10 +40,10 @@ void GetNumberLocationResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["City"].isNull())
-		data_.city = dataNode["City"].asString();
 	if(!dataNode["Number"].isNull())
 		data_.number = dataNode["Number"].asString();
+	if(!dataNode["City"].isNull())
+		data_.city = dataNode["City"].asString();
 	if(!dataNode["Province"].isNull())
 		data_.province = dataNode["Province"].asString();
 	if(!value["Code"].isNull())

ccc/src/model/GetRealtimeInstanceStatesResult.cc

@@ -40,26 +40,26 @@ void GetRealtimeInstanceStatesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["BreakingAgents"].isNull())
-		data_.breakingAgents = std::stol(dataNode["BreakingAgents"].asString());
-	if(!dataNode["InstanceId"].isNull())
-		data_.instanceId = dataNode["InstanceId"].asString();
-	if(!dataNode["InteractiveCalls"].isNull())
-		data_.interactiveCalls = std::stol(dataNode["InteractiveCalls"].asString());
-	if(!dataNode["LoggedInAgents"].isNull())
-		data_.loggedInAgents = std::stol(dataNode["LoggedInAgents"].asString());
+	if(!dataNode["WorkingAgents"].isNull())
+		data_.workingAgents = std::stol(dataNode["WorkingAgents"].asString());
 	if(!dataNode["LongestWaitingTime"].isNull())
 		data_.longestWaitingTime = std::stol(dataNode["LongestWaitingTime"].asString());
-	if(!dataNode["ReadyAgents"].isNull())
-		data_.readyAgents = std::stol(dataNode["ReadyAgents"].asString());
-	if(!dataNode["TalkingAgents"].isNull())
-		data_.talkingAgents = std::stol(dataNode["TalkingAgents"].asString());
+	if(!dataNode["LoggedInAgents"].isNull())
+		data_.loggedInAgents = std::stol(dataNode["LoggedInAgents"].asString());
 	if(!dataNode["TotalAgents"].isNull())
 		data_.totalAgents = std::stol(dataNode["TotalAgents"].asString());
 	if(!dataNode["WaitingCalls"].isNull())
 		data_.waitingCalls = std::stol(dataNode["WaitingCalls"].asString());
-	if(!dataNode["WorkingAgents"].isNull())
-		data_.workingAgents = std::stol(dataNode["WorkingAgents"].asString());
+	if(!dataNode["BreakingAgents"].isNull())
+		data_.breakingAgents = std::stol(dataNode["BreakingAgents"].asString());
+	if(!dataNode["TalkingAgents"].isNull())
+		data_.talkingAgents = std::stol(dataNode["TalkingAgents"].asString());
+	if(!dataNode["InteractiveCalls"].isNull())
+		data_.interactiveCalls = std::stol(dataNode["InteractiveCalls"].asString());
+	if(!dataNode["ReadyAgents"].isNull())
+		data_.readyAgents = std::stol(dataNode["ReadyAgents"].asString());
+	if(!dataNode["InstanceId"].isNull())
+		data_.instanceId = dataNode["InstanceId"].asString();
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
 	if(!value["HttpStatusCode"].isNull())

ccc/src/model/GetTurnCredentialsResult.cc

@@ -40,10 +40,10 @@ void GetTurnCredentialsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["Password"].isNull())
-		data_.password = dataNode["Password"].asString();
 	if(!dataNode["UserName"].isNull())
 		data_.userName = dataNode["UserName"].asString();
+	if(!dataNode["Password"].isNull())
+		data_.password = dataNode["Password"].asString();
 	auto allParams = value["Params"]["Param"];
 	for (const auto &item : allParams)
 		params_.push_back(item.asString());

ccc/src/model/GetTurnServerListResult.cc

@@ -42,14 +42,14 @@ void GetTurnServerListResult::parse(const std::string &payload)
 	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["Data"].isNull())
-		data_ = value["Data"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
 
 }
 

ccc/src/model/GetUserResult.cc

@@ -42,24 +42,24 @@ void GetUserResult::parse(const std::string &payload)
 	auto dataNode = value["Data"];
 	if(!dataNode["DisplayName"].isNull())
 		data_.displayName = dataNode["DisplayName"].asString();
-	if(!dataNode["Email"].isNull())
-		data_.email = dataNode["Email"].asString();
 	if(!dataNode["Extension"].isNull())
 		data_.extension = dataNode["Extension"].asString();
-	if(!dataNode["InstanceId"].isNull())
-		data_.instanceId = dataNode["InstanceId"].asString();
 	if(!dataNode["LoginName"].isNull())
 		data_.loginName = dataNode["LoginName"].asString();
-	if(!dataNode["Mobile"].isNull())
-		data_.mobile = dataNode["Mobile"].asString();
-	if(!dataNode["RoleId"].isNull())
-		data_.roleId = dataNode["RoleId"].asString();
-	if(!dataNode["RoleName"].isNull())
-		data_.roleName = dataNode["RoleName"].asString();
-	if(!dataNode["UserId"].isNull())
-		data_.userId = dataNode["UserId"].asString();
+	if(!dataNode["Email"].isNull())
+		data_.email = dataNode["Email"].asString();
 	if(!dataNode["WorkMode"].isNull())
 		data_.workMode = dataNode["WorkMode"].asString();
+	if(!dataNode["Mobile"].isNull())
+		data_.mobile = dataNode["Mobile"].asString();
+	if(!dataNode["UserId"].isNull())
+		data_.userId = dataNode["UserId"].asString();
+	if(!dataNode["RoleName"].isNull())
+		data_.roleName = dataNode["RoleName"].asString();
+	if(!dataNode["InstanceId"].isNull())
+		data_.instanceId = dataNode["InstanceId"].asString();
+	if(!dataNode["RoleId"].isNull())
+		data_.roleId = dataNode["RoleId"].asString();
 	auto allParams = value["Params"]["Param"];
 	for (const auto &item : allParams)
 		params_.push_back(item.asString());

ccc/src/model/HoldCallResult.cc

@@ -51,59 +51,59 @@ void HoldCallResult::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["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["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["UserId"].isNull())
+			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].asString();
 		if(!callContextNodeChannelContextsChannelContext["SkillGroupId"].isNull())
 			channelContextObject.skillGroupId = callContextNodeChannelContextsChannelContext["SkillGroupId"].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();
-		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["Heartbeat"].isNull())
 		data_.userContext.heartbeat = std::stol(userContextNode["Heartbeat"].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["UserState"].isNull())
-		data_.userContext.userState = userContextNode["UserState"].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["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());

ccc/src/model/InitiateAttendedTransferResult.cc

@@ -53,63 +53,63 @@ void InitiateAttendedTransferResult::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["Index"].isNull())
+			channelContextObject.index = std::stoi(callContextNodeChannelContextsChannelContext["Index"].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["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["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["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["UserExtension"].isNull())
 			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
-		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
-			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].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["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["UserState"].isNull())
-		data_.userContext.userState = userContextNode["UserState"].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["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());

ccc/src/model/InterceptCallResult.cc

@@ -51,63 +51,63 @@ void InterceptCallResult::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["Index"].isNull())
+			channelContextObject.index = std::stoi(callContextNodeChannelContextsChannelContext["Index"].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["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["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["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["UserExtension"].isNull())
 			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
-		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
-			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].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["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["UserState"].isNull())
-		data_.userContext.userState = userContextNode["UserState"].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["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());

ccc/src/model/LaunchAuthenticationResult.cc

@@ -51,63 +51,63 @@ void LaunchAuthenticationResult::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["Index"].isNull())
+			channelContextObject.index = std::stoi(callContextNodeChannelContextsChannelContext["Index"].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["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["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["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["UserExtension"].isNull())
 			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
-		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
-			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].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["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["UserState"].isNull())
-		data_.userContext.userState = userContextNode["UserState"].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["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());

ccc/src/model/LaunchSurveyResult.cc

@@ -51,63 +51,63 @@ void LaunchSurveyResult::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["Index"].isNull())
+			channelContextObject.index = std::stoi(callContextNodeChannelContextsChannelContext["Index"].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["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["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["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["UserExtension"].isNull())
 			channelContextObject.userExtension = callContextNodeChannelContextsChannelContext["UserExtension"].asString();
-		if(!callContextNodeChannelContextsChannelContext["UserId"].isNull())
-			channelContextObject.userId = callContextNodeChannelContextsChannelContext["UserId"].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["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["UserState"].isNull())
-		data_.userContext.userState = userContextNode["UserState"].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["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());

ccc/src/model/ListAgentStateLogsResult.cc

@@ -43,14 +43,14 @@ void ListAgentStateLogsResult::parse(const std::string &payload)
 	for (auto valueDataDataItem : allDataNode)
 	{
 		DataItem dataObject;
-		if(!valueDataDataItem["Duration"].isNull())
-			dataObject.duration = std::stol(valueDataDataItem["Duration"].asString());
 		if(!valueDataDataItem["StartTime"].isNull())
 			dataObject.startTime = std::stol(valueDataDataItem["StartTime"].asString());
-		if(!valueDataDataItem["State"].isNull())
-			dataObject.state = valueDataDataItem["State"].asString();
 		if(!valueDataDataItem["StateCode"].isNull())
 			dataObject.stateCode = valueDataDataItem["StateCode"].asString();
+		if(!valueDataDataItem["Duration"].isNull())
+			dataObject.duration = std::stol(valueDataDataItem["Duration"].asString());
+		if(!valueDataDataItem["State"].isNull())
+			dataObject.state = valueDataDataItem["State"].asString();
 		data_.push_back(dataObject);
 	}
 	if(!value["Code"].isNull())

ccc/src/model/ListBriefSkillGroupsResult.cc

@@ -50,12 +50,10 @@ void ListBriefSkillGroupsResult::parse(const std::string &payload)
 	for (auto dataNodeListSkillGroup : allListNode)
 	{
 		Data::SkillGroup skillGroupObject;
-		if(!dataNodeListSkillGroup["Description"].isNull())
-			skillGroupObject.description = dataNodeListSkillGroup["Description"].asString();
 		if(!dataNodeListSkillGroup["DisplayName"].isNull())
 			skillGroupObject.displayName = dataNodeListSkillGroup["DisplayName"].asString();
-		if(!dataNodeListSkillGroup["InstanceId"].isNull())
-			skillGroupObject.instanceId = dataNodeListSkillGroup["InstanceId"].asString();
+		if(!dataNodeListSkillGroup["Description"].isNull())
+			skillGroupObject.description = dataNodeListSkillGroup["Description"].asString();
 		if(!dataNodeListSkillGroup["PhoneNumberCount"].isNull())
 			skillGroupObject.phoneNumberCount = std::stoi(dataNodeListSkillGroup["PhoneNumberCount"].asString());
 		if(!dataNodeListSkillGroup["SkillGroupId"].isNull())
@@ -64,6 +62,8 @@ void ListBriefSkillGroupsResult::parse(const std::string &payload)
 			skillGroupObject.skillGroupName = dataNodeListSkillGroup["SkillGroupName"].asString();
 		if(!dataNodeListSkillGroup["UserCount"].isNull())
 			skillGroupObject.userCount = std::stoi(dataNodeListSkillGroup["UserCount"].asString());
+		if(!dataNodeListSkillGroup["InstanceId"].isNull())
+			skillGroupObject.instanceId = dataNodeListSkillGroup["InstanceId"].asString();
 		data_.list.push_back(skillGroupObject);
 	}
 	if(!value["Code"].isNull())

ccc/src/model/ListConfigItemsResult.cc

@@ -43,16 +43,16 @@ void ListConfigItemsResult::parse(const std::string &payload)
 	for (auto valueDataConfigItem : allDataNode)
 	{
 		ConfigItem dataObject;
+		if(!valueDataConfigItem["ObjectId"].isNull())
+			dataObject.objectId = valueDataConfigItem["ObjectId"].asString();
+		if(!valueDataConfigItem["Value"].isNull())
+			dataObject.value = valueDataConfigItem["Value"].asString();
+		if(!valueDataConfigItem["ObjectType"].isNull())
+			dataObject.objectType = valueDataConfigItem["ObjectType"].asString();
 		if(!valueDataConfigItem["InstanceId"].isNull())
 			dataObject.instanceId = valueDataConfigItem["InstanceId"].asString();
 		if(!valueDataConfigItem["Name"].isNull())
 			dataObject.name = valueDataConfigItem["Name"].asString();
-		if(!valueDataConfigItem["ObjectId"].isNull())
-			dataObject.objectId = valueDataConfigItem["ObjectId"].asString();
-		if(!valueDataConfigItem["ObjectType"].isNull())
-			dataObject.objectType = valueDataConfigItem["ObjectType"].asString();
-		if(!valueDataConfigItem["Value"].isNull())
-			dataObject.value = valueDataConfigItem["Value"].asString();
 		data_.push_back(dataObject);
 	}
 	auto allParams = value["Params"]["Param"];

ccc/src/model/ListContactFlowsResult.cc

@@ -50,28 +50,28 @@ void ListContactFlowsResult::parse(const std::string &payload)
 	for (auto dataNodeListContactFlow : allListNode)
 	{
 		Data::ContactFlow contactFlowObject;
-		if(!dataNodeListContactFlow["ContactFlowId"].isNull())
-			contactFlowObject.contactFlowId = dataNodeListContactFlow["ContactFlowId"].asString();
-		if(!dataNodeListContactFlow["CreatedTime"].isNull())
-			contactFlowObject.createdTime = dataNodeListContactFlow["CreatedTime"].asString();
+		if(!dataNodeListContactFlow["Type"].isNull())
+			contactFlowObject.type = dataNodeListContactFlow["Type"].asString();
 		if(!dataNodeListContactFlow["Definition"].isNull())
 			contactFlowObject.definition = dataNodeListContactFlow["Definition"].asString();
-		if(!dataNodeListContactFlow["Description"].isNull())
-			contactFlowObject.description = dataNodeListContactFlow["Description"].asString();
 		if(!dataNodeListContactFlow["DraftId"].isNull())
 			contactFlowObject.draftId = dataNodeListContactFlow["DraftId"].asString();
+		if(!dataNodeListContactFlow["Description"].isNull())
+			contactFlowObject.description = dataNodeListContactFlow["Description"].asString();
+		if(!dataNodeListContactFlow["UpdatedTime"].isNull())
+			contactFlowObject.updatedTime = dataNodeListContactFlow["UpdatedTime"].asString();
 		if(!dataNodeListContactFlow["Editor"].isNull())
 			contactFlowObject.editor = dataNodeListContactFlow["Editor"].asString();
+		if(!dataNodeListContactFlow["Published"].isNull())
+			contactFlowObject.published = dataNodeListContactFlow["Published"].asString() == "true";
 		if(!dataNodeListContactFlow["InstanceId"].isNull())
 			contactFlowObject.instanceId = dataNodeListContactFlow["InstanceId"].asString();
 		if(!dataNodeListContactFlow["Name"].isNull())
 			contactFlowObject.name = dataNodeListContactFlow["Name"].asString();
-		if(!dataNodeListContactFlow["Published"].isNull())
-			contactFlowObject.published = dataNodeListContactFlow["Published"].asString() == "true";
-		if(!dataNodeListContactFlow["Type"].isNull())
-			contactFlowObject.type = dataNodeListContactFlow["Type"].asString();
-		if(!dataNodeListContactFlow["UpdatedTime"].isNull())
-			contactFlowObject.updatedTime = dataNodeListContactFlow["UpdatedTime"].asString();
+		if(!dataNodeListContactFlow["ContactFlowId"].isNull())
+			contactFlowObject.contactFlowId = dataNodeListContactFlow["ContactFlowId"].asString();
+		if(!dataNodeListContactFlow["CreatedTime"].isNull())
+			contactFlowObject.createdTime = dataNodeListContactFlow["CreatedTime"].asString();
 		auto allNumberList = value["NumberList"]["NumberList"];
 		for (auto value : allNumberList)
 			contactFlowObject.numberList.push_back(value.asString());

ccc/src/model/ListDevicesResult.cc

@@ -43,20 +43,20 @@ void ListDevicesResult::parse(const std::string &payload)
 	for (auto valueDataDevice : allDataNode)
 	{
 		Device dataObject;
-		if(!valueDataDevice["CallId"].isNull())
-			dataObject.callId = valueDataDevice["CallId"].asString();
+		if(!valueDataDevice["Extension"].isNull())
+			dataObject.extension = valueDataDevice["Extension"].asString();
+		if(!valueDataDevice["Expires"].isNull())
+			dataObject.expires = std::stol(valueDataDevice["Expires"].asString());
 		if(!valueDataDevice["Contact"].isNull())
 			dataObject.contact = valueDataDevice["Contact"].asString();
 		if(!valueDataDevice["DeviceId"].isNull())
 			dataObject.deviceId = valueDataDevice["DeviceId"].asString();
-		if(!valueDataDevice["Expires"].isNull())
-			dataObject.expires = std::stol(valueDataDevice["Expires"].asString());
-		if(!valueDataDevice["Extension"].isNull())
-			dataObject.extension = valueDataDevice["Extension"].asString();
-		if(!valueDataDevice["InstanceId"].isNull())
-			dataObject.instanceId = valueDataDevice["InstanceId"].asString();
 		if(!valueDataDevice["UserId"].isNull())
 			dataObject.userId = valueDataDevice["UserId"].asString();
+		if(!valueDataDevice["CallId"].isNull())
+			dataObject.callId = valueDataDevice["CallId"].asString();
+		if(!valueDataDevice["InstanceId"].isNull())
+			dataObject.instanceId = valueDataDevice["InstanceId"].asString();
 		data_.push_back(dataObject);
 	}
 	auto allParams = value["Params"]["Param"];

ccc/src/model/ListHistoricalSkillGroupReportResult.cc

@@ -50,203 +50,203 @@ void ListHistoricalSkillGroupReportResult::parse(const std::string &payload)
 	for (auto dataNodeListItems : allListNode)
 	{
 		Data::Items itemsObject;
-		if(!dataNodeListItems["SkillGroupId"].isNull())
-			itemsObject.skillGroupId = dataNodeListItems["SkillGroupId"].asString();
 		if(!dataNodeListItems["SkillGroupName"].isNull())
 			itemsObject.skillGroupName = dataNodeListItems["SkillGroupName"].asString();
+		if(!dataNodeListItems["SkillGroupId"].isNull())
+			itemsObject.skillGroupId = dataNodeListItems["SkillGroupId"].asString();
 		auto inboundNode = value["Inbound"];
-		if(!inboundNode["AbandonRate"].isNull())
-			itemsObject.inbound.abandonRate = std::stof(inboundNode["AbandonRate"].asString());
-		if(!inboundNode["AverageAbandonTime"].isNull())
-			itemsObject.inbound.averageAbandonTime = std::stof(inboundNode["AverageAbandonTime"].asString());
-		if(!inboundNode["AverageAbandonedInQueueTime"].isNull())
-			itemsObject.inbound.averageAbandonedInQueueTime = std::stof(inboundNode["AverageAbandonedInQueueTime"].asString());
-		if(!inboundNode["AverageAbandonedInRingTime"].isNull())
-			itemsObject.inbound.averageAbandonedInRingTime = std::stof(inboundNode["AverageAbandonedInRingTime"].asString());
-		if(!inboundNode["AverageHoldTime"].isNull())
-			itemsObject.inbound.averageHoldTime = std::stof(inboundNode["AverageHoldTime"].asString());
 		if(!inboundNode["AverageRingTime"].isNull())
 			itemsObject.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
-		if(!inboundNode["AverageTalkTime"].isNull())
-			itemsObject.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].asString());
-		if(!inboundNode["AverageWaitTime"].isNull())
-			itemsObject.inbound.averageWaitTime = std::stof(inboundNode["AverageWaitTime"].asString());
-		if(!inboundNode["AverageWorkTime"].isNull())
-			itemsObject.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
-		if(!inboundNode["CallsAbandoned"].isNull())
-			itemsObject.inbound.callsAbandoned = std::stol(inboundNode["CallsAbandoned"].asString());
-		if(!inboundNode["CallsAbandonedInQueue"].isNull())
-			itemsObject.inbound.callsAbandonedInQueue = std::stol(inboundNode["CallsAbandonedInQueue"].asString());
-		if(!inboundNode["CallsAbandonedInRing"].isNull())
-			itemsObject.inbound.callsAbandonedInRing = std::stol(inboundNode["CallsAbandonedInRing"].asString());
-		if(!inboundNode["CallsAttendedTransferIn"].isNull())
-			itemsObject.inbound.callsAttendedTransferIn = std::stol(inboundNode["CallsAttendedTransferIn"].asString());
-		if(!inboundNode["CallsAttendedTransferOut"].isNull())
-			itemsObject.inbound.callsAttendedTransferOut = std::stol(inboundNode["CallsAttendedTransferOut"].asString());
-		if(!inboundNode["CallsBlindTransferIn"].isNull())
-			itemsObject.inbound.callsBlindTransferIn = std::stol(inboundNode["CallsBlindTransferIn"].asString());
-		if(!inboundNode["CallsBlindTransferOut"].isNull())
-			itemsObject.inbound.callsBlindTransferOut = std::stol(inboundNode["CallsBlindTransferOut"].asString());
-		if(!inboundNode["CallsHandled"].isNull())
-			itemsObject.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
-		if(!inboundNode["CallsHold"].isNull())
-			itemsObject.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
-		if(!inboundNode["CallsOffered"].isNull())
-			itemsObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
 		if(!inboundNode["CallsOverflow"].isNull())
 			itemsObject.inbound.callsOverflow = std::stol(inboundNode["CallsOverflow"].asString());
-		if(!inboundNode["CallsQueued"].isNull())
-			itemsObject.inbound.callsQueued = std::stol(inboundNode["CallsQueued"].asString());
-		if(!inboundNode["CallsRinged"].isNull())
-			itemsObject.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
-		if(!inboundNode["CallsTimeout"].isNull())
-			itemsObject.inbound.callsTimeout = std::stol(inboundNode["CallsTimeout"].asString());
-		if(!inboundNode["HandleRate"].isNull())
-			itemsObject.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
-		if(!inboundNode["MaxAbandonTime"].isNull())
-			itemsObject.inbound.maxAbandonTime = std::stol(inboundNode["MaxAbandonTime"].asString());
-		if(!inboundNode["MaxAbandonedInQueueTime"].isNull())
-			itemsObject.inbound.maxAbandonedInQueueTime = std::stol(inboundNode["MaxAbandonedInQueueTime"].asString());
-		if(!inboundNode["MaxAbandonedInRingTime"].isNull())
-			itemsObject.inbound.maxAbandonedInRingTime = std::stol(inboundNode["MaxAbandonedInRingTime"].asString());
-		if(!inboundNode["MaxHoldTime"].isNull())
-			itemsObject.inbound.maxHoldTime = std::stol(inboundNode["MaxHoldTime"].asString());
-		if(!inboundNode["MaxRingTime"].isNull())
-			itemsObject.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
-		if(!inboundNode["MaxTalkTime"].isNull())
-			itemsObject.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].asString());
-		if(!inboundNode["MaxWaitTime"].isNull())
-			itemsObject.inbound.maxWaitTime = std::stol(inboundNode["MaxWaitTime"].asString());
-		if(!inboundNode["MaxWorkTime"].isNull())
-			itemsObject.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
-		if(!inboundNode["SatisfactionIndex"].isNull())
-			itemsObject.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
-		if(!inboundNode["SatisfactionRate"].isNull())
-			itemsObject.inbound.satisfactionRate = std::stof(inboundNode["SatisfactionRate"].asString());
-		if(!inboundNode["SatisfactionSurveysOffered"].isNull())
-			itemsObject.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
-		if(!inboundNode["SatisfactionSurveysResponded"].isNull())
-			itemsObject.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].asString());
-		if(!inboundNode["ServiceLevel20"].isNull())
-			itemsObject.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
-		if(!inboundNode["TotalAbandonTime"].isNull())
-			itemsObject.inbound.totalAbandonTime = std::stol(inboundNode["TotalAbandonTime"].asString());
-		if(!inboundNode["TotalAbandonedInQueueTime"].isNull())
-			itemsObject.inbound.totalAbandonedInQueueTime = std::stol(inboundNode["TotalAbandonedInQueueTime"].asString());
-		if(!inboundNode["TotalAbandonedInRingTime"].isNull())
-			itemsObject.inbound.totalAbandonedInRingTime = std::stol(inboundNode["TotalAbandonedInRingTime"].asString());
-		if(!inboundNode["TotalHoldTime"].isNull())
-			itemsObject.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
-		if(!inboundNode["TotalRingTime"].isNull())
-			itemsObject.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
-		if(!inboundNode["TotalTalkTime"].isNull())
-			itemsObject.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
-		if(!inboundNode["TotalWaitTime"].isNull())
-			itemsObject.inbound.totalWaitTime = std::stol(inboundNode["TotalWaitTime"].asString());
+		if(!inboundNode["CallsAbandonedInRing"].isNull())
+			itemsObject.inbound.callsAbandonedInRing = std::stol(inboundNode["CallsAbandonedInRing"].asString());
+		if(!inboundNode["CallsHandled"].isNull())
+			itemsObject.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
 		if(!inboundNode["TotalWorkTime"].isNull())
 			itemsObject.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
+		if(!inboundNode["TotalAbandonedInRingTime"].isNull())
+			itemsObject.inbound.totalAbandonedInRingTime = std::stol(inboundNode["TotalAbandonedInRingTime"].asString());
+		if(!inboundNode["MaxWorkTime"].isNull())
+			itemsObject.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
+		if(!inboundNode["CallsAttendedTransferOut"].isNull())
+			itemsObject.inbound.callsAttendedTransferOut = std::stol(inboundNode["CallsAttendedTransferOut"].asString());
+		if(!inboundNode["AverageWaitTime"].isNull())
+			itemsObject.inbound.averageWaitTime = std::stof(inboundNode["AverageWaitTime"].asString());
+		if(!inboundNode["TotalHoldTime"].isNull())
+			itemsObject.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
+		if(!inboundNode["MaxAbandonTime"].isNull())
+			itemsObject.inbound.maxAbandonTime = std::stol(inboundNode["MaxAbandonTime"].asString());
+		if(!inboundNode["AverageWorkTime"].isNull())
+			itemsObject.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
+		if(!inboundNode["CallsQueued"].isNull())
+			itemsObject.inbound.callsQueued = std::stol(inboundNode["CallsQueued"].asString());
+		if(!inboundNode["CallsBlindTransferIn"].isNull())
+			itemsObject.inbound.callsBlindTransferIn = std::stol(inboundNode["CallsBlindTransferIn"].asString());
+		if(!inboundNode["SatisfactionIndex"].isNull())
+			itemsObject.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+		if(!inboundNode["AverageAbandonedInRingTime"].isNull())
+			itemsObject.inbound.averageAbandonedInRingTime = std::stof(inboundNode["AverageAbandonedInRingTime"].asString());
+		if(!inboundNode["AverageAbandonTime"].isNull())
+			itemsObject.inbound.averageAbandonTime = std::stof(inboundNode["AverageAbandonTime"].asString());
+		if(!inboundNode["CallsRinged"].isNull())
+			itemsObject.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
+		if(!inboundNode["CallsBlindTransferOut"].isNull())
+			itemsObject.inbound.callsBlindTransferOut = std::stol(inboundNode["CallsBlindTransferOut"].asString());
+		if(!inboundNode["CallsAttendedTransferIn"].isNull())
+			itemsObject.inbound.callsAttendedTransferIn = std::stol(inboundNode["CallsAttendedTransferIn"].asString());
+		if(!inboundNode["CallsAbandoned"].isNull())
+			itemsObject.inbound.callsAbandoned = std::stol(inboundNode["CallsAbandoned"].asString());
+		if(!inboundNode["MaxAbandonedInQueueTime"].isNull())
+			itemsObject.inbound.maxAbandonedInQueueTime = std::stol(inboundNode["MaxAbandonedInQueueTime"].asString());
+		if(!inboundNode["TotalWaitTime"].isNull())
+			itemsObject.inbound.totalWaitTime = std::stol(inboundNode["TotalWaitTime"].asString());
+		if(!inboundNode["TotalRingTime"].isNull())
+			itemsObject.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
+		if(!inboundNode["MaxTalkTime"].isNull())
+			itemsObject.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].asString());
+		if(!inboundNode["MaxRingTime"].isNull())
+			itemsObject.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+		if(!inboundNode["AbandonRate"].isNull())
+			itemsObject.inbound.abandonRate = std::stof(inboundNode["AbandonRate"].asString());
+		if(!inboundNode["TotalTalkTime"].isNull())
+			itemsObject.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
+		if(!inboundNode["TotalAbandonTime"].isNull())
+			itemsObject.inbound.totalAbandonTime = std::stol(inboundNode["TotalAbandonTime"].asString());
+		if(!inboundNode["CallsOffered"].isNull())
+			itemsObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
+		if(!inboundNode["MaxAbandonedInRingTime"].isNull())
+			itemsObject.inbound.maxAbandonedInRingTime = std::stol(inboundNode["MaxAbandonedInRingTime"].asString());
+		if(!inboundNode["MaxWaitTime"].isNull())
+			itemsObject.inbound.maxWaitTime = std::stol(inboundNode["MaxWaitTime"].asString());
+		if(!inboundNode["AverageAbandonedInQueueTime"].isNull())
+			itemsObject.inbound.averageAbandonedInQueueTime = std::stof(inboundNode["AverageAbandonedInQueueTime"].asString());
+		if(!inboundNode["ServiceLevel20"].isNull())
+			itemsObject.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
+		if(!inboundNode["MaxHoldTime"].isNull())
+			itemsObject.inbound.maxHoldTime = std::stol(inboundNode["MaxHoldTime"].asString());
+		if(!inboundNode["SatisfactionRate"].isNull())
+			itemsObject.inbound.satisfactionRate = std::stof(inboundNode["SatisfactionRate"].asString());
+		if(!inboundNode["AverageTalkTime"].isNull())
+			itemsObject.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].asString());
+		if(!inboundNode["CallsHold"].isNull())
+			itemsObject.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
+		if(!inboundNode["SatisfactionSurveysOffered"].isNull())
+			itemsObject.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
+		if(!inboundNode["HandleRate"].isNull())
+			itemsObject.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
+		if(!inboundNode["CallsTimeout"].isNull())
+			itemsObject.inbound.callsTimeout = std::stol(inboundNode["CallsTimeout"].asString());
+		if(!inboundNode["SatisfactionSurveysResponded"].isNull())
+			itemsObject.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].asString());
+		if(!inboundNode["AverageHoldTime"].isNull())
+			itemsObject.inbound.averageHoldTime = std::stof(inboundNode["AverageHoldTime"].asString());
+		if(!inboundNode["TotalAbandonedInQueueTime"].isNull())
+			itemsObject.inbound.totalAbandonedInQueueTime = std::stol(inboundNode["TotalAbandonedInQueueTime"].asString());
+		if(!inboundNode["CallsAbandonedInQueue"].isNull())
+			itemsObject.inbound.callsAbandonedInQueue = std::stol(inboundNode["CallsAbandonedInQueue"].asString());
 		auto outboundNode = value["Outbound"];
-		if(!outboundNode["AnswerRate"].isNull())
-			itemsObject.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
-		if(!outboundNode["AverageDialingTime"].isNull())
-			itemsObject.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
-		if(!outboundNode["AverageHoldTime"].isNull())
-			itemsObject.outbound.averageHoldTime = std::stof(outboundNode["AverageHoldTime"].asString());
 		if(!outboundNode["AverageRingTime"].isNull())
 			itemsObject.outbound.averageRingTime = std::stof(outboundNode["AverageRingTime"].asString());
-		if(!outboundNode["AverageTalkTime"].isNull())
-			itemsObject.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
-		if(!outboundNode["AverageWorkTime"].isNull())
-			itemsObject.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
-		if(!outboundNode["CallsAnswered"].isNull())
-			itemsObject.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
-		if(!outboundNode["CallsAttendedTransferIn"].isNull())
-			itemsObject.outbound.callsAttendedTransferIn = std::stol(outboundNode["CallsAttendedTransferIn"].asString());
-		if(!outboundNode["CallsAttendedTransferOut"].isNull())
-			itemsObject.outbound.callsAttendedTransferOut = std::stol(outboundNode["CallsAttendedTransferOut"].asString());
-		if(!outboundNode["CallsBlindTransferIn"].isNull())
-			itemsObject.outbound.callsBlindTransferIn = std::stol(outboundNode["CallsBlindTransferIn"].asString());
-		if(!outboundNode["CallsBlindTransferOut"].isNull())
-			itemsObject.outbound.callsBlindTransferOut = std::stol(outboundNode["CallsBlindTransferOut"].asString());
 		if(!outboundNode["CallsDialed"].isNull())
 			itemsObject.outbound.callsDialed = std::stol(outboundNode["CallsDialed"].asString());
-		if(!outboundNode["CallsHold"].isNull())
-			itemsObject.outbound.callsHold = std::stol(outboundNode["CallsHold"].asString());
-		if(!outboundNode["CallsRinged"].isNull())
-			itemsObject.outbound.callsRinged = std::stol(outboundNode["CallsRinged"].asString());
-		if(!outboundNode["MaxDialingTime"].isNull())
-			itemsObject.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].asString());
-		if(!outboundNode["MaxHoldTime"].isNull())
-			itemsObject.outbound.maxHoldTime = std::stol(outboundNode["MaxHoldTime"].asString());
-		if(!outboundNode["MaxRingTime"].isNull())
-			itemsObject.outbound.maxRingTime = std::stol(outboundNode["MaxRingTime"].asString());
-		if(!outboundNode["MaxTalkTime"].isNull())
-			itemsObject.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
+		if(!outboundNode["CallsAnswered"].isNull())
+			itemsObject.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
+		if(!outboundNode["TotalWorkTime"].isNull())
+			itemsObject.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+		if(!outboundNode["CallsAttendedTransferOut"].isNull())
+			itemsObject.outbound.callsAttendedTransferOut = std::stol(outboundNode["CallsAttendedTransferOut"].asString());
 		if(!outboundNode["MaxWorkTime"].isNull())
 			itemsObject.outbound.maxWorkTime = std::stol(outboundNode["MaxWorkTime"].asString());
-		if(!outboundNode["SatisfactionIndex"].isNull())
-			itemsObject.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
-		if(!outboundNode["SatisfactionRate"].isNull())
-			itemsObject.outbound.satisfactionRate = std::stof(outboundNode["SatisfactionRate"].asString());
-		if(!outboundNode["SatisfactionSurveysOffered"].isNull())
-			itemsObject.outbound.satisfactionSurveysOffered = std::stol(outboundNode["SatisfactionSurveysOffered"].asString());
-		if(!outboundNode["SatisfactionSurveysResponded"].isNull())
-			itemsObject.outbound.satisfactionSurveysResponded = std::stol(outboundNode["SatisfactionSurveysResponded"].asString());
 		if(!outboundNode["TotalDialingTime"].isNull())
 			itemsObject.outbound.totalDialingTime = std::stol(outboundNode["TotalDialingTime"].asString());
 		if(!outboundNode["TotalHoldTime"].isNull())
 			itemsObject.outbound.totalHoldTime = std::stol(outboundNode["TotalHoldTime"].asString());
+		if(!outboundNode["AverageWorkTime"].isNull())
+			itemsObject.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
+		if(!outboundNode["CallsBlindTransferIn"].isNull())
+			itemsObject.outbound.callsBlindTransferIn = std::stol(outboundNode["CallsBlindTransferIn"].asString());
+		if(!outboundNode["SatisfactionIndex"].isNull())
+			itemsObject.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
+		if(!outboundNode["CallsRinged"].isNull())
+			itemsObject.outbound.callsRinged = std::stol(outboundNode["CallsRinged"].asString());
+		if(!outboundNode["CallsAttendedTransferIn"].isNull())
+			itemsObject.outbound.callsAttendedTransferIn = std::stol(outboundNode["CallsAttendedTransferIn"].asString());
+		if(!outboundNode["CallsBlindTransferOut"].isNull())
+			itemsObject.outbound.callsBlindTransferOut = std::stol(outboundNode["CallsBlindTransferOut"].asString());
 		if(!outboundNode["TotalRingTime"].isNull())
 			itemsObject.outbound.totalRingTime = std::stol(outboundNode["TotalRingTime"].asString());
+		if(!outboundNode["MaxTalkTime"].isNull())
+			itemsObject.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
+		if(!outboundNode["MaxRingTime"].isNull())
+			itemsObject.outbound.maxRingTime = std::stol(outboundNode["MaxRingTime"].asString());
 		if(!outboundNode["TotalTalkTime"].isNull())
 			itemsObject.outbound.totalTalkTime = std::stol(outboundNode["TotalTalkTime"].asString());
-		if(!outboundNode["TotalWorkTime"].isNull())
-			itemsObject.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+		if(!outboundNode["MaxDialingTime"].isNull())
+			itemsObject.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].asString());
+		if(!outboundNode["AnswerRate"].isNull())
+			itemsObject.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
+		if(!outboundNode["MaxHoldTime"].isNull())
+			itemsObject.outbound.maxHoldTime = std::stol(outboundNode["MaxHoldTime"].asString());
+		if(!outboundNode["AverageTalkTime"].isNull())
+			itemsObject.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
+		if(!outboundNode["SatisfactionRate"].isNull())
+			itemsObject.outbound.satisfactionRate = std::stof(outboundNode["SatisfactionRate"].asString());
+		if(!outboundNode["CallsHold"].isNull())
+			itemsObject.outbound.callsHold = std::stol(outboundNode["CallsHold"].asString());
+		if(!outboundNode["SatisfactionSurveysOffered"].isNull())
+			itemsObject.outbound.satisfactionSurveysOffered = std::stol(outboundNode["SatisfactionSurveysOffered"].asString());
+		if(!outboundNode["SatisfactionSurveysResponded"].isNull())
+			itemsObject.outbound.satisfactionSurveysResponded = std::stol(outboundNode["SatisfactionSurveysResponded"].asString());
+		if(!outboundNode["AverageHoldTime"].isNull())
+			itemsObject.outbound.averageHoldTime = std::stof(outboundNode["AverageHoldTime"].asString());
+		if(!outboundNode["AverageDialingTime"].isNull())
+			itemsObject.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
 		auto overallNode = value["Overall"];
-		if(!overallNode["AverageBreakTime"].isNull())
-			itemsObject.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
-		if(!overallNode["AverageHoldTime"].isNull())
-			itemsObject.overall.averageHoldTime = std::stof(overallNode["AverageHoldTime"].asString());
-		if(!overallNode["AverageReadyTime"].isNull())
-			itemsObject.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
-		if(!overallNode["AverageTalkTime"].isNull())
-			itemsObject.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
-		if(!overallNode["AverageWorkTime"].isNull())
-			itemsObject.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
-		if(!overallNode["MaxBreakTime"].isNull())
-			itemsObject.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
-		if(!overallNode["MaxHoldTime"].isNull())
-			itemsObject.overall.maxHoldTime = std::stol(overallNode["MaxHoldTime"].asString());
-		if(!overallNode["MaxReadyTime"].isNull())
-			itemsObject.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
-		if(!overallNode["MaxTalkTime"].isNull())
-			itemsObject.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
-		if(!overallNode["MaxWorkTime"].isNull())
-			itemsObject.overall.maxWorkTime = std::stol(overallNode["MaxWorkTime"].asString());
+		if(!overallNode["TotalTalkTime"].isNull())
+			itemsObject.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
+		if(!overallNode["TotalLoggedInTime"].isNull())
+			itemsObject.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
 		if(!overallNode["OccupancyRate"].isNull())
 			itemsObject.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
-		if(!overallNode["SatisfactionIndex"].isNull())
-			itemsObject.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
+		if(!overallNode["TotalWorkTime"].isNull())
+			itemsObject.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
+		if(!overallNode["MaxHoldTime"].isNull())
+			itemsObject.overall.maxHoldTime = std::stol(overallNode["MaxHoldTime"].asString());
+		if(!overallNode["MaxWorkTime"].isNull())
+			itemsObject.overall.maxWorkTime = std::stol(overallNode["MaxWorkTime"].asString());
+		if(!overallNode["AverageBreakTime"].isNull())
+			itemsObject.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
+		if(!overallNode["TotalHoldTime"].isNull())
+			itemsObject.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
 		if(!overallNode["SatisfactionRate"].isNull())
 			itemsObject.overall.satisfactionRate = std::stof(overallNode["SatisfactionRate"].asString());
+		if(!overallNode["MaxBreakTime"].isNull())
+			itemsObject.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
+		if(!overallNode["AverageWorkTime"].isNull())
+			itemsObject.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
+		if(!overallNode["AverageTalkTime"].isNull())
+			itemsObject.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
+		if(!overallNode["SatisfactionIndex"].isNull())
+			itemsObject.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
 		if(!overallNode["SatisfactionSurveysOffered"].isNull())
 			itemsObject.overall.satisfactionSurveysOffered = std::stol(overallNode["SatisfactionSurveysOffered"].asString());
 		if(!overallNode["SatisfactionSurveysResponded"].isNull())
 			itemsObject.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].asString());
-		if(!overallNode["TotalBreakTime"].isNull())
-			itemsObject.overall.totalBreakTime = std::stol(overallNode["TotalBreakTime"].asString());
-		if(!overallNode["TotalCalls"].isNull())
-			itemsObject.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString());
-		if(!overallNode["TotalHoldTime"].isNull())
-			itemsObject.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
-		if(!overallNode["TotalLoggedInTime"].isNull())
-			itemsObject.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
+		if(!overallNode["MaxReadyTime"].isNull())
+			itemsObject.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
+		if(!overallNode["AverageReadyTime"].isNull())
+			itemsObject.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
+		if(!overallNode["AverageHoldTime"].isNull())
+			itemsObject.overall.averageHoldTime = std::stof(overallNode["AverageHoldTime"].asString());
 		if(!overallNode["TotalReadyTime"].isNull())
 			itemsObject.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
-		if(!overallNode["TotalTalkTime"].isNull())
-			itemsObject.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
-		if(!overallNode["TotalWorkTime"].isNull())
-			itemsObject.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
+		if(!overallNode["TotalBreakTime"].isNull())
+			itemsObject.overall.totalBreakTime = std::stol(overallNode["TotalBreakTime"].asString());
+		if(!overallNode["MaxTalkTime"].isNull())
+			itemsObject.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
+		if(!overallNode["TotalCalls"].isNull())
+			itemsObject.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString());
 		data_.list.push_back(itemsObject);
 	}
 	if(!value["Code"].isNull())

ccc/src/model/ListInstancesOfUserResult.cc

@@ -50,44 +50,44 @@ void ListInstancesOfUserResult::parse(const std::string &payload)
 	for (auto dataNodeListCallCenterInstance : allListNode)
 	{
 		Data::CallCenterInstance callCenterInstanceObject;
-		if(!dataNodeListCallCenterInstance["AliyunUid"].isNull())
-			callCenterInstanceObject.aliyunUid = dataNodeListCallCenterInstance["AliyunUid"].asString();
+		if(!dataNodeListCallCenterInstance["Status"].isNull())
+			callCenterInstanceObject.status = dataNodeListCallCenterInstance["Status"].asString();
 		if(!dataNodeListCallCenterInstance["ConsoleUrl"].isNull())
 			callCenterInstanceObject.consoleUrl = dataNodeListCallCenterInstance["ConsoleUrl"].asString();
 		if(!dataNodeListCallCenterInstance["Description"].isNull())
 			callCenterInstanceObject.description = dataNodeListCallCenterInstance["Description"].asString();
+		if(!dataNodeListCallCenterInstance["AliyunUid"].isNull())
+			callCenterInstanceObject.aliyunUid = dataNodeListCallCenterInstance["AliyunUid"].asString();
+		if(!dataNodeListCallCenterInstance["Name"].isNull())
+			callCenterInstanceObject.name = dataNodeListCallCenterInstance["Name"].asString();
 		if(!dataNodeListCallCenterInstance["DomainName"].isNull())
 			callCenterInstanceObject.domainName = dataNodeListCallCenterInstance["DomainName"].asString();
 		if(!dataNodeListCallCenterInstance["Id"].isNull())
 			callCenterInstanceObject.id = dataNodeListCallCenterInstance["Id"].asString();
-		if(!dataNodeListCallCenterInstance["Name"].isNull())
-			callCenterInstanceObject.name = dataNodeListCallCenterInstance["Name"].asString();
-		if(!dataNodeListCallCenterInstance["Status"].isNull())
-			callCenterInstanceObject.status = dataNodeListCallCenterInstance["Status"].asString();
 		auto allAdminListNode = dataNodeListCallCenterInstance["AdminList"]["User"];
 		for (auto dataNodeListCallCenterInstanceAdminListUser : allAdminListNode)
 		{
 			Data::CallCenterInstance::User adminListObject;
 			if(!dataNodeListCallCenterInstanceAdminListUser["DisplayName"].isNull())
 				adminListObject.displayName = dataNodeListCallCenterInstanceAdminListUser["DisplayName"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["Email"].isNull())
-				adminListObject.email = dataNodeListCallCenterInstanceAdminListUser["Email"].asString();
 			if(!dataNodeListCallCenterInstanceAdminListUser["Extension"].isNull())
 				adminListObject.extension = dataNodeListCallCenterInstanceAdminListUser["Extension"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["InstanceId"].isNull())
-				adminListObject.instanceId = dataNodeListCallCenterInstanceAdminListUser["InstanceId"].asString();
 			if(!dataNodeListCallCenterInstanceAdminListUser["LoginName"].isNull())
 				adminListObject.loginName = dataNodeListCallCenterInstanceAdminListUser["LoginName"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["Mobile"].isNull())
-				adminListObject.mobile = dataNodeListCallCenterInstanceAdminListUser["Mobile"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["RoleId"].isNull())
-				adminListObject.roleId = dataNodeListCallCenterInstanceAdminListUser["RoleId"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["RoleName"].isNull())
-				adminListObject.roleName = dataNodeListCallCenterInstanceAdminListUser["RoleName"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["UserId"].isNull())
-				adminListObject.userId = dataNodeListCallCenterInstanceAdminListUser["UserId"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["Email"].isNull())
+				adminListObject.email = dataNodeListCallCenterInstanceAdminListUser["Email"].asString();
 			if(!dataNodeListCallCenterInstanceAdminListUser["WorkMode"].isNull())
 				adminListObject.workMode = dataNodeListCallCenterInstanceAdminListUser["WorkMode"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["Mobile"].isNull())
+				adminListObject.mobile = dataNodeListCallCenterInstanceAdminListUser["Mobile"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["UserId"].isNull())
+				adminListObject.userId = dataNodeListCallCenterInstanceAdminListUser["UserId"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["RoleName"].isNull())
+				adminListObject.roleName = dataNodeListCallCenterInstanceAdminListUser["RoleName"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["InstanceId"].isNull())
+				adminListObject.instanceId = dataNodeListCallCenterInstanceAdminListUser["InstanceId"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["RoleId"].isNull())
+				adminListObject.roleId = dataNodeListCallCenterInstanceAdminListUser["RoleId"].asString();
 			callCenterInstanceObject.adminList.push_back(adminListObject);
 		}
 		auto allNumberListNode = dataNodeListCallCenterInstance["NumberList"]["PhoneNumber"];
@@ -96,38 +96,38 @@ void ListInstancesOfUserResult::parse(const std::string &payload)
 			Data::CallCenterInstance::PhoneNumber numberListObject;
 			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["Active"].isNull())
 				numberListObject.active = dataNodeListCallCenterInstanceNumberListPhoneNumber["Active"].asString() == "true";
-			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["City"].isNull())
-				numberListObject.city = dataNodeListCallCenterInstanceNumberListPhoneNumber["City"].asString();
-			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["ContactFlowId"].isNull())
-				numberListObject.contactFlowId = dataNodeListCallCenterInstanceNumberListPhoneNumber["ContactFlowId"].asString();
-			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["InstanceId"].isNull())
-				numberListObject.instanceId = dataNodeListCallCenterInstanceNumberListPhoneNumber["InstanceId"].asString();
-			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["Number"].isNull())
-				numberListObject.number = dataNodeListCallCenterInstanceNumberListPhoneNumber["Number"].asString();
-			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["Province"].isNull())
-				numberListObject.province = dataNodeListCallCenterInstanceNumberListPhoneNumber["Province"].asString();
-			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["Usage"].isNull())
-				numberListObject.usage = dataNodeListCallCenterInstanceNumberListPhoneNumber["Usage"].asString();
 			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["UserId"].isNull())
 				numberListObject.userId = dataNodeListCallCenterInstanceNumberListPhoneNumber["UserId"].asString();
+			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["Number"].isNull())
+				numberListObject.number = dataNodeListCallCenterInstanceNumberListPhoneNumber["Number"].asString();
+			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["City"].isNull())
+				numberListObject.city = dataNodeListCallCenterInstanceNumberListPhoneNumber["City"].asString();
+			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["InstanceId"].isNull())
+				numberListObject.instanceId = dataNodeListCallCenterInstanceNumberListPhoneNumber["InstanceId"].asString();
+			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["Usage"].isNull())
+				numberListObject.usage = dataNodeListCallCenterInstanceNumberListPhoneNumber["Usage"].asString();
+			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["ContactFlowId"].isNull())
+				numberListObject.contactFlowId = dataNodeListCallCenterInstanceNumberListPhoneNumber["ContactFlowId"].asString();
+			if(!dataNodeListCallCenterInstanceNumberListPhoneNumber["Province"].isNull())
+				numberListObject.province = dataNodeListCallCenterInstanceNumberListPhoneNumber["Province"].asString();
 			auto allSkillGroupsNode = dataNodeListCallCenterInstanceNumberListPhoneNumber["SkillGroups"]["SkillGroup"];
 			for (auto dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup : allSkillGroupsNode)
 			{
 				Data::CallCenterInstance::PhoneNumber::SkillGroup skillGroupsObject;
-				if(!dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["Description"].isNull())
-					skillGroupsObject.description = dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["Description"].asString();
 				if(!dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["DisplayName"].isNull())
 					skillGroupsObject.displayName = dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["DisplayName"].asString();
-				if(!dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["InstanceId"].isNull())
-					skillGroupsObject.instanceId = dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["InstanceId"].asString();
-				if(!dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["Name"].isNull())
-					skillGroupsObject.name = dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["Name"].asString();
+				if(!dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["Description"].isNull())
+					skillGroupsObject.description = dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["Description"].asString();
 				if(!dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["PhoneNumberCount"].isNull())
 					skillGroupsObject.phoneNumberCount = std::stoi(dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["PhoneNumberCount"].asString());
 				if(!dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["SkillGroupId"].isNull())
 					skillGroupsObject.skillGroupId = dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["SkillGroupId"].asString();
 				if(!dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["UserCount"].isNull())
 					skillGroupsObject.userCount = std::stoi(dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["UserCount"].asString());
+				if(!dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["InstanceId"].isNull())
+					skillGroupsObject.instanceId = dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["InstanceId"].asString();
+				if(!dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["Name"].isNull())
+					skillGroupsObject.name = dataNodeListCallCenterInstanceNumberListPhoneNumberSkillGroupsSkillGroup["Name"].asString();
 				numberListObject.skillGroups.push_back(skillGroupsObject);
 			}
 			callCenterInstanceObject.numberList.push_back(numberListObject);

ccc/src/model/ListInstancesResult.cc

@@ -50,46 +50,46 @@ void ListInstancesResult::parse(const std::string &payload)
 	for (auto dataNodeListCallCenterInstance : allListNode)
 	{
 		Data::CallCenterInstance callCenterInstanceObject;
-		if(!dataNodeListCallCenterInstance["AliyunUid"].isNull())
-			callCenterInstanceObject.aliyunUid = dataNodeListCallCenterInstance["AliyunUid"].asString();
+		if(!dataNodeListCallCenterInstance["Status"].isNull())
+			callCenterInstanceObject.status = dataNodeListCallCenterInstance["Status"].asString();
 		if(!dataNodeListCallCenterInstance["ConsoleUrl"].isNull())
 			callCenterInstanceObject.consoleUrl = dataNodeListCallCenterInstance["ConsoleUrl"].asString();
-		if(!dataNodeListCallCenterInstance["CreateTime"].isNull())
-			callCenterInstanceObject.createTime = std::stol(dataNodeListCallCenterInstance["CreateTime"].asString());
 		if(!dataNodeListCallCenterInstance["Description"].isNull())
 			callCenterInstanceObject.description = dataNodeListCallCenterInstance["Description"].asString();
+		if(!dataNodeListCallCenterInstance["CreateTime"].isNull())
+			callCenterInstanceObject.createTime = std::stol(dataNodeListCallCenterInstance["CreateTime"].asString());
+		if(!dataNodeListCallCenterInstance["AliyunUid"].isNull())
+			callCenterInstanceObject.aliyunUid = dataNodeListCallCenterInstance["AliyunUid"].asString();
+		if(!dataNodeListCallCenterInstance["Name"].isNull())
+			callCenterInstanceObject.name = dataNodeListCallCenterInstance["Name"].asString();
 		if(!dataNodeListCallCenterInstance["DomainName"].isNull())
 			callCenterInstanceObject.domainName = dataNodeListCallCenterInstance["DomainName"].asString();
 		if(!dataNodeListCallCenterInstance["Id"].isNull())
 			callCenterInstanceObject.id = dataNodeListCallCenterInstance["Id"].asString();
-		if(!dataNodeListCallCenterInstance["Name"].isNull())
-			callCenterInstanceObject.name = dataNodeListCallCenterInstance["Name"].asString();
-		if(!dataNodeListCallCenterInstance["Status"].isNull())
-			callCenterInstanceObject.status = dataNodeListCallCenterInstance["Status"].asString();
 		auto allAdminListNode = dataNodeListCallCenterInstance["AdminList"]["User"];
 		for (auto dataNodeListCallCenterInstanceAdminListUser : allAdminListNode)
 		{
 			Data::CallCenterInstance::User adminListObject;
 			if(!dataNodeListCallCenterInstanceAdminListUser["DisplayName"].isNull())
 				adminListObject.displayName = dataNodeListCallCenterInstanceAdminListUser["DisplayName"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["Email"].isNull())
-				adminListObject.email = dataNodeListCallCenterInstanceAdminListUser["Email"].asString();
 			if(!dataNodeListCallCenterInstanceAdminListUser["Extension"].isNull())
 				adminListObject.extension = dataNodeListCallCenterInstanceAdminListUser["Extension"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["InstanceId"].isNull())
-				adminListObject.instanceId = dataNodeListCallCenterInstanceAdminListUser["InstanceId"].asString();
 			if(!dataNodeListCallCenterInstanceAdminListUser["LoginName"].isNull())
 				adminListObject.loginName = dataNodeListCallCenterInstanceAdminListUser["LoginName"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["Mobile"].isNull())
-				adminListObject.mobile = dataNodeListCallCenterInstanceAdminListUser["Mobile"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["RoleId"].isNull())
-				adminListObject.roleId = dataNodeListCallCenterInstanceAdminListUser["RoleId"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["RoleName"].isNull())
-				adminListObject.roleName = dataNodeListCallCenterInstanceAdminListUser["RoleName"].asString();
-			if(!dataNodeListCallCenterInstanceAdminListUser["UserId"].isNull())
-				adminListObject.userId = dataNodeListCallCenterInstanceAdminListUser["UserId"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["Email"].isNull())
+				adminListObject.email = dataNodeListCallCenterInstanceAdminListUser["Email"].asString();
 			if(!dataNodeListCallCenterInstanceAdminListUser["WorkMode"].isNull())
 				adminListObject.workMode = dataNodeListCallCenterInstanceAdminListUser["WorkMode"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["Mobile"].isNull())
+				adminListObject.mobile = dataNodeListCallCenterInstanceAdminListUser["Mobile"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["UserId"].isNull())
+				adminListObject.userId = dataNodeListCallCenterInstanceAdminListUser["UserId"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["RoleName"].isNull())
+				adminListObject.roleName = dataNodeListCallCenterInstanceAdminListUser["RoleName"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["InstanceId"].isNull())
+				adminListObject.instanceId = dataNodeListCallCenterInstanceAdminListUser["InstanceId"].asString();
+			if(!dataNodeListCallCenterInstanceAdminListUser["RoleId"].isNull())
+				adminListObject.roleId = dataNodeListCallCenterInstanceAdminListUser["RoleId"].asString();
 			callCenterInstanceObject.adminList.push_back(adminListObject);
 		}
 		auto allNumberListNode = dataNodeListCallCenterInstance["NumberList"]["PhoneNumber"];

ccc/src/model/ListIntervalAgentReportResult.cc

@@ -46,162 +46,162 @@ void ListIntervalAgentReportResult::parse(const std::string &payload)
 		if(!valueDataDataItem["StatsTime"].isNull())
 			dataObject.statsTime = std::stol(valueDataDataItem["StatsTime"].asString());
 		auto inboundNode = value["Inbound"];
-		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["AverageTalkTime"].isNull())
-			dataObject.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].asString());
-		if(!inboundNode["AverageWorkTime"].isNull())
-			dataObject.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
-		if(!inboundNode["CallsAttendedTransferIn"].isNull())
-			dataObject.inbound.callsAttendedTransferIn = std::stol(inboundNode["CallsAttendedTransferIn"].asString());
-		if(!inboundNode["CallsAttendedTransferOut"].isNull())
-			dataObject.inbound.callsAttendedTransferOut = std::stol(inboundNode["CallsAttendedTransferOut"].asString());
-		if(!inboundNode["CallsBlindTransferIn"].isNull())
-			dataObject.inbound.callsBlindTransferIn = std::stol(inboundNode["CallsBlindTransferIn"].asString());
-		if(!inboundNode["CallsBlindTransferOut"].isNull())
-			dataObject.inbound.callsBlindTransferOut = std::stol(inboundNode["CallsBlindTransferOut"].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["CallsRinged"].isNull())
-			dataObject.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
-		if(!inboundNode["HandleRate"].isNull())
-			dataObject.inbound.handleRate = std::stof(inboundNode["HandleRate"].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["MaxTalkTime"].isNull())
-			dataObject.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].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["SatisfactionRate"].isNull())
-			dataObject.inbound.satisfactionRate = std::stof(inboundNode["SatisfactionRate"].asString());
-		if(!inboundNode["SatisfactionSurveysOffered"].isNull())
-			dataObject.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
-		if(!inboundNode["SatisfactionSurveysResponded"].isNull())
-			dataObject.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].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["TotalWorkTime"].isNull())
 			dataObject.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
+		if(!inboundNode["CallsAttendedTransferOut"].isNull())
+			dataObject.inbound.callsAttendedTransferOut = std::stol(inboundNode["CallsAttendedTransferOut"].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["AverageWorkTime"].isNull())
+			dataObject.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
+		if(!inboundNode["CallsBlindTransferIn"].isNull())
+			dataObject.inbound.callsBlindTransferIn = std::stol(inboundNode["CallsBlindTransferIn"].asString());
+		if(!inboundNode["SatisfactionIndex"].isNull())
+			dataObject.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+		if(!inboundNode["CallsRinged"].isNull())
+			dataObject.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
+		if(!inboundNode["CallsAttendedTransferIn"].isNull())
+			dataObject.inbound.callsAttendedTransferIn = std::stol(inboundNode["CallsAttendedTransferIn"].asString());
+		if(!inboundNode["CallsBlindTransferOut"].isNull())
+			dataObject.inbound.callsBlindTransferOut = std::stol(inboundNode["CallsBlindTransferOut"].asString());
+		if(!inboundNode["TotalRingTime"].isNull())
+			dataObject.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
+		if(!inboundNode["MaxTalkTime"].isNull())
+			dataObject.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].asString());
+		if(!inboundNode["MaxRingTime"].isNull())
+			dataObject.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+		if(!inboundNode["TotalTalkTime"].isNull())
+			dataObject.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
+		if(!inboundNode["CallsOffered"].isNull())
+			dataObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
+		if(!inboundNode["MaxHoldTime"].isNull())
+			dataObject.inbound.maxHoldTime = std::stol(inboundNode["MaxHoldTime"].asString());
+		if(!inboundNode["AverageTalkTime"].isNull())
+			dataObject.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].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["AverageHoldTime"].isNull())
+			dataObject.inbound.averageHoldTime = std::stof(inboundNode["AverageHoldTime"].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["CallsAttendedTransferIn"].isNull())
-			dataObject.outbound.callsAttendedTransferIn = std::stol(outboundNode["CallsAttendedTransferIn"].asString());
-		if(!outboundNode["CallsAttendedTransferOut"].isNull())
-			dataObject.outbound.callsAttendedTransferOut = std::stol(outboundNode["CallsAttendedTransferOut"].asString());
-		if(!outboundNode["CallsBlindTransferIn"].isNull())
-			dataObject.outbound.callsBlindTransferIn = std::stol(outboundNode["CallsBlindTransferIn"].asString());
-		if(!outboundNode["CallsBlindTransferOut"].isNull())
-			dataObject.outbound.callsBlindTransferOut = std::stol(outboundNode["CallsBlindTransferOut"].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["CallsRinged"].isNull())
-			dataObject.outbound.callsRinged = std::stol(outboundNode["CallsRinged"].asString());
-		if(!outboundNode["MaxDialingTime"].isNull())
-			dataObject.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].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["CallsAnswered"].isNull())
+			dataObject.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
+		if(!outboundNode["TotalWorkTime"].isNull())
+			dataObject.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+		if(!outboundNode["CallsAttendedTransferOut"].isNull())
+			dataObject.outbound.callsAttendedTransferOut = std::stol(outboundNode["CallsAttendedTransferOut"].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["SatisfactionRate"].isNull())
-			dataObject.outbound.satisfactionRate = std::stof(outboundNode["SatisfactionRate"].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["AverageWorkTime"].isNull())
+			dataObject.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
+		if(!outboundNode["CallsBlindTransferIn"].isNull())
+			dataObject.outbound.callsBlindTransferIn = std::stol(outboundNode["CallsBlindTransferIn"].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["CallsAttendedTransferIn"].isNull())
+			dataObject.outbound.callsAttendedTransferIn = std::stol(outboundNode["CallsAttendedTransferIn"].asString());
+		if(!outboundNode["CallsBlindTransferOut"].isNull())
+			dataObject.outbound.callsBlindTransferOut = std::stol(outboundNode["CallsBlindTransferOut"].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["TotalWorkTime"].isNull())
-			dataObject.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+		if(!outboundNode["MaxDialingTime"].isNull())
+			dataObject.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].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["AverageTalkTime"].isNull())
+			dataObject.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
+		if(!outboundNode["SatisfactionRate"].isNull())
+			dataObject.outbound.satisfactionRate = std::stof(outboundNode["SatisfactionRate"].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["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["OccupancyRate"].isNull())
+			dataObject.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
+		if(!overallNode["TotalWorkTime"].isNull())
+			dataObject.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
+		if(!overallNode["MaxWorkTime"].isNull())
+			dataObject.overall.maxWorkTime = std::stol(overallNode["MaxWorkTime"].asString());
+		if(!overallNode["TotalHoldTime"].isNull())
+			dataObject.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
 		if(!overallNode["AverageWorkTime"].isNull())
 			dataObject.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
-		if(!overallNode["FirstCheckInTime"].isNull())
-			dataObject.overall.firstCheckInTime = std::stol(overallNode["FirstCheckInTime"].asString());
-		if(!overallNode["LastCheckoutTime"].isNull())
-			dataObject.overall.lastCheckoutTime = std::stol(overallNode["LastCheckoutTime"].asString());
 		if(!overallNode["MaxBreakTime"].isNull())
 			dataObject.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
-		if(!overallNode["MaxHoldTime"].isNull())
-			dataObject.overall.maxHoldTime = std::stol(overallNode["MaxHoldTime"].asString());
+		if(!overallNode["SatisfactionIndex"].isNull())
+			dataObject.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].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["TotalReadyTime"].isNull())
+			dataObject.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
+		if(!overallNode["LastCheckoutTime"].isNull())
+			dataObject.overall.lastCheckoutTime = std::stol(overallNode["LastCheckoutTime"].asString());
+		if(!overallNode["TotalCalls"].isNull())
+			dataObject.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString());
+		if(!overallNode["TotalLoggedInTime"].isNull())
+			dataObject.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
+		if(!overallNode["TotalTalkTime"].isNull())
+			dataObject.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
+		if(!overallNode["MaxHoldTime"].isNull())
+			dataObject.overall.maxHoldTime = std::stol(overallNode["MaxHoldTime"].asString());
+		if(!overallNode["AverageBreakTime"].isNull())
+			dataObject.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
+		if(!overallNode["AverageTalkTime"].isNull())
+			dataObject.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
 		if(!overallNode["SatisfactionRate"].isNull())
 			dataObject.overall.satisfactionRate = std::stof(overallNode["SatisfactionRate"].asString());
 		if(!overallNode["SatisfactionSurveysOffered"].isNull())
 			dataObject.overall.satisfactionSurveysOffered = std::stol(overallNode["SatisfactionSurveysOffered"].asString());
+		if(!overallNode["FirstCheckInTime"].isNull())
+			dataObject.overall.firstCheckInTime = std::stol(overallNode["FirstCheckInTime"].asString());
 		if(!overallNode["SatisfactionSurveysResponded"].isNull())
 			dataObject.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].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["TotalBreakTime"].isNull())
 			dataObject.overall.totalBreakTime = std::stol(overallNode["TotalBreakTime"].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())