Refine API response for GetCallDetailRecord.

CHANGELOG

@@ -1,3 +1,9 @@
+2021-06-08 Version: 1.36.772
+- Refine API response for GetCallDetailRecord.
+
+2021-06-08 Version: 1.36.771
+- Support input parameter LaunchConfigurationHostNames and MinTargetCapacity for CreateAutoProvisioningGroup.
+
 2021-06-08 Version: 1.36.770
 - Increase detection frequency for availability monitoring.
 - Add application group to query in batch according to group ID.

VERSION

@@ -1 +1 @@
-1.36.770
+1.36.772

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

@@ -34,19 +34,19 @@ namespace AlibabaCloud
 			public:
 				struct Data
 				{
-					struct CdrAgentEventsItem
+					struct AgentEventsItem
 					{
 						struct EventSequenceItem
 						{
 							long eventTime;
 							std::string event;
 						};
-						std::vector<CdrAgentEventsItem::EventSequenceItem> eventSequence;
+						std::vector<AgentEventsItem::EventSequenceItem> eventSequence;
 						std::string agentId;
 						std::string agentName;
 						std::string skillGroupId;
 					};
-					struct CdrIvrEventsItem
+					struct IvrEventsItem
 					{
 						struct EventSequenceItem2
 						{
@@ -54,9 +54,9 @@ namespace AlibabaCloud
 							std::string event;
 						};
 						std::string flowId;
-						std::vector<CdrIvrEventsItem::EventSequenceItem2> eventSequence1;
+						std::vector<IvrEventsItem::EventSequenceItem2> eventSequence1;
 					};
-					struct CdrQueueEventsItem
+					struct QueueEventsItem
 					{
 						struct EventSequenceItem4
 						{
@@ -64,33 +64,33 @@ namespace AlibabaCloud
 							std::string event;
 						};
 						std::string flowId;
-						std::vector<CdrQueueEventsItem::EventSequenceItem4> eventSequence3;
+						std::vector<QueueEventsItem::EventSequenceItem4> eventSequence3;
 						std::string queueId;
 						std::string queueName;
 						int queueType;
 					};
+					std::vector<AgentEventsItem> agentEvents;
 					std::string skillGroupIds;
 					std::string calledNumber;
 					std::string contactType;
 					std::string contactDisposition;
 					std::string instanceId;
 					std::string releaseInitiator;
-					std::vector<CdrIvrEventsItem> cdrIvrEvents;
 					int satisfaction;
 					long startTime;
 					std::string contactId;
 					long callDuration;
 					std::string callingNumber;
+					std::vector<QueueEventsItem> queueEvents;
 					long releaseTime;
 					bool recordingReady;
 					std::string skillGroupNames;
-					std::vector<CdrQueueEventsItem> cdrQueueEvents;
 					std::string satisfactionSurveyChannel;
 					std::string agentIds;
 					bool satisfactionSurveyOffered;
-					std::vector<CdrAgentEventsItem> cdrAgentEvents;
 					long establishedTime;
 					std::string agentNames;
+					std::vector<IvrEventsItem> ivrEvents;
 				};
 
 

ccc/src/model/GetCallDetailRecordResult.cc

@@ -78,69 +78,69 @@ void GetCallDetailRecordResult::parse(const std::string &payload)
 		data_.releaseInitiator = dataNode["ReleaseInitiator"].asString();
 	if(!dataNode["RecordingReady"].isNull())
 		data_.recordingReady = dataNode["RecordingReady"].asString() == "true";
-	auto allCdrAgentEventsNode = dataNode["CdrAgentEvents"]["CdrAgentEventsItem"];
-	for (auto dataNodeCdrAgentEventsCdrAgentEventsItem : allCdrAgentEventsNode)
+	auto allAgentEventsNode = dataNode["AgentEvents"]["AgentEventsItem"];
+	for (auto dataNodeAgentEventsAgentEventsItem : allAgentEventsNode)
 	{
-		Data::CdrAgentEventsItem cdrAgentEventsItemObject;
-		if(!dataNodeCdrAgentEventsCdrAgentEventsItem["AgentId"].isNull())
-			cdrAgentEventsItemObject.agentId = dataNodeCdrAgentEventsCdrAgentEventsItem["AgentId"].asString();
-		if(!dataNodeCdrAgentEventsCdrAgentEventsItem["AgentName"].isNull())
-			cdrAgentEventsItemObject.agentName = dataNodeCdrAgentEventsCdrAgentEventsItem["AgentName"].asString();
-		if(!dataNodeCdrAgentEventsCdrAgentEventsItem["SkillGroupId"].isNull())
-			cdrAgentEventsItemObject.skillGroupId = dataNodeCdrAgentEventsCdrAgentEventsItem["SkillGroupId"].asString();
-		auto allEventSequenceNode = dataNodeCdrAgentEventsCdrAgentEventsItem["EventSequence"]["EventSequenceItem"];
-		for (auto dataNodeCdrAgentEventsCdrAgentEventsItemEventSequenceEventSequenceItem : allEventSequenceNode)
+		Data::AgentEventsItem agentEventsItemObject;
+		if(!dataNodeAgentEventsAgentEventsItem["AgentId"].isNull())
+			agentEventsItemObject.agentId = dataNodeAgentEventsAgentEventsItem["AgentId"].asString();
+		if(!dataNodeAgentEventsAgentEventsItem["AgentName"].isNull())
+			agentEventsItemObject.agentName = dataNodeAgentEventsAgentEventsItem["AgentName"].asString();
+		if(!dataNodeAgentEventsAgentEventsItem["SkillGroupId"].isNull())
+			agentEventsItemObject.skillGroupId = dataNodeAgentEventsAgentEventsItem["SkillGroupId"].asString();
+		auto allEventSequenceNode = dataNodeAgentEventsAgentEventsItem["EventSequence"]["EventSequenceItem"];
+		for (auto dataNodeAgentEventsAgentEventsItemEventSequenceEventSequenceItem : allEventSequenceNode)
 		{
-			Data::CdrAgentEventsItem::EventSequenceItem eventSequenceObject;
-			if(!dataNodeCdrAgentEventsCdrAgentEventsItemEventSequenceEventSequenceItem["Event"].isNull())
-				eventSequenceObject.event = dataNodeCdrAgentEventsCdrAgentEventsItemEventSequenceEventSequenceItem["Event"].asString();
-			if(!dataNodeCdrAgentEventsCdrAgentEventsItemEventSequenceEventSequenceItem["EventTime"].isNull())
-				eventSequenceObject.eventTime = std::stol(dataNodeCdrAgentEventsCdrAgentEventsItemEventSequenceEventSequenceItem["EventTime"].asString());
-			cdrAgentEventsItemObject.eventSequence.push_back(eventSequenceObject);
+			Data::AgentEventsItem::EventSequenceItem eventSequenceObject;
+			if(!dataNodeAgentEventsAgentEventsItemEventSequenceEventSequenceItem["Event"].isNull())
+				eventSequenceObject.event = dataNodeAgentEventsAgentEventsItemEventSequenceEventSequenceItem["Event"].asString();
+			if(!dataNodeAgentEventsAgentEventsItemEventSequenceEventSequenceItem["EventTime"].isNull())
+				eventSequenceObject.eventTime = std::stol(dataNodeAgentEventsAgentEventsItemEventSequenceEventSequenceItem["EventTime"].asString());
+			agentEventsItemObject.eventSequence.push_back(eventSequenceObject);
 		}
-		data_.cdrAgentEvents.push_back(cdrAgentEventsItemObject);
+		data_.agentEvents.push_back(agentEventsItemObject);
 	}
-	auto allCdrIvrEventsNode = dataNode["CdrIvrEvents"]["CdrIvrEventsItem"];
-	for (auto dataNodeCdrIvrEventsCdrIvrEventsItem : allCdrIvrEventsNode)
+	auto allIvrEventsNode = dataNode["IvrEvents"]["IvrEventsItem"];
+	for (auto dataNodeIvrEventsIvrEventsItem : allIvrEventsNode)
 	{
-		Data::CdrIvrEventsItem cdrIvrEventsItemObject;
-		if(!dataNodeCdrIvrEventsCdrIvrEventsItem["FlowId"].isNull())
-			cdrIvrEventsItemObject.flowId = dataNodeCdrIvrEventsCdrIvrEventsItem["FlowId"].asString();
-		auto allEventSequence1Node = dataNodeCdrIvrEventsCdrIvrEventsItem["EventSequence"]["EventSequenceItem"];
-		for (auto dataNodeCdrIvrEventsCdrIvrEventsItemEventSequenceEventSequenceItem : allEventSequence1Node)
+		Data::IvrEventsItem ivrEventsItemObject;
+		if(!dataNodeIvrEventsIvrEventsItem["FlowId"].isNull())
+			ivrEventsItemObject.flowId = dataNodeIvrEventsIvrEventsItem["FlowId"].asString();
+		auto allEventSequence1Node = dataNodeIvrEventsIvrEventsItem["EventSequence"]["EventSequenceItem"];
+		for (auto dataNodeIvrEventsIvrEventsItemEventSequenceEventSequenceItem : allEventSequence1Node)
 		{
-			Data::CdrIvrEventsItem::EventSequenceItem2 eventSequence1Object;
-			if(!dataNodeCdrIvrEventsCdrIvrEventsItemEventSequenceEventSequenceItem["Event"].isNull())
-				eventSequence1Object.event = dataNodeCdrIvrEventsCdrIvrEventsItemEventSequenceEventSequenceItem["Event"].asString();
-			if(!dataNodeCdrIvrEventsCdrIvrEventsItemEventSequenceEventSequenceItem["EventTime"].isNull())
-				eventSequence1Object.eventTime = std::stol(dataNodeCdrIvrEventsCdrIvrEventsItemEventSequenceEventSequenceItem["EventTime"].asString());
-			cdrIvrEventsItemObject.eventSequence1.push_back(eventSequence1Object);
+			Data::IvrEventsItem::EventSequenceItem2 eventSequence1Object;
+			if(!dataNodeIvrEventsIvrEventsItemEventSequenceEventSequenceItem["Event"].isNull())
+				eventSequence1Object.event = dataNodeIvrEventsIvrEventsItemEventSequenceEventSequenceItem["Event"].asString();
+			if(!dataNodeIvrEventsIvrEventsItemEventSequenceEventSequenceItem["EventTime"].isNull())
+				eventSequence1Object.eventTime = std::stol(dataNodeIvrEventsIvrEventsItemEventSequenceEventSequenceItem["EventTime"].asString());
+			ivrEventsItemObject.eventSequence1.push_back(eventSequence1Object);
 		}
-		data_.cdrIvrEvents.push_back(cdrIvrEventsItemObject);
+		data_.ivrEvents.push_back(ivrEventsItemObject);
 	}
-	auto allCdrQueueEventsNode = dataNode["CdrQueueEvents"]["CdrQueueEventsItem"];
-	for (auto dataNodeCdrQueueEventsCdrQueueEventsItem : allCdrQueueEventsNode)
+	auto allQueueEventsNode = dataNode["QueueEvents"]["QueueEventsItem"];
+	for (auto dataNodeQueueEventsQueueEventsItem : allQueueEventsNode)
 	{
-		Data::CdrQueueEventsItem cdrQueueEventsItemObject;
-		if(!dataNodeCdrQueueEventsCdrQueueEventsItem["FlowId"].isNull())
-			cdrQueueEventsItemObject.flowId = dataNodeCdrQueueEventsCdrQueueEventsItem["FlowId"].asString();
-		if(!dataNodeCdrQueueEventsCdrQueueEventsItem["QueueId"].isNull())
-			cdrQueueEventsItemObject.queueId = dataNodeCdrQueueEventsCdrQueueEventsItem["QueueId"].asString();
-		if(!dataNodeCdrQueueEventsCdrQueueEventsItem["QueueName"].isNull())
-			cdrQueueEventsItemObject.queueName = dataNodeCdrQueueEventsCdrQueueEventsItem["QueueName"].asString();
-		if(!dataNodeCdrQueueEventsCdrQueueEventsItem["QueueType"].isNull())
-			cdrQueueEventsItemObject.queueType = std::stoi(dataNodeCdrQueueEventsCdrQueueEventsItem["QueueType"].asString());
-		auto allEventSequence3Node = dataNodeCdrQueueEventsCdrQueueEventsItem["EventSequence"]["EventSequenceItem"];
-		for (auto dataNodeCdrQueueEventsCdrQueueEventsItemEventSequenceEventSequenceItem : allEventSequence3Node)
+		Data::QueueEventsItem queueEventsItemObject;
+		if(!dataNodeQueueEventsQueueEventsItem["FlowId"].isNull())
+			queueEventsItemObject.flowId = dataNodeQueueEventsQueueEventsItem["FlowId"].asString();
+		if(!dataNodeQueueEventsQueueEventsItem["QueueId"].isNull())
+			queueEventsItemObject.queueId = dataNodeQueueEventsQueueEventsItem["QueueId"].asString();
+		if(!dataNodeQueueEventsQueueEventsItem["QueueName"].isNull())
+			queueEventsItemObject.queueName = dataNodeQueueEventsQueueEventsItem["QueueName"].asString();
+		if(!dataNodeQueueEventsQueueEventsItem["QueueType"].isNull())
+			queueEventsItemObject.queueType = std::stoi(dataNodeQueueEventsQueueEventsItem["QueueType"].asString());
+		auto allEventSequence3Node = dataNodeQueueEventsQueueEventsItem["EventSequence"]["EventSequenceItem"];
+		for (auto dataNodeQueueEventsQueueEventsItemEventSequenceEventSequenceItem : allEventSequence3Node)
 		{
-			Data::CdrQueueEventsItem::EventSequenceItem4 eventSequence3Object;
-			if(!dataNodeCdrQueueEventsCdrQueueEventsItemEventSequenceEventSequenceItem["Event"].isNull())
-				eventSequence3Object.event = dataNodeCdrQueueEventsCdrQueueEventsItemEventSequenceEventSequenceItem["Event"].asString();
-			if(!dataNodeCdrQueueEventsCdrQueueEventsItemEventSequenceEventSequenceItem["EventTime"].isNull())
-				eventSequence3Object.eventTime = std::stol(dataNodeCdrQueueEventsCdrQueueEventsItemEventSequenceEventSequenceItem["EventTime"].asString());
-			cdrQueueEventsItemObject.eventSequence3.push_back(eventSequence3Object);
+			Data::QueueEventsItem::EventSequenceItem4 eventSequence3Object;
+			if(!dataNodeQueueEventsQueueEventsItemEventSequenceEventSequenceItem["Event"].isNull())
+				eventSequence3Object.event = dataNodeQueueEventsQueueEventsItemEventSequenceEventSequenceItem["Event"].asString();
+			if(!dataNodeQueueEventsQueueEventsItemEventSequenceEventSequenceItem["EventTime"].isNull())
+				eventSequence3Object.eventTime = std::stol(dataNodeQueueEventsQueueEventsItemEventSequenceEventSequenceItem["EventTime"].asString());
+			queueEventsItemObject.eventSequence3.push_back(eventSequence3Object);
 		}
-		data_.cdrQueueEvents.push_back(cdrQueueEventsItemObject);
+		data_.queueEvents.push_back(queueEventsItemObject);
 	}
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();

ecs/include/alibabacloud/ecs/model/CreateAutoProvisioningGroupRequest.h

@@ -33,16 +33,16 @@ namespace AlibabaCloud
 			public:
 				struct LaunchConfigurationDataDisk
 				{
-					int size;
-					std::string category;
 					std::string performanceLevel;
-					std::string device;
+					std::string kmsKeyId;
+					std::string description;
 					std::string snapshotId;
+					int size;
+					std::string device;
+					std::string diskName;
+					std::string category;
 					bool deleteWithInstance;
 					bool encrypted;
-					std::string kmsKeyId;
-					std::string diskName;
-					std::string description;
 				};
 				struct SystemDiskConfig
 				{
@@ -54,11 +54,11 @@ namespace AlibabaCloud
 				};
 				struct LaunchTemplateConfig
 				{
-					std::string instanceType;
-					double maxPrice;
 					std::string vSwitchId;
-					double weightedCapacity;
+					double maxPrice;
 					int priority;
+					std::string instanceType;
+					double weightedCapacity;
 				};
 				struct LaunchConfigurationTag
 				{
@@ -80,6 +80,8 @@ namespace AlibabaCloud
 				void setAutoProvisioningGroupType(const std::string& autoProvisioningGroupType);
 				std::string getLaunchConfigurationSystemDiskPerformanceLevel()const;
 				void setLaunchConfigurationSystemDiskPerformanceLevel(const std::string& launchConfigurationSystemDiskPerformanceLevel);
+				std::vector<std::string> getLaunchConfigurationHostNames()const;
+				void setLaunchConfigurationHostNames(const std::vector<std::string>& launchConfigurationHostNames);
 				std::string getResourceGroupId()const;
 				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getLaunchConfigurationImageId()const;
@@ -110,6 +112,8 @@ namespace AlibabaCloud
 				void setLaunchConfigurationInternetMaxBandwidthOut(int launchConfigurationInternetMaxBandwidthOut);
 				std::string getLaunchConfigurationHostName()const;
 				void setLaunchConfigurationHostName(const std::string& launchConfigurationHostName);
+				std::string getMinTargetCapacity()const;
+				void setMinTargetCapacity(const std::string& minTargetCapacity);
 				float getMaxSpotPrice()const;
 				void setMaxSpotPrice(float maxSpotPrice);
 				bool getLaunchConfigurationPasswordInherit()const;
@@ -185,6 +189,7 @@ namespace AlibabaCloud
 				std::string launchConfigurationSystemDiskCategory_;
 				std::string autoProvisioningGroupType_;
 				std::string launchConfigurationSystemDiskPerformanceLevel_;
+				std::vector<std::string> launchConfigurationHostNames_;
 				std::string resourceGroupId_;
 				std::string launchConfigurationImageId_;
 				std::string launchConfigurationResourceGroupId_;
@@ -200,6 +205,7 @@ namespace AlibabaCloud
 				int launchConfigurationSystemDiskSize_;
 				int launchConfigurationInternetMaxBandwidthOut_;
 				std::string launchConfigurationHostName_;
+				std::string minTargetCapacity_;
 				float maxSpotPrice_;
 				bool launchConfigurationPasswordInherit_;
 				std::string clientToken_;

ecs/src/model/CreateAutoProvisioningGroupRequest.cc

@@ -38,16 +38,16 @@ void CreateAutoProvisioningGroupRequest::setLaunchConfigurationDataDisk(const st
 	for(int dep1 = 0; dep1!= launchConfigurationDataDisk.size(); dep1++) {
 		auto launchConfigurationDataDiskObj = launchConfigurationDataDisk.at(dep1);
 		std::string launchConfigurationDataDiskObjStr = "LaunchConfiguration.DataDisk." + std::to_string(dep1 + 1);
-		setParameter(launchConfigurationDataDiskObjStr + ".Size", std::to_string(launchConfigurationDataDiskObj.size));
-		setParameter(launchConfigurationDataDiskObjStr + ".Category", launchConfigurationDataDiskObj.category);
 		setParameter(launchConfigurationDataDiskObjStr + ".PerformanceLevel", launchConfigurationDataDiskObj.performanceLevel);
-		setParameter(launchConfigurationDataDiskObjStr + ".Device", launchConfigurationDataDiskObj.device);
+		setParameter(launchConfigurationDataDiskObjStr + ".KmsKeyId", launchConfigurationDataDiskObj.kmsKeyId);
+		setParameter(launchConfigurationDataDiskObjStr + ".Description", launchConfigurationDataDiskObj.description);
 		setParameter(launchConfigurationDataDiskObjStr + ".SnapshotId", launchConfigurationDataDiskObj.snapshotId);
+		setParameter(launchConfigurationDataDiskObjStr + ".Size", std::to_string(launchConfigurationDataDiskObj.size));
+		setParameter(launchConfigurationDataDiskObjStr + ".Device", launchConfigurationDataDiskObj.device);
+		setParameter(launchConfigurationDataDiskObjStr + ".DiskName", launchConfigurationDataDiskObj.diskName);
+		setParameter(launchConfigurationDataDiskObjStr + ".Category", launchConfigurationDataDiskObj.category);
 		setParameter(launchConfigurationDataDiskObjStr + ".DeleteWithInstance", launchConfigurationDataDiskObj.deleteWithInstance ? "true" : "false");
 		setParameter(launchConfigurationDataDiskObjStr + ".Encrypted", launchConfigurationDataDiskObj.encrypted ? "true" : "false");
-		setParameter(launchConfigurationDataDiskObjStr + ".KmsKeyId", launchConfigurationDataDiskObj.kmsKeyId);
-		setParameter(launchConfigurationDataDiskObjStr + ".DiskName", launchConfigurationDataDiskObj.diskName);
-		setParameter(launchConfigurationDataDiskObjStr + ".Description", launchConfigurationDataDiskObj.description);
 	}
 }
 
@@ -95,6 +95,19 @@ void CreateAutoProvisioningGroupRequest::setLaunchConfigurationSystemDiskPerform
 	setParameter("LaunchConfigurationSystemDiskPerformanceLevel", launchConfigurationSystemDiskPerformanceLevel);
 }
 
+std::vector<std::string> CreateAutoProvisioningGroupRequest::getLaunchConfigurationHostNames()const
+{
+	return launchConfigurationHostNames_;
+}
+
+void CreateAutoProvisioningGroupRequest::setLaunchConfigurationHostNames(const std::vector<std::string>& launchConfigurationHostNames)
+{
+	launchConfigurationHostNames_ = launchConfigurationHostNames;
+	for(int dep1 = 0; dep1!= launchConfigurationHostNames.size(); dep1++) {
+		setParameter("LaunchConfigurationHostNames."+ std::to_string(dep1), launchConfigurationHostNames.at(dep1));
+	}
+}
+
 std::string CreateAutoProvisioningGroupRequest::getResourceGroupId()const
 {
 	return resourceGroupId_;
@@ -268,6 +281,17 @@ void CreateAutoProvisioningGroupRequest::setLaunchConfigurationHostName(const st
 	setParameter("LaunchConfigurationHostName", launchConfigurationHostName);
 }
 
+std::string CreateAutoProvisioningGroupRequest::getMinTargetCapacity()const
+{
+	return minTargetCapacity_;
+}
+
+void CreateAutoProvisioningGroupRequest::setMinTargetCapacity(const std::string& minTargetCapacity)
+{
+	minTargetCapacity_ = minTargetCapacity;
+	setParameter("MinTargetCapacity", minTargetCapacity);
+}
+
 float CreateAutoProvisioningGroupRequest::getMaxSpotPrice()const
 {
 	return maxSpotPrice_;
@@ -455,11 +479,11 @@ void CreateAutoProvisioningGroupRequest::setLaunchTemplateConfig(const std::vect
 	for(int dep1 = 0; dep1!= launchTemplateConfig.size(); dep1++) {
 		auto launchTemplateConfigObj = launchTemplateConfig.at(dep1);
 		std::string launchTemplateConfigObjStr = "LaunchTemplateConfig." + std::to_string(dep1 + 1);
-		setParameter(launchTemplateConfigObjStr + ".InstanceType", launchTemplateConfigObj.instanceType);
-		setParameter(launchTemplateConfigObjStr + ".MaxPrice", std::to_string(launchTemplateConfigObj.maxPrice));
 		setParameter(launchTemplateConfigObjStr + ".VSwitchId", launchTemplateConfigObj.vSwitchId);
-		setParameter(launchTemplateConfigObjStr + ".WeightedCapacity", std::to_string(launchTemplateConfigObj.weightedCapacity));
+		setParameter(launchTemplateConfigObjStr + ".MaxPrice", std::to_string(launchTemplateConfigObj.maxPrice));
 		setParameter(launchTemplateConfigObjStr + ".Priority", std::to_string(launchTemplateConfigObj.priority));
+		setParameter(launchTemplateConfigObjStr + ".InstanceType", launchTemplateConfigObj.instanceType);
+		setParameter(launchTemplateConfigObjStr + ".WeightedCapacity", std::to_string(launchTemplateConfigObj.weightedCapacity));
 	}
 }
 

ecs/src/model/CreateAutoProvisioningGroupResult.cc

@@ -43,16 +43,16 @@ void CreateAutoProvisioningGroupResult::parse(const std::string &payload)
 	for (auto valueLaunchResultsLaunchResult : allLaunchResultsNode)
 	{
 		LaunchResult launchResultsObject;
-		if(!valueLaunchResultsLaunchResult["SpotStrategy"].isNull())
-			launchResultsObject.spotStrategy = valueLaunchResultsLaunchResult["SpotStrategy"].asString();
-		if(!valueLaunchResultsLaunchResult["InstanceType"].isNull())
-			launchResultsObject.instanceType = valueLaunchResultsLaunchResult["InstanceType"].asString();
 		if(!valueLaunchResultsLaunchResult["ZoneId"].isNull())
 			launchResultsObject.zoneId = valueLaunchResultsLaunchResult["ZoneId"].asString();
-		if(!valueLaunchResultsLaunchResult["ErrorCode"].isNull())
-			launchResultsObject.errorCode = valueLaunchResultsLaunchResult["ErrorCode"].asString();
 		if(!valueLaunchResultsLaunchResult["ErrorMsg"].isNull())
 			launchResultsObject.errorMsg = valueLaunchResultsLaunchResult["ErrorMsg"].asString();
+		if(!valueLaunchResultsLaunchResult["InstanceType"].isNull())
+			launchResultsObject.instanceType = valueLaunchResultsLaunchResult["InstanceType"].asString();
+		if(!valueLaunchResultsLaunchResult["ErrorCode"].isNull())
+			launchResultsObject.errorCode = valueLaunchResultsLaunchResult["ErrorCode"].asString();
+		if(!valueLaunchResultsLaunchResult["SpotStrategy"].isNull())
+			launchResultsObject.spotStrategy = valueLaunchResultsLaunchResult["SpotStrategy"].asString();
 		auto allInstanceIds = value["InstanceIds"]["InstanceId"];
 		for (auto value : allInstanceIds)
 			launchResultsObject.instanceIds.push_back(value.asString());