From ea23aa89b7e26bb732bea26df025ab99eb538622 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Tue, 1 Dec 2020 08:15:17 +0000 Subject: [PATCH] Fixed bugs for CCC. --- CHANGELOG | 3 + ccc/CMakeLists.txt | 28 ++ ccc/include/alibabacloud/ccc/CCCClient.h | 56 ++++ .../ccc/model/AddPhoneTagsRequest.h | 3 + .../ccc/model/DisableTrunkProvidersRequest.h | 51 ++++ .../ccc/model/DisableTrunkProvidersResult.h | 57 ++++ .../ccc/model/GetUserByExtensionRequest.h | 51 ++++ .../ccc/model/GetUserByExtensionResult.h | 97 +++++++ .../ccc/model/ListAgentStateLogsRequest.h | 66 +++++ .../ccc/model/ListAgentStateLogsResult.h | 78 ++++++ .../ListAgentSummaryReportsByIntervalResult.h | 2 + .../ccc/model/ListAgentSummaryReportsResult.h | 2 + .../ListTransferableSkillGroupsRequest.h | 51 ++++ .../model/ListTransferableSkillGroupsResult.h | 71 +++++ .../ccc/model/ListTrunkProvidersRequest.h | 48 ++++ .../ccc/model/ListTrunkProvidersResult.h | 64 +++++ .../ccc/model/ListTrunksOfSkillGroupRequest.h | 54 ++++ .../ccc/model/ListTrunksOfSkillGroupResult.h | 64 +++++ .../ModifyPrimaryTrunksOfSkillGroupRequest.h | 57 ++++ .../ModifyPrimaryTrunksOfSkillGroupResult.h | 57 ++++ .../ccc/model/RequestLoginInfoRequest.h | 3 + .../ccc/model/ResetUserStatusRequest.h | 3 + ccc/src/CCCClient.cc | 252 ++++++++++++++++++ ccc/src/model/AddBulkPhoneNumbersResult.cc | 12 +- ccc/src/model/AddPhoneTagsRequest.cc | 11 + .../model/CreateScenarioFromTemplateResult.cc | 12 +- ccc/src/model/CreateScenarioResult.cc | 12 +- ccc/src/model/DisableTrunkProvidersRequest.cc | 53 ++++ ccc/src/model/DisableTrunkProvidersResult.cc | 72 +++++ ccc/src/model/FindUsersResult.cc | 32 +-- ccc/src/model/GetConversationListResult.cc | 16 +- ccc/src/model/GetJobListResult.cc | 84 +++--- ccc/src/model/GetJobResult.cc | 32 +-- ccc/src/model/GetJobStatusByCallIdResult.cc | 44 +-- ccc/src/model/GetScenarioResult.cc | 12 +- ccc/src/model/GetTaskListResult.cc | 32 +-- ccc/src/model/GetUserByExtensionRequest.cc | 51 ++++ ccc/src/model/GetUserByExtensionResult.cc | 130 +++++++++ ccc/src/model/ListAgentEventsResult.cc | 12 +- ccc/src/model/ListAgentStateLogsRequest.cc | 106 ++++++++ ccc/src/model/ListAgentStateLogsResult.cc | 108 ++++++++ ...ListAgentSummaryReportsByIntervalResult.cc | 36 +-- .../model/ListAgentSummaryReportsResult.cc | 4 + ...ListBasicStatisticsReportSubItemsResult.cc | 12 +- ccc/src/model/ListCallDetailRecordsResult.cc | 56 ++-- ccc/src/model/ListContactFlowsResult.cc | 72 ++--- ccc/src/model/ListInstancesOfUserResult.cc | 56 ++-- ccc/src/model/ListJobStatusResult.cc | 136 +++++----- ccc/src/model/ListJobsByGroupResult.cc | 84 +++--- ccc/src/model/ListPhoneNumbersResult.cc | 12 +- ccc/src/model/ListRealTimeAgentResult.cc | 12 +- ccc/src/model/ListRecentCallRecordsResult.cc | 108 ++++---- ccc/src/model/ListScenarioTemplatesResult.cc | 56 ++-- ccc/src/model/ListScenariosResult.cc | 52 ++-- ...killGroupSummaryReportsByIntervalResult.cc | 20 +- ccc/src/model/ListSkillGroupsResult.cc | 40 +-- .../ListTransferableSkillGroupsRequest.cc | 51 ++++ .../ListTransferableSkillGroupsResult.cc | 101 +++++++ ccc/src/model/ListTrunkProvidersRequest.cc | 40 +++ ccc/src/model/ListTrunkProvidersResult.cc | 87 ++++++ .../model/ListTrunksOfSkillGroupRequest.cc | 62 +++++ ccc/src/model/ListTrunksOfSkillGroupResult.cc | 87 ++++++ .../model/ListUnreachableContactsResult.cc | 28 +- ccc/src/model/ListUsersOfSkillGroupResult.cc | 52 ++-- ccc/src/model/ListUsersResult.cc | 32 +-- .../ModifyPrimaryTrunksOfSkillGroupRequest.cc | 75 ++++++ .../ModifyPrimaryTrunksOfSkillGroupResult.cc | 72 +++++ ccc/src/model/ModifyScenarioResult.cc | 12 +- ccc/src/model/RequestLoginInfoRequest.cc | 11 + ccc/src/model/ResetUserStatusRequest.cc | 13 + 70 files changed, 2942 insertions(+), 586 deletions(-) create mode 100644 ccc/include/alibabacloud/ccc/model/DisableTrunkProvidersRequest.h create mode 100644 ccc/include/alibabacloud/ccc/model/DisableTrunkProvidersResult.h create mode 100644 ccc/include/alibabacloud/ccc/model/GetUserByExtensionRequest.h create mode 100644 ccc/include/alibabacloud/ccc/model/GetUserByExtensionResult.h create mode 100644 ccc/include/alibabacloud/ccc/model/ListAgentStateLogsRequest.h create mode 100644 ccc/include/alibabacloud/ccc/model/ListAgentStateLogsResult.h create mode 100644 ccc/include/alibabacloud/ccc/model/ListTransferableSkillGroupsRequest.h create mode 100644 ccc/include/alibabacloud/ccc/model/ListTransferableSkillGroupsResult.h create mode 100644 ccc/include/alibabacloud/ccc/model/ListTrunkProvidersRequest.h create mode 100644 ccc/include/alibabacloud/ccc/model/ListTrunkProvidersResult.h create mode 100644 ccc/include/alibabacloud/ccc/model/ListTrunksOfSkillGroupRequest.h create mode 100644 ccc/include/alibabacloud/ccc/model/ListTrunksOfSkillGroupResult.h create mode 100644 ccc/include/alibabacloud/ccc/model/ModifyPrimaryTrunksOfSkillGroupRequest.h create mode 100644 ccc/include/alibabacloud/ccc/model/ModifyPrimaryTrunksOfSkillGroupResult.h create mode 100644 ccc/src/model/DisableTrunkProvidersRequest.cc create mode 100644 ccc/src/model/DisableTrunkProvidersResult.cc create mode 100644 ccc/src/model/GetUserByExtensionRequest.cc create mode 100644 ccc/src/model/GetUserByExtensionResult.cc create mode 100644 ccc/src/model/ListAgentStateLogsRequest.cc create mode 100644 ccc/src/model/ListAgentStateLogsResult.cc create mode 100644 ccc/src/model/ListTransferableSkillGroupsRequest.cc create mode 100644 ccc/src/model/ListTransferableSkillGroupsResult.cc create mode 100644 ccc/src/model/ListTrunkProvidersRequest.cc create mode 100644 ccc/src/model/ListTrunkProvidersResult.cc create mode 100644 ccc/src/model/ListTrunksOfSkillGroupRequest.cc create mode 100644 ccc/src/model/ListTrunksOfSkillGroupResult.cc create mode 100644 ccc/src/model/ModifyPrimaryTrunksOfSkillGroupRequest.cc create mode 100644 ccc/src/model/ModifyPrimaryTrunksOfSkillGroupResult.cc diff --git a/CHANGELOG b/CHANGELOG index 53b5ec35a..6d596e315 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2020-12-01 Version: patch +- Fixed bugs for CCC. + 2020-12-01 Version: patch - Supported Open Api. diff --git a/ccc/CMakeLists.txt b/ccc/CMakeLists.txt index 0912beee9..7b66a764a 100644 --- a/ccc/CMakeLists.txt +++ b/ccc/CMakeLists.txt @@ -83,6 +83,8 @@ set(ccc_public_header_model include/alibabacloud/ccc/model/DialExResult.h include/alibabacloud/ccc/model/DialogueRequest.h include/alibabacloud/ccc/model/DialogueResult.h + include/alibabacloud/ccc/model/DisableTrunkProvidersRequest.h + include/alibabacloud/ccc/model/DisableTrunkProvidersResult.h include/alibabacloud/ccc/model/DownloadAllTypeRecordingRequest.h include/alibabacloud/ccc/model/DownloadAllTypeRecordingResult.h include/alibabacloud/ccc/model/DownloadCabRecordingRequest.h @@ -151,6 +153,8 @@ set(ccc_public_header_model include/alibabacloud/ccc/model/GetTaskListResult.h include/alibabacloud/ccc/model/GetUserRequest.h include/alibabacloud/ccc/model/GetUserResult.h + include/alibabacloud/ccc/model/GetUserByExtensionRequest.h + include/alibabacloud/ccc/model/GetUserByExtensionResult.h include/alibabacloud/ccc/model/InflightTaskTimeoutRequest.h include/alibabacloud/ccc/model/InflightTaskTimeoutResult.h include/alibabacloud/ccc/model/LaunchAppraiseRequest.h @@ -161,6 +165,8 @@ set(ccc_public_header_model include/alibabacloud/ccc/model/ListAgentDevicesResult.h include/alibabacloud/ccc/model/ListAgentEventsRequest.h include/alibabacloud/ccc/model/ListAgentEventsResult.h + include/alibabacloud/ccc/model/ListAgentStateLogsRequest.h + include/alibabacloud/ccc/model/ListAgentStateLogsResult.h include/alibabacloud/ccc/model/ListAgentStatesRequest.h include/alibabacloud/ccc/model/ListAgentStatesResult.h include/alibabacloud/ccc/model/ListAgentSummaryReportsRequest.h @@ -229,6 +235,12 @@ set(ccc_public_header_model include/alibabacloud/ccc/model/ListSkillGroupsOfUserResult.h include/alibabacloud/ccc/model/ListSurveysRequest.h include/alibabacloud/ccc/model/ListSurveysResult.h + include/alibabacloud/ccc/model/ListTransferableSkillGroupsRequest.h + include/alibabacloud/ccc/model/ListTransferableSkillGroupsResult.h + include/alibabacloud/ccc/model/ListTrunkProvidersRequest.h + include/alibabacloud/ccc/model/ListTrunkProvidersResult.h + include/alibabacloud/ccc/model/ListTrunksOfSkillGroupRequest.h + include/alibabacloud/ccc/model/ListTrunksOfSkillGroupResult.h include/alibabacloud/ccc/model/ListUnreachableContactsRequest.h include/alibabacloud/ccc/model/ListUnreachableContactsResult.h include/alibabacloud/ccc/model/ListUsersRequest.h @@ -245,6 +257,8 @@ set(ccc_public_header_model include/alibabacloud/ccc/model/ModifyPhoneNumberResult.h include/alibabacloud/ccc/model/ModifyPhoneTagsRequest.h include/alibabacloud/ccc/model/ModifyPhoneTagsResult.h + include/alibabacloud/ccc/model/ModifyPrimaryTrunksOfSkillGroupRequest.h + include/alibabacloud/ccc/model/ModifyPrimaryTrunksOfSkillGroupResult.h include/alibabacloud/ccc/model/ModifyPrivacyNumberCallDetailRequest.h include/alibabacloud/ccc/model/ModifyPrivacyNumberCallDetailResult.h include/alibabacloud/ccc/model/ModifyScenarioRequest.h @@ -366,6 +380,8 @@ set(ccc_src src/model/DialExResult.cc src/model/DialogueRequest.cc src/model/DialogueResult.cc + src/model/DisableTrunkProvidersRequest.cc + src/model/DisableTrunkProvidersResult.cc src/model/DownloadAllTypeRecordingRequest.cc src/model/DownloadAllTypeRecordingResult.cc src/model/DownloadCabRecordingRequest.cc @@ -434,6 +450,8 @@ set(ccc_src src/model/GetTaskListResult.cc src/model/GetUserRequest.cc src/model/GetUserResult.cc + src/model/GetUserByExtensionRequest.cc + src/model/GetUserByExtensionResult.cc src/model/InflightTaskTimeoutRequest.cc src/model/InflightTaskTimeoutResult.cc src/model/LaunchAppraiseRequest.cc @@ -444,6 +462,8 @@ set(ccc_src src/model/ListAgentDevicesResult.cc src/model/ListAgentEventsRequest.cc src/model/ListAgentEventsResult.cc + src/model/ListAgentStateLogsRequest.cc + src/model/ListAgentStateLogsResult.cc src/model/ListAgentStatesRequest.cc src/model/ListAgentStatesResult.cc src/model/ListAgentSummaryReportsRequest.cc @@ -512,6 +532,12 @@ set(ccc_src src/model/ListSkillGroupsOfUserResult.cc src/model/ListSurveysRequest.cc src/model/ListSurveysResult.cc + src/model/ListTransferableSkillGroupsRequest.cc + src/model/ListTransferableSkillGroupsResult.cc + src/model/ListTrunkProvidersRequest.cc + src/model/ListTrunkProvidersResult.cc + src/model/ListTrunksOfSkillGroupRequest.cc + src/model/ListTrunksOfSkillGroupResult.cc src/model/ListUnreachableContactsRequest.cc src/model/ListUnreachableContactsResult.cc src/model/ListUsersRequest.cc @@ -528,6 +554,8 @@ set(ccc_src src/model/ModifyPhoneNumberResult.cc src/model/ModifyPhoneTagsRequest.cc src/model/ModifyPhoneTagsResult.cc + src/model/ModifyPrimaryTrunksOfSkillGroupRequest.cc + src/model/ModifyPrimaryTrunksOfSkillGroupResult.cc src/model/ModifyPrivacyNumberCallDetailRequest.cc src/model/ModifyPrivacyNumberCallDetailResult.cc src/model/ModifyScenarioRequest.cc diff --git a/ccc/include/alibabacloud/ccc/CCCClient.h b/ccc/include/alibabacloud/ccc/CCCClient.h index 9224d66cb..4d82c2598 100644 --- a/ccc/include/alibabacloud/ccc/CCCClient.h +++ b/ccc/include/alibabacloud/ccc/CCCClient.h @@ -84,6 +84,8 @@ #include "model/DialExResult.h" #include "model/DialogueRequest.h" #include "model/DialogueResult.h" +#include "model/DisableTrunkProvidersRequest.h" +#include "model/DisableTrunkProvidersResult.h" #include "model/DownloadAllTypeRecordingRequest.h" #include "model/DownloadAllTypeRecordingResult.h" #include "model/DownloadCabRecordingRequest.h" @@ -152,6 +154,8 @@ #include "model/GetTaskListResult.h" #include "model/GetUserRequest.h" #include "model/GetUserResult.h" +#include "model/GetUserByExtensionRequest.h" +#include "model/GetUserByExtensionResult.h" #include "model/InflightTaskTimeoutRequest.h" #include "model/InflightTaskTimeoutResult.h" #include "model/LaunchAppraiseRequest.h" @@ -162,6 +166,8 @@ #include "model/ListAgentDevicesResult.h" #include "model/ListAgentEventsRequest.h" #include "model/ListAgentEventsResult.h" +#include "model/ListAgentStateLogsRequest.h" +#include "model/ListAgentStateLogsResult.h" #include "model/ListAgentStatesRequest.h" #include "model/ListAgentStatesResult.h" #include "model/ListAgentSummaryReportsRequest.h" @@ -230,6 +236,12 @@ #include "model/ListSkillGroupsOfUserResult.h" #include "model/ListSurveysRequest.h" #include "model/ListSurveysResult.h" +#include "model/ListTransferableSkillGroupsRequest.h" +#include "model/ListTransferableSkillGroupsResult.h" +#include "model/ListTrunkProvidersRequest.h" +#include "model/ListTrunkProvidersResult.h" +#include "model/ListTrunksOfSkillGroupRequest.h" +#include "model/ListTrunksOfSkillGroupResult.h" #include "model/ListUnreachableContactsRequest.h" #include "model/ListUnreachableContactsResult.h" #include "model/ListUsersRequest.h" @@ -246,6 +258,8 @@ #include "model/ModifyPhoneNumberResult.h" #include "model/ModifyPhoneTagsRequest.h" #include "model/ModifyPhoneTagsResult.h" +#include "model/ModifyPrimaryTrunksOfSkillGroupRequest.h" +#include "model/ModifyPrimaryTrunksOfSkillGroupResult.h" #include "model/ModifyPrivacyNumberCallDetailRequest.h" #include "model/ModifyPrivacyNumberCallDetailResult.h" #include "model/ModifyScenarioRequest.h" @@ -404,6 +418,9 @@ namespace AlibabaCloud typedef Outcome DialogueOutcome; typedef std::future DialogueOutcomeCallable; typedef std::function&)> DialogueAsyncHandler; + typedef Outcome DisableTrunkProvidersOutcome; + typedef std::future DisableTrunkProvidersOutcomeCallable; + typedef std::function&)> DisableTrunkProvidersAsyncHandler; typedef Outcome DownloadAllTypeRecordingOutcome; typedef std::future DownloadAllTypeRecordingOutcomeCallable; typedef std::function&)> DownloadAllTypeRecordingAsyncHandler; @@ -506,6 +523,9 @@ namespace AlibabaCloud typedef Outcome GetUserOutcome; typedef std::future GetUserOutcomeCallable; typedef std::function&)> GetUserAsyncHandler; + typedef Outcome GetUserByExtensionOutcome; + typedef std::future GetUserByExtensionOutcomeCallable; + typedef std::function&)> GetUserByExtensionAsyncHandler; typedef Outcome InflightTaskTimeoutOutcome; typedef std::future InflightTaskTimeoutOutcomeCallable; typedef std::function&)> InflightTaskTimeoutAsyncHandler; @@ -521,6 +541,9 @@ namespace AlibabaCloud typedef Outcome ListAgentEventsOutcome; typedef std::future ListAgentEventsOutcomeCallable; typedef std::function&)> ListAgentEventsAsyncHandler; + typedef Outcome ListAgentStateLogsOutcome; + typedef std::future ListAgentStateLogsOutcomeCallable; + typedef std::function&)> ListAgentStateLogsAsyncHandler; typedef Outcome ListAgentStatesOutcome; typedef std::future ListAgentStatesOutcomeCallable; typedef std::function&)> ListAgentStatesAsyncHandler; @@ -623,6 +646,15 @@ namespace AlibabaCloud typedef Outcome ListSurveysOutcome; typedef std::future ListSurveysOutcomeCallable; typedef std::function&)> ListSurveysAsyncHandler; + typedef Outcome ListTransferableSkillGroupsOutcome; + typedef std::future ListTransferableSkillGroupsOutcomeCallable; + typedef std::function&)> ListTransferableSkillGroupsAsyncHandler; + typedef Outcome ListTrunkProvidersOutcome; + typedef std::future ListTrunkProvidersOutcomeCallable; + typedef std::function&)> ListTrunkProvidersAsyncHandler; + typedef Outcome ListTrunksOfSkillGroupOutcome; + typedef std::future ListTrunksOfSkillGroupOutcomeCallable; + typedef std::function&)> ListTrunksOfSkillGroupAsyncHandler; typedef Outcome ListUnreachableContactsOutcome; typedef std::future ListUnreachableContactsOutcomeCallable; typedef std::function&)> ListUnreachableContactsAsyncHandler; @@ -647,6 +679,9 @@ namespace AlibabaCloud typedef Outcome ModifyPhoneTagsOutcome; typedef std::future ModifyPhoneTagsOutcomeCallable; typedef std::function&)> ModifyPhoneTagsAsyncHandler; + typedef Outcome ModifyPrimaryTrunksOfSkillGroupOutcome; + typedef std::future ModifyPrimaryTrunksOfSkillGroupOutcomeCallable; + typedef std::function&)> ModifyPrimaryTrunksOfSkillGroupAsyncHandler; typedef Outcome ModifyPrivacyNumberCallDetailOutcome; typedef std::future ModifyPrivacyNumberCallDetailOutcomeCallable; typedef std::function&)> ModifyPrivacyNumberCallDetailAsyncHandler; @@ -829,6 +864,9 @@ namespace AlibabaCloud DialogueOutcome dialogue(const Model::DialogueRequest &request)const; void dialogueAsync(const Model::DialogueRequest& request, const DialogueAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DialogueOutcomeCallable dialogueCallable(const Model::DialogueRequest& request) const; + DisableTrunkProvidersOutcome disableTrunkProviders(const Model::DisableTrunkProvidersRequest &request)const; + void disableTrunkProvidersAsync(const Model::DisableTrunkProvidersRequest& request, const DisableTrunkProvidersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DisableTrunkProvidersOutcomeCallable disableTrunkProvidersCallable(const Model::DisableTrunkProvidersRequest& request) const; DownloadAllTypeRecordingOutcome downloadAllTypeRecording(const Model::DownloadAllTypeRecordingRequest &request)const; void downloadAllTypeRecordingAsync(const Model::DownloadAllTypeRecordingRequest& request, const DownloadAllTypeRecordingAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DownloadAllTypeRecordingOutcomeCallable downloadAllTypeRecordingCallable(const Model::DownloadAllTypeRecordingRequest& request) const; @@ -931,6 +969,9 @@ namespace AlibabaCloud GetUserOutcome getUser(const Model::GetUserRequest &request)const; void getUserAsync(const Model::GetUserRequest& request, const GetUserAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetUserOutcomeCallable getUserCallable(const Model::GetUserRequest& request) const; + GetUserByExtensionOutcome getUserByExtension(const Model::GetUserByExtensionRequest &request)const; + void getUserByExtensionAsync(const Model::GetUserByExtensionRequest& request, const GetUserByExtensionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetUserByExtensionOutcomeCallable getUserByExtensionCallable(const Model::GetUserByExtensionRequest& request) const; InflightTaskTimeoutOutcome inflightTaskTimeout(const Model::InflightTaskTimeoutRequest &request)const; void inflightTaskTimeoutAsync(const Model::InflightTaskTimeoutRequest& request, const InflightTaskTimeoutAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; InflightTaskTimeoutOutcomeCallable inflightTaskTimeoutCallable(const Model::InflightTaskTimeoutRequest& request) const; @@ -946,6 +987,9 @@ namespace AlibabaCloud ListAgentEventsOutcome listAgentEvents(const Model::ListAgentEventsRequest &request)const; void listAgentEventsAsync(const Model::ListAgentEventsRequest& request, const ListAgentEventsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListAgentEventsOutcomeCallable listAgentEventsCallable(const Model::ListAgentEventsRequest& request) const; + ListAgentStateLogsOutcome listAgentStateLogs(const Model::ListAgentStateLogsRequest &request)const; + void listAgentStateLogsAsync(const Model::ListAgentStateLogsRequest& request, const ListAgentStateLogsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAgentStateLogsOutcomeCallable listAgentStateLogsCallable(const Model::ListAgentStateLogsRequest& request) const; ListAgentStatesOutcome listAgentStates(const Model::ListAgentStatesRequest &request)const; void listAgentStatesAsync(const Model::ListAgentStatesRequest& request, const ListAgentStatesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListAgentStatesOutcomeCallable listAgentStatesCallable(const Model::ListAgentStatesRequest& request) const; @@ -1048,6 +1092,15 @@ namespace AlibabaCloud ListSurveysOutcome listSurveys(const Model::ListSurveysRequest &request)const; void listSurveysAsync(const Model::ListSurveysRequest& request, const ListSurveysAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListSurveysOutcomeCallable listSurveysCallable(const Model::ListSurveysRequest& request) const; + ListTransferableSkillGroupsOutcome listTransferableSkillGroups(const Model::ListTransferableSkillGroupsRequest &request)const; + void listTransferableSkillGroupsAsync(const Model::ListTransferableSkillGroupsRequest& request, const ListTransferableSkillGroupsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListTransferableSkillGroupsOutcomeCallable listTransferableSkillGroupsCallable(const Model::ListTransferableSkillGroupsRequest& request) const; + ListTrunkProvidersOutcome listTrunkProviders(const Model::ListTrunkProvidersRequest &request)const; + void listTrunkProvidersAsync(const Model::ListTrunkProvidersRequest& request, const ListTrunkProvidersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListTrunkProvidersOutcomeCallable listTrunkProvidersCallable(const Model::ListTrunkProvidersRequest& request) const; + ListTrunksOfSkillGroupOutcome listTrunksOfSkillGroup(const Model::ListTrunksOfSkillGroupRequest &request)const; + void listTrunksOfSkillGroupAsync(const Model::ListTrunksOfSkillGroupRequest& request, const ListTrunksOfSkillGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListTrunksOfSkillGroupOutcomeCallable listTrunksOfSkillGroupCallable(const Model::ListTrunksOfSkillGroupRequest& request) const; ListUnreachableContactsOutcome listUnreachableContacts(const Model::ListUnreachableContactsRequest &request)const; void listUnreachableContactsAsync(const Model::ListUnreachableContactsRequest& request, const ListUnreachableContactsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListUnreachableContactsOutcomeCallable listUnreachableContactsCallable(const Model::ListUnreachableContactsRequest& request) const; @@ -1072,6 +1125,9 @@ namespace AlibabaCloud ModifyPhoneTagsOutcome modifyPhoneTags(const Model::ModifyPhoneTagsRequest &request)const; void modifyPhoneTagsAsync(const Model::ModifyPhoneTagsRequest& request, const ModifyPhoneTagsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ModifyPhoneTagsOutcomeCallable modifyPhoneTagsCallable(const Model::ModifyPhoneTagsRequest& request) const; + ModifyPrimaryTrunksOfSkillGroupOutcome modifyPrimaryTrunksOfSkillGroup(const Model::ModifyPrimaryTrunksOfSkillGroupRequest &request)const; + void modifyPrimaryTrunksOfSkillGroupAsync(const Model::ModifyPrimaryTrunksOfSkillGroupRequest& request, const ModifyPrimaryTrunksOfSkillGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyPrimaryTrunksOfSkillGroupOutcomeCallable modifyPrimaryTrunksOfSkillGroupCallable(const Model::ModifyPrimaryTrunksOfSkillGroupRequest& request) const; ModifyPrivacyNumberCallDetailOutcome modifyPrivacyNumberCallDetail(const Model::ModifyPrivacyNumberCallDetailRequest &request)const; void modifyPrivacyNumberCallDetailAsync(const Model::ModifyPrivacyNumberCallDetailRequest& request, const ModifyPrivacyNumberCallDetailAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ModifyPrivacyNumberCallDetailOutcomeCallable modifyPrivacyNumberCallDetailCallable(const Model::ModifyPrivacyNumberCallDetailRequest& request) const; diff --git a/ccc/include/alibabacloud/ccc/model/AddPhoneTagsRequest.h b/ccc/include/alibabacloud/ccc/model/AddPhoneTagsRequest.h index 203853307..88baa88ce 100644 --- a/ccc/include/alibabacloud/ccc/model/AddPhoneTagsRequest.h +++ b/ccc/include/alibabacloud/ccc/model/AddPhoneTagsRequest.h @@ -51,6 +51,8 @@ namespace AlibabaCloud void setPhoneNumberList(const std::vector& phoneNumberList); std::string getServiceTag()const; void setServiceTag(const std::string& serviceTag); + std::string getSipTag()const; + void setSipTag(const std::string& sipTag); std::string getRegionNameCity()const; void setRegionNameCity(const std::string& regionNameCity); @@ -63,6 +65,7 @@ namespace AlibabaCloud std::string provider_; std::vector phoneNumberList_; std::string serviceTag_; + std::string sipTag_; std::string regionNameCity_; }; diff --git a/ccc/include/alibabacloud/ccc/model/DisableTrunkProvidersRequest.h b/ccc/include/alibabacloud/ccc/model/DisableTrunkProvidersRequest.h new file mode 100644 index 000000000..8e596a98a --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/DisableTrunkProvidersRequest.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_CCC_MODEL_DISABLETRUNKPROVIDERSREQUEST_H_ +#define ALIBABACLOUD_CCC_MODEL_DISABLETRUNKPROVIDERSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT DisableTrunkProvidersRequest : public RpcServiceRequest + { + + public: + DisableTrunkProvidersRequest(); + ~DisableTrunkProvidersRequest(); + + std::vector getProviderName()const; + void setProviderName(const std::vector& providerName); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::vector providerName_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_DISABLETRUNKPROVIDERSREQUEST_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/DisableTrunkProvidersResult.h b/ccc/include/alibabacloud/ccc/model/DisableTrunkProvidersResult.h new file mode 100644 index 000000000..934685b02 --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/DisableTrunkProvidersResult.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_DISABLETRUNKPROVIDERSRESULT_H_ +#define ALIBABACLOUD_CCC_MODEL_DISABLETRUNKPROVIDERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT DisableTrunkProvidersResult : public ServiceResult + { + public: + + + DisableTrunkProvidersResult(); + explicit DisableTrunkProvidersResult(const std::string &payload); + ~DisableTrunkProvidersResult(); + std::string getMessage()const; + int getHttpStatusCode()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int httpStatusCode_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_DISABLETRUNKPROVIDERSRESULT_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/GetUserByExtensionRequest.h b/ccc/include/alibabacloud/ccc/model/GetUserByExtensionRequest.h new file mode 100644 index 000000000..9309b0fb8 --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/GetUserByExtensionRequest.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_CCC_MODEL_GETUSERBYEXTENSIONREQUEST_H_ +#define ALIBABACLOUD_CCC_MODEL_GETUSERBYEXTENSIONREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT GetUserByExtensionRequest : public RpcServiceRequest + { + + public: + GetUserByExtensionRequest(); + ~GetUserByExtensionRequest(); + + std::string getExtension()const; + void setExtension(const std::string& extension); + std::string getInstanceId()const; + void setInstanceId(const std::string& instanceId); + + private: + std::string extension_; + std::string instanceId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_GETUSERBYEXTENSIONREQUEST_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/GetUserByExtensionResult.h b/ccc/include/alibabacloud/ccc/model/GetUserByExtensionResult.h new file mode 100644 index 000000000..2d3176944 --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/GetUserByExtensionResult.h @@ -0,0 +1,97 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_GETUSERBYEXTENSIONRESULT_H_ +#define ALIBABACLOUD_CCC_MODEL_GETUSERBYEXTENSIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT GetUserByExtensionResult : public ServiceResult + { + public: + struct User + { + struct Detail + { + std::string extension; + std::string loginName; + std::string department; + std::string email; + std::string phone; + std::string displayName; + }; + struct Role + { + std::string roleName; + std::string instanceId; + std::string roleDescription; + std::string roleId; + }; + struct SkillLevel + { + struct Skill + { + std::string skillGroupName; + std::string instanceId; + std::string skillGroupId; + std::string skillGroupDescription; + }; + Skill skill; + std::string skillLevelId; + int level; + }; + std::vector skillLevels; + std::string instanceId; + std::string userId; + std::string ramId; + std::vector roles; + Detail detail; + }; + + + GetUserByExtensionResult(); + explicit GetUserByExtensionResult(const std::string &payload); + ~GetUserByExtensionResult(); + User getUser()const; + std::string getMessage()const; + int getHttpStatusCode()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + User user_; + std::string message_; + int httpStatusCode_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_GETUSERBYEXTENSIONRESULT_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/ListAgentStateLogsRequest.h b/ccc/include/alibabacloud/ccc/model/ListAgentStateLogsRequest.h new file mode 100644 index 000000000..630e62801 --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/ListAgentStateLogsRequest.h @@ -0,0 +1,66 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSREQUEST_H_ +#define ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT ListAgentStateLogsRequest : public RpcServiceRequest + { + + public: + ListAgentStateLogsRequest(); + ~ListAgentStateLogsRequest(); + + long getEndTime()const; + void setEndTime(long endTime); + long getStartTime()const; + void setStartTime(long startTime); + long getRamId()const; + void setRamId(long ramId); + int getPageNumber()const; + void setPageNumber(int pageNumber); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getInstanceId()const; + void setInstanceId(const std::string& instanceId); + int getPageSize()const; + void setPageSize(int pageSize); + + private: + long endTime_; + long startTime_; + long ramId_; + int pageNumber_; + std::string accessKeyId_; + std::string instanceId_; + int pageSize_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSREQUEST_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/ListAgentStateLogsResult.h b/ccc/include/alibabacloud/ccc/model/ListAgentStateLogsResult.h new file mode 100644 index 000000000..f8c85074b --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/ListAgentStateLogsResult.h @@ -0,0 +1,78 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSRESULT_H_ +#define ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT ListAgentStateLogsResult : public ServiceResult + { + public: + struct AgentStateLogPage + { + struct AgentStateLog + { + std::string skillGroupIds; + std::string counterParty; + long stateTime; + std::string instanceId; + std::string state; + long ramId; + std::string stateCode; + std::string connectId; + std::string contactId; + }; + int totalCount; + int pageSize; + int pageNumber; + std::vector list; + }; + + + ListAgentStateLogsResult(); + explicit ListAgentStateLogsResult(const std::string &payload); + ~ListAgentStateLogsResult(); + std::string getMessage()const; + int getHttpStatusCode()const; + std::string getCode()const; + AgentStateLogPage getAgentStateLogPage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int httpStatusCode_; + std::string code_; + AgentStateLogPage agentStateLogPage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSRESULT_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/ListAgentSummaryReportsByIntervalResult.h b/ccc/include/alibabacloud/ccc/model/ListAgentSummaryReportsByIntervalResult.h index a974dd7e5..27f5a382c 100644 --- a/ccc/include/alibabacloud/ccc/model/ListAgentSummaryReportsByIntervalResult.h +++ b/ccc/include/alibabacloud/ccc/model/ListAgentSummaryReportsByIntervalResult.h @@ -48,8 +48,10 @@ namespace AlibabaCloud long oneTransferCalls; float satisfactionIndex; long satisfactionSurveysResponded; + std::string lastLogOutTime; long totalTalkTime; long averageReadyTime; + std::string firstLogInTime; long totalLoggedInTime; long maxTalkTime; long maxReadyTime; diff --git a/ccc/include/alibabacloud/ccc/model/ListAgentSummaryReportsResult.h b/ccc/include/alibabacloud/ccc/model/ListAgentSummaryReportsResult.h index 898f47388..a8608cf2f 100644 --- a/ccc/include/alibabacloud/ccc/model/ListAgentSummaryReportsResult.h +++ b/ccc/include/alibabacloud/ccc/model/ListAgentSummaryReportsResult.h @@ -46,8 +46,10 @@ namespace AlibabaCloud long oneTransferCalls; float satisfactionIndex; long satisfactionSurveysResponded; + std::string lastLogOutTime; long totalTalkTime; long averageReadyTime; + std::string firstLogInTime; long totalLoggedInTime; long maxTalkTime; long maxReadyTime; diff --git a/ccc/include/alibabacloud/ccc/model/ListTransferableSkillGroupsRequest.h b/ccc/include/alibabacloud/ccc/model/ListTransferableSkillGroupsRequest.h new file mode 100644 index 000000000..7a4e3a7cd --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/ListTransferableSkillGroupsRequest.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_CCC_MODEL_LISTTRANSFERABLESKILLGROUPSREQUEST_H_ +#define ALIBABACLOUD_CCC_MODEL_LISTTRANSFERABLESKILLGROUPSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT ListTransferableSkillGroupsRequest : public RpcServiceRequest + { + + public: + ListTransferableSkillGroupsRequest(); + ~ListTransferableSkillGroupsRequest(); + + std::string getInstanceId()const; + void setInstanceId(const std::string& instanceId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string instanceId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_LISTTRANSFERABLESKILLGROUPSREQUEST_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/ListTransferableSkillGroupsResult.h b/ccc/include/alibabacloud/ccc/model/ListTransferableSkillGroupsResult.h new file mode 100644 index 000000000..e629f813a --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/ListTransferableSkillGroupsResult.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_LISTTRANSFERABLESKILLGROUPSRESULT_H_ +#define ALIBABACLOUD_CCC_MODEL_LISTTRANSFERABLESKILLGROUPSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT ListTransferableSkillGroupsResult : public ServiceResult + { + public: + struct SkillGroup + { + bool allowPrivateOutboundNumber; + std::string skillGroupName; + std::string accSkillGroupName; + std::string instanceId; + int userCount; + std::string routingStrategy; + std::string skillGroupId; + std::string accQueueName; + std::string skillGroupDescription; + }; + + + ListTransferableSkillGroupsResult(); + explicit ListTransferableSkillGroupsResult(const std::string &payload); + ~ListTransferableSkillGroupsResult(); + std::string getMessage()const; + int getHttpStatusCode()const; + std::vector getSkillGroups()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int httpStatusCode_; + std::vector skillGroups_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_LISTTRANSFERABLESKILLGROUPSRESULT_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/ListTrunkProvidersRequest.h b/ccc/include/alibabacloud/ccc/model/ListTrunkProvidersRequest.h new file mode 100644 index 000000000..8bc961656 --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/ListTrunkProvidersRequest.h @@ -0,0 +1,48 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_LISTTRUNKPROVIDERSREQUEST_H_ +#define ALIBABACLOUD_CCC_MODEL_LISTTRUNKPROVIDERSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT ListTrunkProvidersRequest : public RpcServiceRequest + { + + public: + ListTrunkProvidersRequest(); + ~ListTrunkProvidersRequest(); + + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_LISTTRUNKPROVIDERSREQUEST_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/ListTrunkProvidersResult.h b/ccc/include/alibabacloud/ccc/model/ListTrunkProvidersResult.h new file mode 100644 index 000000000..33c9f6919 --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/ListTrunkProvidersResult.h @@ -0,0 +1,64 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_LISTTRUNKPROVIDERSRESULT_H_ +#define ALIBABACLOUD_CCC_MODEL_LISTTRUNKPROVIDERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT ListTrunkProvidersResult : public ServiceResult + { + public: + struct TrunkProvider + { + std::string status; + std::string providerName; + }; + + + ListTrunkProvidersResult(); + explicit ListTrunkProvidersResult(const std::string &payload); + ~ListTrunkProvidersResult(); + std::string getMessage()const; + int getHttpStatusCode()const; + std::vector getTrunkProviders()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int httpStatusCode_; + std::vector trunkProviders_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_LISTTRUNKPROVIDERSRESULT_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/ListTrunksOfSkillGroupRequest.h b/ccc/include/alibabacloud/ccc/model/ListTrunksOfSkillGroupRequest.h new file mode 100644 index 000000000..8083cc160 --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/ListTrunksOfSkillGroupRequest.h @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_LISTTRUNKSOFSKILLGROUPREQUEST_H_ +#define ALIBABACLOUD_CCC_MODEL_LISTTRUNKSOFSKILLGROUPREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT ListTrunksOfSkillGroupRequest : public RpcServiceRequest + { + + public: + ListTrunksOfSkillGroupRequest(); + ~ListTrunksOfSkillGroupRequest(); + + std::string getInstanceId()const; + void setInstanceId(const std::string& instanceId); + std::string getSkillGroupId()const; + void setSkillGroupId(const std::string& skillGroupId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string instanceId_; + std::string skillGroupId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_LISTTRUNKSOFSKILLGROUPREQUEST_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/ListTrunksOfSkillGroupResult.h b/ccc/include/alibabacloud/ccc/model/ListTrunksOfSkillGroupResult.h new file mode 100644 index 000000000..8fd09c686 --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/ListTrunksOfSkillGroupResult.h @@ -0,0 +1,64 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_LISTTRUNKSOFSKILLGROUPRESULT_H_ +#define ALIBABACLOUD_CCC_MODEL_LISTTRUNKSOFSKILLGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT ListTrunksOfSkillGroupResult : public ServiceResult + { + public: + struct TrunkConfig + { + std::string providerName; + bool primary; + }; + + + ListTrunksOfSkillGroupResult(); + explicit ListTrunksOfSkillGroupResult(const std::string &payload); + ~ListTrunksOfSkillGroupResult(); + std::string getMessage()const; + int getHttpStatusCode()const; + std::vector getTrunkConfigs()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int httpStatusCode_; + std::vector trunkConfigs_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_LISTTRUNKSOFSKILLGROUPRESULT_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/ModifyPrimaryTrunksOfSkillGroupRequest.h b/ccc/include/alibabacloud/ccc/model/ModifyPrimaryTrunksOfSkillGroupRequest.h new file mode 100644 index 000000000..a10126360 --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/ModifyPrimaryTrunksOfSkillGroupRequest.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_MODIFYPRIMARYTRUNKSOFSKILLGROUPREQUEST_H_ +#define ALIBABACLOUD_CCC_MODEL_MODIFYPRIMARYTRUNKSOFSKILLGROUPREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT ModifyPrimaryTrunksOfSkillGroupRequest : public RpcServiceRequest + { + + public: + ModifyPrimaryTrunksOfSkillGroupRequest(); + ~ModifyPrimaryTrunksOfSkillGroupRequest(); + + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::vector getPrimaryProviderName()const; + void setPrimaryProviderName(const std::vector& primaryProviderName); + std::string getInstanceId()const; + void setInstanceId(const std::string& instanceId); + std::string getSkillGroupId()const; + void setSkillGroupId(const std::string& skillGroupId); + + private: + std::string accessKeyId_; + std::vector primaryProviderName_; + std::string instanceId_; + std::string skillGroupId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_MODIFYPRIMARYTRUNKSOFSKILLGROUPREQUEST_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/ModifyPrimaryTrunksOfSkillGroupResult.h b/ccc/include/alibabacloud/ccc/model/ModifyPrimaryTrunksOfSkillGroupResult.h new file mode 100644 index 000000000..da57c4d5c --- /dev/null +++ b/ccc/include/alibabacloud/ccc/model/ModifyPrimaryTrunksOfSkillGroupResult.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_CCC_MODEL_MODIFYPRIMARYTRUNKSOFSKILLGROUPRESULT_H_ +#define ALIBABACLOUD_CCC_MODEL_MODIFYPRIMARYTRUNKSOFSKILLGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace CCC + { + namespace Model + { + class ALIBABACLOUD_CCC_EXPORT ModifyPrimaryTrunksOfSkillGroupResult : public ServiceResult + { + public: + + + ModifyPrimaryTrunksOfSkillGroupResult(); + explicit ModifyPrimaryTrunksOfSkillGroupResult(const std::string &payload); + ~ModifyPrimaryTrunksOfSkillGroupResult(); + std::string getMessage()const; + int getHttpStatusCode()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int httpStatusCode_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_CCC_MODEL_MODIFYPRIMARYTRUNKSOFSKILLGROUPRESULT_H_ \ No newline at end of file diff --git a/ccc/include/alibabacloud/ccc/model/RequestLoginInfoRequest.h b/ccc/include/alibabacloud/ccc/model/RequestLoginInfoRequest.h index e4c5af370..0f8d76b8a 100644 --- a/ccc/include/alibabacloud/ccc/model/RequestLoginInfoRequest.h +++ b/ccc/include/alibabacloud/ccc/model/RequestLoginInfoRequest.h @@ -37,11 +37,14 @@ namespace AlibabaCloud std::string getInstanceId()const; void setInstanceId(const std::string& instanceId); + std::string getUserId()const; + void setUserId(const std::string& userId); std::string getAccessKeyId()const; void setAccessKeyId(const std::string& accessKeyId); private: std::string instanceId_; + std::string userId_; std::string accessKeyId_; }; diff --git a/ccc/include/alibabacloud/ccc/model/ResetUserStatusRequest.h b/ccc/include/alibabacloud/ccc/model/ResetUserStatusRequest.h index 2cf244637..3671f3533 100644 --- a/ccc/include/alibabacloud/ccc/model/ResetUserStatusRequest.h +++ b/ccc/include/alibabacloud/ccc/model/ResetUserStatusRequest.h @@ -37,11 +37,14 @@ namespace AlibabaCloud std::string getInstanceId()const; void setInstanceId(const std::string& instanceId); + std::vector getRamIdList()const; + void setRamIdList(const std::vector& ramIdList); std::string getAccessKeyId()const; void setAccessKeyId(const std::string& accessKeyId); private: std::string instanceId_; + std::vector ramIdList_; std::string accessKeyId_; }; diff --git a/ccc/src/CCCClient.cc b/ccc/src/CCCClient.cc index 338013746..d88222096 100644 --- a/ccc/src/CCCClient.cc +++ b/ccc/src/CCCClient.cc @@ -1167,6 +1167,42 @@ CCCClient::DialogueOutcomeCallable CCCClient::dialogueCallable(const DialogueReq return task->get_future(); } +CCCClient::DisableTrunkProvidersOutcome CCCClient::disableTrunkProviders(const DisableTrunkProvidersRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DisableTrunkProvidersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DisableTrunkProvidersOutcome(DisableTrunkProvidersResult(outcome.result())); + else + return DisableTrunkProvidersOutcome(outcome.error()); +} + +void CCCClient::disableTrunkProvidersAsync(const DisableTrunkProvidersRequest& request, const DisableTrunkProvidersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, disableTrunkProviders(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +CCCClient::DisableTrunkProvidersOutcomeCallable CCCClient::disableTrunkProvidersCallable(const DisableTrunkProvidersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->disableTrunkProviders(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + CCCClient::DownloadAllTypeRecordingOutcome CCCClient::downloadAllTypeRecording(const DownloadAllTypeRecordingRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2391,6 +2427,42 @@ CCCClient::GetUserOutcomeCallable CCCClient::getUserCallable(const GetUserReques return task->get_future(); } +CCCClient::GetUserByExtensionOutcome CCCClient::getUserByExtension(const GetUserByExtensionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetUserByExtensionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetUserByExtensionOutcome(GetUserByExtensionResult(outcome.result())); + else + return GetUserByExtensionOutcome(outcome.error()); +} + +void CCCClient::getUserByExtensionAsync(const GetUserByExtensionRequest& request, const GetUserByExtensionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getUserByExtension(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +CCCClient::GetUserByExtensionOutcomeCallable CCCClient::getUserByExtensionCallable(const GetUserByExtensionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getUserByExtension(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + CCCClient::InflightTaskTimeoutOutcome CCCClient::inflightTaskTimeout(const InflightTaskTimeoutRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2571,6 +2643,42 @@ CCCClient::ListAgentEventsOutcomeCallable CCCClient::listAgentEventsCallable(con return task->get_future(); } +CCCClient::ListAgentStateLogsOutcome CCCClient::listAgentStateLogs(const ListAgentStateLogsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAgentStateLogsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAgentStateLogsOutcome(ListAgentStateLogsResult(outcome.result())); + else + return ListAgentStateLogsOutcome(outcome.error()); +} + +void CCCClient::listAgentStateLogsAsync(const ListAgentStateLogsRequest& request, const ListAgentStateLogsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAgentStateLogs(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +CCCClient::ListAgentStateLogsOutcomeCallable CCCClient::listAgentStateLogsCallable(const ListAgentStateLogsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAgentStateLogs(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + CCCClient::ListAgentStatesOutcome CCCClient::listAgentStates(const ListAgentStatesRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -3795,6 +3903,114 @@ CCCClient::ListSurveysOutcomeCallable CCCClient::listSurveysCallable(const ListS return task->get_future(); } +CCCClient::ListTransferableSkillGroupsOutcome CCCClient::listTransferableSkillGroups(const ListTransferableSkillGroupsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListTransferableSkillGroupsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListTransferableSkillGroupsOutcome(ListTransferableSkillGroupsResult(outcome.result())); + else + return ListTransferableSkillGroupsOutcome(outcome.error()); +} + +void CCCClient::listTransferableSkillGroupsAsync(const ListTransferableSkillGroupsRequest& request, const ListTransferableSkillGroupsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listTransferableSkillGroups(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +CCCClient::ListTransferableSkillGroupsOutcomeCallable CCCClient::listTransferableSkillGroupsCallable(const ListTransferableSkillGroupsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listTransferableSkillGroups(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +CCCClient::ListTrunkProvidersOutcome CCCClient::listTrunkProviders(const ListTrunkProvidersRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListTrunkProvidersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListTrunkProvidersOutcome(ListTrunkProvidersResult(outcome.result())); + else + return ListTrunkProvidersOutcome(outcome.error()); +} + +void CCCClient::listTrunkProvidersAsync(const ListTrunkProvidersRequest& request, const ListTrunkProvidersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listTrunkProviders(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +CCCClient::ListTrunkProvidersOutcomeCallable CCCClient::listTrunkProvidersCallable(const ListTrunkProvidersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listTrunkProviders(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +CCCClient::ListTrunksOfSkillGroupOutcome CCCClient::listTrunksOfSkillGroup(const ListTrunksOfSkillGroupRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListTrunksOfSkillGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListTrunksOfSkillGroupOutcome(ListTrunksOfSkillGroupResult(outcome.result())); + else + return ListTrunksOfSkillGroupOutcome(outcome.error()); +} + +void CCCClient::listTrunksOfSkillGroupAsync(const ListTrunksOfSkillGroupRequest& request, const ListTrunksOfSkillGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listTrunksOfSkillGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +CCCClient::ListTrunksOfSkillGroupOutcomeCallable CCCClient::listTrunksOfSkillGroupCallable(const ListTrunksOfSkillGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listTrunksOfSkillGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + CCCClient::ListUnreachableContactsOutcome CCCClient::listUnreachableContacts(const ListUnreachableContactsRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -4083,6 +4299,42 @@ CCCClient::ModifyPhoneTagsOutcomeCallable CCCClient::modifyPhoneTagsCallable(con return task->get_future(); } +CCCClient::ModifyPrimaryTrunksOfSkillGroupOutcome CCCClient::modifyPrimaryTrunksOfSkillGroup(const ModifyPrimaryTrunksOfSkillGroupRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyPrimaryTrunksOfSkillGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyPrimaryTrunksOfSkillGroupOutcome(ModifyPrimaryTrunksOfSkillGroupResult(outcome.result())); + else + return ModifyPrimaryTrunksOfSkillGroupOutcome(outcome.error()); +} + +void CCCClient::modifyPrimaryTrunksOfSkillGroupAsync(const ModifyPrimaryTrunksOfSkillGroupRequest& request, const ModifyPrimaryTrunksOfSkillGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyPrimaryTrunksOfSkillGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +CCCClient::ModifyPrimaryTrunksOfSkillGroupOutcomeCallable CCCClient::modifyPrimaryTrunksOfSkillGroupCallable(const ModifyPrimaryTrunksOfSkillGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyPrimaryTrunksOfSkillGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + CCCClient::ModifyPrivacyNumberCallDetailOutcome CCCClient::modifyPrivacyNumberCallDetail(const ModifyPrivacyNumberCallDetailRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/ccc/src/model/AddBulkPhoneNumbersResult.cc b/ccc/src/model/AddBulkPhoneNumbersResult.cc index 074caf1dd..9757880ee 100644 --- a/ccc/src/model/AddBulkPhoneNumbersResult.cc +++ b/ccc/src/model/AddBulkPhoneNumbersResult.cc @@ -61,14 +61,14 @@ void AddBulkPhoneNumbersResult::parse(const std::string &payload) phoneNumbersObject.usage = valuePhoneNumbersPhoneNumber["Usage"].asString(); if(!valuePhoneNumbersPhoneNumber["Trunks"].isNull()) phoneNumbersObject.trunks = std::stoi(valuePhoneNumbersPhoneNumber["Trunks"].asString()); - auto allSkillGroupsNode = allPhoneNumbersNode["SkillGroups"]["SkillGroup"]; - for (auto allPhoneNumbersNodeSkillGroupsSkillGroup : allSkillGroupsNode) + auto allSkillGroupsNode = valuePhoneNumbersPhoneNumber["SkillGroups"]["SkillGroup"]; + for (auto valuePhoneNumbersPhoneNumberSkillGroupsSkillGroup : allSkillGroupsNode) { PhoneNumber::SkillGroup skillGroupsObject; - if(!allPhoneNumbersNodeSkillGroupsSkillGroup["SkillGroupId"].isNull()) - skillGroupsObject.skillGroupId = allPhoneNumbersNodeSkillGroupsSkillGroup["SkillGroupId"].asString(); - if(!allPhoneNumbersNodeSkillGroupsSkillGroup["SkillGroupName"].isNull()) - skillGroupsObject.skillGroupName = allPhoneNumbersNodeSkillGroupsSkillGroup["SkillGroupName"].asString(); + if(!valuePhoneNumbersPhoneNumberSkillGroupsSkillGroup["SkillGroupId"].isNull()) + skillGroupsObject.skillGroupId = valuePhoneNumbersPhoneNumberSkillGroupsSkillGroup["SkillGroupId"].asString(); + if(!valuePhoneNumbersPhoneNumberSkillGroupsSkillGroup["SkillGroupName"].isNull()) + skillGroupsObject.skillGroupName = valuePhoneNumbersPhoneNumberSkillGroupsSkillGroup["SkillGroupName"].asString(); phoneNumbersObject.skillGroups.push_back(skillGroupsObject); } auto contactFlowNode = value["ContactFlow"]; diff --git a/ccc/src/model/AddPhoneTagsRequest.cc b/ccc/src/model/AddPhoneTagsRequest.cc index da316594c..56a765569 100644 --- a/ccc/src/model/AddPhoneTagsRequest.cc +++ b/ccc/src/model/AddPhoneTagsRequest.cc @@ -117,6 +117,17 @@ void AddPhoneTagsRequest::setServiceTag(const std::string& serviceTag) setParameter("ServiceTag", serviceTag); } +std::string AddPhoneTagsRequest::getSipTag()const +{ + return sipTag_; +} + +void AddPhoneTagsRequest::setSipTag(const std::string& sipTag) +{ + sipTag_ = sipTag; + setParameter("SipTag", sipTag); +} + std::string AddPhoneTagsRequest::getRegionNameCity()const { return regionNameCity_; diff --git a/ccc/src/model/CreateScenarioFromTemplateResult.cc b/ccc/src/model/CreateScenarioFromTemplateResult.cc index 5408512ce..3b3d1bd4a 100644 --- a/ccc/src/model/CreateScenarioFromTemplateResult.cc +++ b/ccc/src/model/CreateScenarioFromTemplateResult.cc @@ -66,14 +66,14 @@ void CreateScenarioFromTemplateResult::parse(const std::string &payload) surveyObject.round = std::stoi(scenarioNodeSurveysSurvey["Round"].asString()); if(!scenarioNodeSurveysSurvey["BeebotId"].isNull()) surveyObject.beebotId = scenarioNodeSurveysSurvey["BeebotId"].asString(); - auto allIntentsNode = allSurveysNode["Intents"]["IntentNode"]; - for (auto allSurveysNodeIntentsIntentNode : allIntentsNode) + auto allIntentsNode = scenarioNodeSurveysSurvey["Intents"]["IntentNode"]; + for (auto scenarioNodeSurveysSurveyIntentsIntentNode : allIntentsNode) { Scenario::Survey::IntentNode intentsObject; - if(!allSurveysNodeIntentsIntentNode["NodeId"].isNull()) - intentsObject.nodeId = allSurveysNodeIntentsIntentNode["NodeId"].asString(); - if(!allSurveysNodeIntentsIntentNode["IntentId"].isNull()) - intentsObject.intentId = allSurveysNodeIntentsIntentNode["IntentId"].asString(); + if(!scenarioNodeSurveysSurveyIntentsIntentNode["NodeId"].isNull()) + intentsObject.nodeId = scenarioNodeSurveysSurveyIntentsIntentNode["NodeId"].asString(); + if(!scenarioNodeSurveysSurveyIntentsIntentNode["IntentId"].isNull()) + intentsObject.intentId = scenarioNodeSurveysSurveyIntentsIntentNode["IntentId"].asString(); surveyObject.intents.push_back(intentsObject); } scenario_.surveys.push_back(surveyObject); diff --git a/ccc/src/model/CreateScenarioResult.cc b/ccc/src/model/CreateScenarioResult.cc index 02b623e54..b0b90c2b8 100644 --- a/ccc/src/model/CreateScenarioResult.cc +++ b/ccc/src/model/CreateScenarioResult.cc @@ -66,14 +66,14 @@ void CreateScenarioResult::parse(const std::string &payload) surveyObject.round = std::stoi(scenarioNodeSurveysSurvey["Round"].asString()); if(!scenarioNodeSurveysSurvey["BeebotId"].isNull()) surveyObject.beebotId = scenarioNodeSurveysSurvey["BeebotId"].asString(); - auto allIntentsNode = allSurveysNode["Intents"]["IntentNode"]; - for (auto allSurveysNodeIntentsIntentNode : allIntentsNode) + auto allIntentsNode = scenarioNodeSurveysSurvey["Intents"]["IntentNode"]; + for (auto scenarioNodeSurveysSurveyIntentsIntentNode : allIntentsNode) { Scenario::Survey::IntentNode intentsObject; - if(!allSurveysNodeIntentsIntentNode["NodeId"].isNull()) - intentsObject.nodeId = allSurveysNodeIntentsIntentNode["NodeId"].asString(); - if(!allSurveysNodeIntentsIntentNode["IntentId"].isNull()) - intentsObject.intentId = allSurveysNodeIntentsIntentNode["IntentId"].asString(); + if(!scenarioNodeSurveysSurveyIntentsIntentNode["NodeId"].isNull()) + intentsObject.nodeId = scenarioNodeSurveysSurveyIntentsIntentNode["NodeId"].asString(); + if(!scenarioNodeSurveysSurveyIntentsIntentNode["IntentId"].isNull()) + intentsObject.intentId = scenarioNodeSurveysSurveyIntentsIntentNode["IntentId"].asString(); surveyObject.intents.push_back(intentsObject); } scenario_.surveys.push_back(surveyObject); diff --git a/ccc/src/model/DisableTrunkProvidersRequest.cc b/ccc/src/model/DisableTrunkProvidersRequest.cc new file mode 100644 index 000000000..479111632 --- /dev/null +++ b/ccc/src/model/DisableTrunkProvidersRequest.cc @@ -0,0 +1,53 @@ +/* + * 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 + +using AlibabaCloud::CCC::Model::DisableTrunkProvidersRequest; + +DisableTrunkProvidersRequest::DisableTrunkProvidersRequest() : + RpcServiceRequest("ccc", "2017-07-05", "DisableTrunkProviders") +{ + setMethod(HttpRequest::Method::Post); +} + +DisableTrunkProvidersRequest::~DisableTrunkProvidersRequest() +{} + +std::vector DisableTrunkProvidersRequest::getProviderName()const +{ + return providerName_; +} + +void DisableTrunkProvidersRequest::setProviderName(const std::vector& providerName) +{ + providerName_ = providerName; + for(int dep1 = 0; dep1!= providerName.size(); dep1++) { + setParameter("ProviderName."+ std::to_string(dep1), providerName.at(dep1)); + } +} + +std::string DisableTrunkProvidersRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DisableTrunkProvidersRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/ccc/src/model/DisableTrunkProvidersResult.cc b/ccc/src/model/DisableTrunkProvidersResult.cc new file mode 100644 index 000000000..8953e710a --- /dev/null +++ b/ccc/src/model/DisableTrunkProvidersResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::CCC; +using namespace AlibabaCloud::CCC::Model; + +DisableTrunkProvidersResult::DisableTrunkProvidersResult() : + ServiceResult() +{} + +DisableTrunkProvidersResult::DisableTrunkProvidersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DisableTrunkProvidersResult::~DisableTrunkProvidersResult() +{} + +void DisableTrunkProvidersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["HttpStatusCode"].isNull()) + httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + +} + +std::string DisableTrunkProvidersResult::getMessage()const +{ + return message_; +} + +int DisableTrunkProvidersResult::getHttpStatusCode()const +{ + return httpStatusCode_; +} + +std::string DisableTrunkProvidersResult::getCode()const +{ + return code_; +} + +bool DisableTrunkProvidersResult::getSuccess()const +{ + return success_; +} + diff --git a/ccc/src/model/FindUsersResult.cc b/ccc/src/model/FindUsersResult.cc index efb023e12..c73ce844d 100644 --- a/ccc/src/model/FindUsersResult.cc +++ b/ccc/src/model/FindUsersResult.cc @@ -58,28 +58,28 @@ void FindUsersResult::parse(const std::string &payload) userObject.instanceId = usersNodeListUser["InstanceId"].asString(); if(!usersNodeListUser["PrivateOutboundNumberId"].isNull()) userObject.privateOutboundNumberId = usersNodeListUser["PrivateOutboundNumberId"].asString(); - auto allRolesNode = allListNode["Roles"]["Role"]; - for (auto allListNodeRolesRole : allRolesNode) + auto allRolesNode = usersNodeListUser["Roles"]["Role"]; + for (auto usersNodeListUserRolesRole : allRolesNode) { Users::User::Role rolesObject; - if(!allListNodeRolesRole["RoleId"].isNull()) - rolesObject.roleId = allListNodeRolesRole["RoleId"].asString(); - if(!allListNodeRolesRole["InstanceId"].isNull()) - rolesObject.instanceId = allListNodeRolesRole["InstanceId"].asString(); - if(!allListNodeRolesRole["RoleName"].isNull()) - rolesObject.roleName = allListNodeRolesRole["RoleName"].asString(); - if(!allListNodeRolesRole["RoleDescription"].isNull()) - rolesObject.roleDescription = allListNodeRolesRole["RoleDescription"].asString(); + if(!usersNodeListUserRolesRole["RoleId"].isNull()) + rolesObject.roleId = usersNodeListUserRolesRole["RoleId"].asString(); + if(!usersNodeListUserRolesRole["InstanceId"].isNull()) + rolesObject.instanceId = usersNodeListUserRolesRole["InstanceId"].asString(); + if(!usersNodeListUserRolesRole["RoleName"].isNull()) + rolesObject.roleName = usersNodeListUserRolesRole["RoleName"].asString(); + if(!usersNodeListUserRolesRole["RoleDescription"].isNull()) + rolesObject.roleDescription = usersNodeListUserRolesRole["RoleDescription"].asString(); userObject.roles.push_back(rolesObject); } - auto allSkillLevelsNode = allListNode["SkillLevels"]["SkillLevel"]; - for (auto allListNodeSkillLevelsSkillLevel : allSkillLevelsNode) + auto allSkillLevelsNode = usersNodeListUser["SkillLevels"]["SkillLevel"]; + for (auto usersNodeListUserSkillLevelsSkillLevel : allSkillLevelsNode) { Users::User::SkillLevel skillLevelsObject; - if(!allListNodeSkillLevelsSkillLevel["SkillLevelId"].isNull()) - skillLevelsObject.skillLevelId = allListNodeSkillLevelsSkillLevel["SkillLevelId"].asString(); - if(!allListNodeSkillLevelsSkillLevel["Level"].isNull()) - skillLevelsObject.level = std::stoi(allListNodeSkillLevelsSkillLevel["Level"].asString()); + if(!usersNodeListUserSkillLevelsSkillLevel["SkillLevelId"].isNull()) + skillLevelsObject.skillLevelId = usersNodeListUserSkillLevelsSkillLevel["SkillLevelId"].asString(); + if(!usersNodeListUserSkillLevelsSkillLevel["Level"].isNull()) + skillLevelsObject.level = std::stoi(usersNodeListUserSkillLevelsSkillLevel["Level"].asString()); auto skillNode = value["Skill"]; if(!skillNode["SkillGroupId"].isNull()) skillLevelsObject.skill.skillGroupId = skillNode["SkillGroupId"].asString(); diff --git a/ccc/src/model/GetConversationListResult.cc b/ccc/src/model/GetConversationListResult.cc index e92d638de..96cd893e7 100644 --- a/ccc/src/model/GetConversationListResult.cc +++ b/ccc/src/model/GetConversationListResult.cc @@ -49,16 +49,16 @@ void GetConversationListResult::parse(const std::string &payload) conversationsObject.speaker = valueConversationsConversationDetail["Speaker"].asString(); if(!valueConversationsConversationDetail["Script"].isNull()) conversationsObject.script = valueConversationsConversationDetail["Script"].asString(); - auto allSummaryNode = allConversationsNode["Summary"]["SummaryItem"]; - for (auto allConversationsNodeSummarySummaryItem : allSummaryNode) + auto allSummaryNode = valueConversationsConversationDetail["Summary"]["SummaryItem"]; + for (auto valueConversationsConversationDetailSummarySummaryItem : allSummaryNode) { ConversationDetail::SummaryItem summaryObject; - if(!allConversationsNodeSummarySummaryItem["Category"].isNull()) - summaryObject.category = allConversationsNodeSummarySummaryItem["Category"].asString(); - if(!allConversationsNodeSummarySummaryItem["SummaryName"].isNull()) - summaryObject.summaryName = allConversationsNodeSummarySummaryItem["SummaryName"].asString(); - if(!allConversationsNodeSummarySummaryItem["Content"].isNull()) - summaryObject.content = allConversationsNodeSummarySummaryItem["Content"].asString(); + if(!valueConversationsConversationDetailSummarySummaryItem["Category"].isNull()) + summaryObject.category = valueConversationsConversationDetailSummarySummaryItem["Category"].asString(); + if(!valueConversationsConversationDetailSummarySummaryItem["SummaryName"].isNull()) + summaryObject.summaryName = valueConversationsConversationDetailSummarySummaryItem["SummaryName"].asString(); + if(!valueConversationsConversationDetailSummarySummaryItem["Content"].isNull()) + summaryObject.content = valueConversationsConversationDetailSummarySummaryItem["Content"].asString(); conversationsObject.summary.push_back(summaryObject); } conversations_.push_back(conversationsObject); diff --git a/ccc/src/model/GetJobListResult.cc b/ccc/src/model/GetJobListResult.cc index 5549bdc75..6050c3799 100644 --- a/ccc/src/model/GetJobListResult.cc +++ b/ccc/src/model/GetJobListResult.cc @@ -68,58 +68,58 @@ void GetJobListResult::parse(const std::string &payload) jobObject.referenceId = jobsNodeListJob["ReferenceId"].asString(); if(!jobsNodeListJob["FailureReason"].isNull()) jobObject.failureReason = jobsNodeListJob["FailureReason"].asString(); - auto allContactsNode = allListNode["Contacts"]["Contact"]; - for (auto allListNodeContactsContact : allContactsNode) + auto allContactsNode = jobsNodeListJob["Contacts"]["Contact"]; + for (auto jobsNodeListJobContactsContact : allContactsNode) { Jobs::Job::Contact contactsObject; - if(!allListNodeContactsContact["ContactId"].isNull()) - contactsObject.contactId = allListNodeContactsContact["ContactId"].asString(); - if(!allListNodeContactsContact["ContactName"].isNull()) - contactsObject.contactName = allListNodeContactsContact["ContactName"].asString(); - if(!allListNodeContactsContact["Honorific"].isNull()) - contactsObject.honorific = allListNodeContactsContact["Honorific"].asString(); - if(!allListNodeContactsContact["Role"].isNull()) - contactsObject.role = allListNodeContactsContact["Role"].asString(); - if(!allListNodeContactsContact["PhoneNumber"].isNull()) - contactsObject.phoneNumber = allListNodeContactsContact["PhoneNumber"].asString(); - if(!allListNodeContactsContact["State"].isNull()) - contactsObject.state = allListNodeContactsContact["State"].asString(); - if(!allListNodeContactsContact["ReferenceId"].isNull()) - contactsObject.referenceId = allListNodeContactsContact["ReferenceId"].asString(); - if(!allListNodeContactsContact["JobId"].isNull()) - contactsObject.jobId = allListNodeContactsContact["JobId"].asString(); + if(!jobsNodeListJobContactsContact["ContactId"].isNull()) + contactsObject.contactId = jobsNodeListJobContactsContact["ContactId"].asString(); + if(!jobsNodeListJobContactsContact["ContactName"].isNull()) + contactsObject.contactName = jobsNodeListJobContactsContact["ContactName"].asString(); + if(!jobsNodeListJobContactsContact["Honorific"].isNull()) + contactsObject.honorific = jobsNodeListJobContactsContact["Honorific"].asString(); + if(!jobsNodeListJobContactsContact["Role"].isNull()) + contactsObject.role = jobsNodeListJobContactsContact["Role"].asString(); + if(!jobsNodeListJobContactsContact["PhoneNumber"].isNull()) + contactsObject.phoneNumber = jobsNodeListJobContactsContact["PhoneNumber"].asString(); + if(!jobsNodeListJobContactsContact["State"].isNull()) + contactsObject.state = jobsNodeListJobContactsContact["State"].asString(); + if(!jobsNodeListJobContactsContact["ReferenceId"].isNull()) + contactsObject.referenceId = jobsNodeListJobContactsContact["ReferenceId"].asString(); + if(!jobsNodeListJobContactsContact["JobId"].isNull()) + contactsObject.jobId = jobsNodeListJobContactsContact["JobId"].asString(); jobObject.contacts.push_back(contactsObject); } - auto allExtrasNode = allListNode["Extras"]["KeyValuePair"]; - for (auto allListNodeExtrasKeyValuePair : allExtrasNode) + auto allExtrasNode = jobsNodeListJob["Extras"]["KeyValuePair"]; + for (auto jobsNodeListJobExtrasKeyValuePair : allExtrasNode) { Jobs::Job::KeyValuePair extrasObject; - if(!allListNodeExtrasKeyValuePair["Key"].isNull()) - extrasObject.key = allListNodeExtrasKeyValuePair["Key"].asString(); - if(!allListNodeExtrasKeyValuePair["Value"].isNull()) - extrasObject.value = allListNodeExtrasKeyValuePair["Value"].asString(); + if(!jobsNodeListJobExtrasKeyValuePair["Key"].isNull()) + extrasObject.key = jobsNodeListJobExtrasKeyValuePair["Key"].asString(); + if(!jobsNodeListJobExtrasKeyValuePair["Value"].isNull()) + extrasObject.value = jobsNodeListJobExtrasKeyValuePair["Value"].asString(); jobObject.extras.push_back(extrasObject); } - auto allSummaryNode = allListNode["Summary"]["SummaryItem"]; - for (auto allListNodeSummarySummaryItem : allSummaryNode) + auto allSummaryNode = jobsNodeListJob["Summary"]["SummaryItem"]; + for (auto jobsNodeListJobSummarySummaryItem : allSummaryNode) { Jobs::Job::SummaryItem summaryObject; - if(!allListNodeSummarySummaryItem["SummaryId"].isNull()) - summaryObject.summaryId = allListNodeSummarySummaryItem["SummaryId"].asString(); - if(!allListNodeSummarySummaryItem["GroupId"].isNull()) - summaryObject.groupId = allListNodeSummarySummaryItem["GroupId"].asString(); - if(!allListNodeSummarySummaryItem["JobId"].isNull()) - summaryObject.jobId = allListNodeSummarySummaryItem["JobId"].asString(); - if(!allListNodeSummarySummaryItem["TaskId"].isNull()) - summaryObject.taskId = allListNodeSummarySummaryItem["TaskId"].asString(); - if(!allListNodeSummarySummaryItem["ConversationDetailId"].isNull()) - summaryObject.conversationDetailId = allListNodeSummarySummaryItem["ConversationDetailId"].asString(); - if(!allListNodeSummarySummaryItem["Category"].isNull()) - summaryObject.category = allListNodeSummarySummaryItem["Category"].asString(); - if(!allListNodeSummarySummaryItem["SummaryName"].isNull()) - summaryObject.summaryName = allListNodeSummarySummaryItem["SummaryName"].asString(); - if(!allListNodeSummarySummaryItem["Content"].isNull()) - summaryObject.content = allListNodeSummarySummaryItem["Content"].asString(); + if(!jobsNodeListJobSummarySummaryItem["SummaryId"].isNull()) + summaryObject.summaryId = jobsNodeListJobSummarySummaryItem["SummaryId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["GroupId"].isNull()) + summaryObject.groupId = jobsNodeListJobSummarySummaryItem["GroupId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["JobId"].isNull()) + summaryObject.jobId = jobsNodeListJobSummarySummaryItem["JobId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["TaskId"].isNull()) + summaryObject.taskId = jobsNodeListJobSummarySummaryItem["TaskId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["ConversationDetailId"].isNull()) + summaryObject.conversationDetailId = jobsNodeListJobSummarySummaryItem["ConversationDetailId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["Category"].isNull()) + summaryObject.category = jobsNodeListJobSummarySummaryItem["Category"].asString(); + if(!jobsNodeListJobSummarySummaryItem["SummaryName"].isNull()) + summaryObject.summaryName = jobsNodeListJobSummarySummaryItem["SummaryName"].asString(); + if(!jobsNodeListJobSummarySummaryItem["Content"].isNull()) + summaryObject.content = jobsNodeListJobSummarySummaryItem["Content"].asString(); jobObject.summary.push_back(summaryObject); } auto allCallingNumbers = value["CallingNumbers"]["String"]; diff --git a/ccc/src/model/GetJobResult.cc b/ccc/src/model/GetJobResult.cc index 0109122a0..a02668007 100644 --- a/ccc/src/model/GetJobResult.cc +++ b/ccc/src/model/GetJobResult.cc @@ -116,26 +116,26 @@ void GetJobResult::parse(const std::string &payload) taskObject.brief = jobNodeTasksTask["Brief"].asString(); if(!jobNodeTasksTask["Duration"].isNull()) taskObject.duration = std::stoi(jobNodeTasksTask["Duration"].asString()); - auto allConversationNode = allTasksNode["Conversation"]["ConversationDetail"]; - for (auto allTasksNodeConversationConversationDetail : allConversationNode) + auto allConversationNode = jobNodeTasksTask["Conversation"]["ConversationDetail"]; + for (auto jobNodeTasksTaskConversationConversationDetail : allConversationNode) { Job::Task::ConversationDetail conversationObject; - if(!allTasksNodeConversationConversationDetail["Timestamp"].isNull()) - conversationObject.timestamp = std::stol(allTasksNodeConversationConversationDetail["Timestamp"].asString()); - if(!allTasksNodeConversationConversationDetail["Speaker"].isNull()) - conversationObject.speaker = allTasksNodeConversationConversationDetail["Speaker"].asString(); - if(!allTasksNodeConversationConversationDetail["Script"].isNull()) - conversationObject.script = allTasksNodeConversationConversationDetail["Script"].asString(); - auto allSummary1Node = allConversationNode["Summary"]["SummaryItem"]; - for (auto allConversationNodeSummarySummaryItem : allSummary1Node) + if(!jobNodeTasksTaskConversationConversationDetail["Timestamp"].isNull()) + conversationObject.timestamp = std::stol(jobNodeTasksTaskConversationConversationDetail["Timestamp"].asString()); + if(!jobNodeTasksTaskConversationConversationDetail["Speaker"].isNull()) + conversationObject.speaker = jobNodeTasksTaskConversationConversationDetail["Speaker"].asString(); + if(!jobNodeTasksTaskConversationConversationDetail["Script"].isNull()) + conversationObject.script = jobNodeTasksTaskConversationConversationDetail["Script"].asString(); + auto allSummary1Node = jobNodeTasksTaskConversationConversationDetail["Summary"]["SummaryItem"]; + for (auto jobNodeTasksTaskConversationConversationDetailSummarySummaryItem : allSummary1Node) { Job::Task::ConversationDetail::SummaryItem summary1Object; - if(!allConversationNodeSummarySummaryItem["Category"].isNull()) - summary1Object.category = allConversationNodeSummarySummaryItem["Category"].asString(); - if(!allConversationNodeSummarySummaryItem["SummaryName"].isNull()) - summary1Object.summaryName = allConversationNodeSummarySummaryItem["SummaryName"].asString(); - if(!allConversationNodeSummarySummaryItem["Content"].isNull()) - summary1Object.content = allConversationNodeSummarySummaryItem["Content"].asString(); + if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Category"].isNull()) + summary1Object.category = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Category"].asString(); + if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["SummaryName"].isNull()) + summary1Object.summaryName = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["SummaryName"].asString(); + if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Content"].isNull()) + summary1Object.content = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Content"].asString(); conversationObject.summary1.push_back(summary1Object); } taskObject.conversation.push_back(conversationObject); diff --git a/ccc/src/model/GetJobStatusByCallIdResult.cc b/ccc/src/model/GetJobStatusByCallIdResult.cc index 30656b981..d8296b8f7 100644 --- a/ccc/src/model/GetJobStatusByCallIdResult.cc +++ b/ccc/src/model/GetJobStatusByCallIdResult.cc @@ -118,32 +118,32 @@ void GetJobStatusByCallIdResult::parse(const std::string &payload) taskObject.brief = jobNodeTasksTask["Brief"].asString(); if(!jobNodeTasksTask["Duration"].isNull()) taskObject.duration = std::stoi(jobNodeTasksTask["Duration"].asString()); - auto allConversationNode = allTasksNode["Conversation"]["ConversationDetail"]; - for (auto allTasksNodeConversationConversationDetail : allConversationNode) + auto allConversationNode = jobNodeTasksTask["Conversation"]["ConversationDetail"]; + for (auto jobNodeTasksTaskConversationConversationDetail : allConversationNode) { Job::Task::ConversationDetail conversationObject; - if(!allTasksNodeConversationConversationDetail["ConversationDetailId"].isNull()) - conversationObject.conversationDetailId = allTasksNodeConversationConversationDetail["ConversationDetailId"].asString(); - if(!allTasksNodeConversationConversationDetail["TaskId"].isNull()) - conversationObject.taskId = allTasksNodeConversationConversationDetail["TaskId"].asString(); - if(!allTasksNodeConversationConversationDetail["Timestamp"].isNull()) - conversationObject.timestamp = std::stol(allTasksNodeConversationConversationDetail["Timestamp"].asString()); - if(!allTasksNodeConversationConversationDetail["Speaker"].isNull()) - conversationObject.speaker = allTasksNodeConversationConversationDetail["Speaker"].asString(); - if(!allTasksNodeConversationConversationDetail["Script"].isNull()) - conversationObject.script = allTasksNodeConversationConversationDetail["Script"].asString(); - auto allSummary1Node = allConversationNode["Summary"]["SummaryItem"]; - for (auto allConversationNodeSummarySummaryItem : allSummary1Node) + if(!jobNodeTasksTaskConversationConversationDetail["ConversationDetailId"].isNull()) + conversationObject.conversationDetailId = jobNodeTasksTaskConversationConversationDetail["ConversationDetailId"].asString(); + if(!jobNodeTasksTaskConversationConversationDetail["TaskId"].isNull()) + conversationObject.taskId = jobNodeTasksTaskConversationConversationDetail["TaskId"].asString(); + if(!jobNodeTasksTaskConversationConversationDetail["Timestamp"].isNull()) + conversationObject.timestamp = std::stol(jobNodeTasksTaskConversationConversationDetail["Timestamp"].asString()); + if(!jobNodeTasksTaskConversationConversationDetail["Speaker"].isNull()) + conversationObject.speaker = jobNodeTasksTaskConversationConversationDetail["Speaker"].asString(); + if(!jobNodeTasksTaskConversationConversationDetail["Script"].isNull()) + conversationObject.script = jobNodeTasksTaskConversationConversationDetail["Script"].asString(); + auto allSummary1Node = jobNodeTasksTaskConversationConversationDetail["Summary"]["SummaryItem"]; + for (auto jobNodeTasksTaskConversationConversationDetailSummarySummaryItem : allSummary1Node) { Job::Task::ConversationDetail::SummaryItem summary1Object; - if(!allConversationNodeSummarySummaryItem["SummaryId"].isNull()) - summary1Object.summaryId = allConversationNodeSummarySummaryItem["SummaryId"].asString(); - if(!allConversationNodeSummarySummaryItem["Category"].isNull()) - summary1Object.category = allConversationNodeSummarySummaryItem["Category"].asString(); - if(!allConversationNodeSummarySummaryItem["SummaryName"].isNull()) - summary1Object.summaryName = allConversationNodeSummarySummaryItem["SummaryName"].asString(); - if(!allConversationNodeSummarySummaryItem["Content"].isNull()) - summary1Object.content = allConversationNodeSummarySummaryItem["Content"].asString(); + if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["SummaryId"].isNull()) + summary1Object.summaryId = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["SummaryId"].asString(); + if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Category"].isNull()) + summary1Object.category = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Category"].asString(); + if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["SummaryName"].isNull()) + summary1Object.summaryName = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["SummaryName"].asString(); + if(!jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Content"].isNull()) + summary1Object.content = jobNodeTasksTaskConversationConversationDetailSummarySummaryItem["Content"].asString(); conversationObject.summary1.push_back(summary1Object); } taskObject.conversation.push_back(conversationObject); diff --git a/ccc/src/model/GetScenarioResult.cc b/ccc/src/model/GetScenarioResult.cc index 37e19a5fe..6cf23e948 100644 --- a/ccc/src/model/GetScenarioResult.cc +++ b/ccc/src/model/GetScenarioResult.cc @@ -66,14 +66,14 @@ void GetScenarioResult::parse(const std::string &payload) surveyObject.round = std::stoi(scenarioNodeSurveysSurvey["Round"].asString()); if(!scenarioNodeSurveysSurvey["BeebotId"].isNull()) surveyObject.beebotId = scenarioNodeSurveysSurvey["BeebotId"].asString(); - auto allIntentsNode = allSurveysNode["Intents"]["IntentNode"]; - for (auto allSurveysNodeIntentsIntentNode : allIntentsNode) + auto allIntentsNode = scenarioNodeSurveysSurvey["Intents"]["IntentNode"]; + for (auto scenarioNodeSurveysSurveyIntentsIntentNode : allIntentsNode) { Scenario::Survey::IntentNode intentsObject; - if(!allSurveysNodeIntentsIntentNode["NodeId"].isNull()) - intentsObject.nodeId = allSurveysNodeIntentsIntentNode["NodeId"].asString(); - if(!allSurveysNodeIntentsIntentNode["IntentId"].isNull()) - intentsObject.intentId = allSurveysNodeIntentsIntentNode["IntentId"].asString(); + if(!scenarioNodeSurveysSurveyIntentsIntentNode["NodeId"].isNull()) + intentsObject.nodeId = scenarioNodeSurveysSurveyIntentsIntentNode["NodeId"].asString(); + if(!scenarioNodeSurveysSurveyIntentsIntentNode["IntentId"].isNull()) + intentsObject.intentId = scenarioNodeSurveysSurveyIntentsIntentNode["IntentId"].asString(); surveyObject.intents.push_back(intentsObject); } scenario_.surveys.push_back(surveyObject); diff --git a/ccc/src/model/GetTaskListResult.cc b/ccc/src/model/GetTaskListResult.cc index a25938c64..1007d0e3f 100644 --- a/ccc/src/model/GetTaskListResult.cc +++ b/ccc/src/model/GetTaskListResult.cc @@ -67,26 +67,26 @@ void GetTaskListResult::parse(const std::string &payload) tasksObject.brief = valueTasksTask["Brief"].asString(); if(!valueTasksTask["Duration"].isNull()) tasksObject.duration = std::stoi(valueTasksTask["Duration"].asString()); - auto allConversationNode = allTasksNode["Conversation"]["ConversationDetail"]; - for (auto allTasksNodeConversationConversationDetail : allConversationNode) + auto allConversationNode = valueTasksTask["Conversation"]["ConversationDetail"]; + for (auto valueTasksTaskConversationConversationDetail : allConversationNode) { Task::ConversationDetail conversationObject; - if(!allTasksNodeConversationConversationDetail["Timestamp"].isNull()) - conversationObject.timestamp = std::stol(allTasksNodeConversationConversationDetail["Timestamp"].asString()); - if(!allTasksNodeConversationConversationDetail["Speaker"].isNull()) - conversationObject.speaker = allTasksNodeConversationConversationDetail["Speaker"].asString(); - if(!allTasksNodeConversationConversationDetail["Script"].isNull()) - conversationObject.script = allTasksNodeConversationConversationDetail["Script"].asString(); - auto allSummaryNode = allConversationNode["Summary"]["SummaryItem"]; - for (auto allConversationNodeSummarySummaryItem : allSummaryNode) + if(!valueTasksTaskConversationConversationDetail["Timestamp"].isNull()) + conversationObject.timestamp = std::stol(valueTasksTaskConversationConversationDetail["Timestamp"].asString()); + if(!valueTasksTaskConversationConversationDetail["Speaker"].isNull()) + conversationObject.speaker = valueTasksTaskConversationConversationDetail["Speaker"].asString(); + if(!valueTasksTaskConversationConversationDetail["Script"].isNull()) + conversationObject.script = valueTasksTaskConversationConversationDetail["Script"].asString(); + auto allSummaryNode = valueTasksTaskConversationConversationDetail["Summary"]["SummaryItem"]; + for (auto valueTasksTaskConversationConversationDetailSummarySummaryItem : allSummaryNode) { Task::ConversationDetail::SummaryItem summaryObject; - if(!allConversationNodeSummarySummaryItem["Category"].isNull()) - summaryObject.category = allConversationNodeSummarySummaryItem["Category"].asString(); - if(!allConversationNodeSummarySummaryItem["SummaryName"].isNull()) - summaryObject.summaryName = allConversationNodeSummarySummaryItem["SummaryName"].asString(); - if(!allConversationNodeSummarySummaryItem["Content"].isNull()) - summaryObject.content = allConversationNodeSummarySummaryItem["Content"].asString(); + if(!valueTasksTaskConversationConversationDetailSummarySummaryItem["Category"].isNull()) + summaryObject.category = valueTasksTaskConversationConversationDetailSummarySummaryItem["Category"].asString(); + if(!valueTasksTaskConversationConversationDetailSummarySummaryItem["SummaryName"].isNull()) + summaryObject.summaryName = valueTasksTaskConversationConversationDetailSummarySummaryItem["SummaryName"].asString(); + if(!valueTasksTaskConversationConversationDetailSummarySummaryItem["Content"].isNull()) + summaryObject.content = valueTasksTaskConversationConversationDetailSummarySummaryItem["Content"].asString(); conversationObject.summary.push_back(summaryObject); } tasksObject.conversation.push_back(conversationObject); diff --git a/ccc/src/model/GetUserByExtensionRequest.cc b/ccc/src/model/GetUserByExtensionRequest.cc new file mode 100644 index 000000000..1983d7e0a --- /dev/null +++ b/ccc/src/model/GetUserByExtensionRequest.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 + +using AlibabaCloud::CCC::Model::GetUserByExtensionRequest; + +GetUserByExtensionRequest::GetUserByExtensionRequest() : + RpcServiceRequest("ccc", "2017-07-05", "GetUserByExtension") +{ + setMethod(HttpRequest::Method::Post); +} + +GetUserByExtensionRequest::~GetUserByExtensionRequest() +{} + +std::string GetUserByExtensionRequest::getExtension()const +{ + return extension_; +} + +void GetUserByExtensionRequest::setExtension(const std::string& extension) +{ + extension_ = extension; + setParameter("Extension", extension); +} + +std::string GetUserByExtensionRequest::getInstanceId()const +{ + return instanceId_; +} + +void GetUserByExtensionRequest::setInstanceId(const std::string& instanceId) +{ + instanceId_ = instanceId; + setParameter("InstanceId", instanceId); +} + diff --git a/ccc/src/model/GetUserByExtensionResult.cc b/ccc/src/model/GetUserByExtensionResult.cc new file mode 100644 index 000000000..0da63669c --- /dev/null +++ b/ccc/src/model/GetUserByExtensionResult.cc @@ -0,0 +1,130 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::CCC; +using namespace AlibabaCloud::CCC::Model; + +GetUserByExtensionResult::GetUserByExtensionResult() : + ServiceResult() +{} + +GetUserByExtensionResult::GetUserByExtensionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetUserByExtensionResult::~GetUserByExtensionResult() +{} + +void GetUserByExtensionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto userNode = value["User"]; + if(!userNode["UserId"].isNull()) + user_.userId = userNode["UserId"].asString(); + if(!userNode["RamId"].isNull()) + user_.ramId = userNode["RamId"].asString(); + if(!userNode["InstanceId"].isNull()) + user_.instanceId = userNode["InstanceId"].asString(); + auto allRolesNode = userNode["Roles"]["Role"]; + for (auto userNodeRolesRole : allRolesNode) + { + User::Role roleObject; + if(!userNodeRolesRole["RoleId"].isNull()) + roleObject.roleId = userNodeRolesRole["RoleId"].asString(); + if(!userNodeRolesRole["InstanceId"].isNull()) + roleObject.instanceId = userNodeRolesRole["InstanceId"].asString(); + if(!userNodeRolesRole["RoleName"].isNull()) + roleObject.roleName = userNodeRolesRole["RoleName"].asString(); + if(!userNodeRolesRole["RoleDescription"].isNull()) + roleObject.roleDescription = userNodeRolesRole["RoleDescription"].asString(); + user_.roles.push_back(roleObject); + } + auto allSkillLevelsNode = userNode["SkillLevels"]["SkillLevel"]; + for (auto userNodeSkillLevelsSkillLevel : allSkillLevelsNode) + { + User::SkillLevel skillLevelObject; + if(!userNodeSkillLevelsSkillLevel["SkillLevelId"].isNull()) + skillLevelObject.skillLevelId = userNodeSkillLevelsSkillLevel["SkillLevelId"].asString(); + if(!userNodeSkillLevelsSkillLevel["Level"].isNull()) + skillLevelObject.level = std::stoi(userNodeSkillLevelsSkillLevel["Level"].asString()); + auto skillNode = value["Skill"]; + if(!skillNode["SkillGroupId"].isNull()) + skillLevelObject.skill.skillGroupId = skillNode["SkillGroupId"].asString(); + if(!skillNode["InstanceId"].isNull()) + skillLevelObject.skill.instanceId = skillNode["InstanceId"].asString(); + if(!skillNode["SkillGroupName"].isNull()) + skillLevelObject.skill.skillGroupName = skillNode["SkillGroupName"].asString(); + if(!skillNode["SkillGroupDescription"].isNull()) + skillLevelObject.skill.skillGroupDescription = skillNode["SkillGroupDescription"].asString(); + user_.skillLevels.push_back(skillLevelObject); + } + auto detailNode = userNode["Detail"]; + if(!detailNode["LoginName"].isNull()) + user_.detail.loginName = detailNode["LoginName"].asString(); + if(!detailNode["DisplayName"].isNull()) + user_.detail.displayName = detailNode["DisplayName"].asString(); + if(!detailNode["Phone"].isNull()) + user_.detail.phone = detailNode["Phone"].asString(); + if(!detailNode["Email"].isNull()) + user_.detail.email = detailNode["Email"].asString(); + if(!detailNode["Department"].isNull()) + user_.detail.department = detailNode["Department"].asString(); + if(!detailNode["Extension"].isNull()) + user_.detail.extension = detailNode["Extension"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["HttpStatusCode"].isNull()) + httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + +} + +GetUserByExtensionResult::User GetUserByExtensionResult::getUser()const +{ + return user_; +} + +std::string GetUserByExtensionResult::getMessage()const +{ + return message_; +} + +int GetUserByExtensionResult::getHttpStatusCode()const +{ + return httpStatusCode_; +} + +std::string GetUserByExtensionResult::getCode()const +{ + return code_; +} + +bool GetUserByExtensionResult::getSuccess()const +{ + return success_; +} + diff --git a/ccc/src/model/ListAgentEventsResult.cc b/ccc/src/model/ListAgentEventsResult.cc index c8d6745e5..740a208fb 100644 --- a/ccc/src/model/ListAgentEventsResult.cc +++ b/ccc/src/model/ListAgentEventsResult.cc @@ -53,14 +53,14 @@ void ListAgentEventsResult::parse(const std::string &payload) agentEventListObject.event = valueAgentEventListAgentEvent["Event"].asString(); if(!valueAgentEventListAgentEvent["EventTime"].isNull()) agentEventListObject.eventTime = std::stol(valueAgentEventListAgentEvent["EventTime"].asString()); - auto allSkillGroupIdsNode = allAgentEventListNode["SkillGroupIds"]["SkillGroup"]; - for (auto allAgentEventListNodeSkillGroupIdsSkillGroup : allSkillGroupIdsNode) + auto allSkillGroupIdsNode = valueAgentEventListAgentEvent["SkillGroupIds"]["SkillGroup"]; + for (auto valueAgentEventListAgentEventSkillGroupIdsSkillGroup : allSkillGroupIdsNode) { AgentEvent::SkillGroup skillGroupIdsObject; - if(!allAgentEventListNodeSkillGroupIdsSkillGroup["SkillGroupId"].isNull()) - skillGroupIdsObject.skillGroupId = allAgentEventListNodeSkillGroupIdsSkillGroup["SkillGroupId"].asString(); - if(!allAgentEventListNodeSkillGroupIdsSkillGroup["SkillGroupName"].isNull()) - skillGroupIdsObject.skillGroupName = allAgentEventListNodeSkillGroupIdsSkillGroup["SkillGroupName"].asString(); + if(!valueAgentEventListAgentEventSkillGroupIdsSkillGroup["SkillGroupId"].isNull()) + skillGroupIdsObject.skillGroupId = valueAgentEventListAgentEventSkillGroupIdsSkillGroup["SkillGroupId"].asString(); + if(!valueAgentEventListAgentEventSkillGroupIdsSkillGroup["SkillGroupName"].isNull()) + skillGroupIdsObject.skillGroupName = valueAgentEventListAgentEventSkillGroupIdsSkillGroup["SkillGroupName"].asString(); agentEventListObject.skillGroupIds.push_back(skillGroupIdsObject); } agentEventList_.push_back(agentEventListObject); diff --git a/ccc/src/model/ListAgentStateLogsRequest.cc b/ccc/src/model/ListAgentStateLogsRequest.cc new file mode 100644 index 000000000..633199aab --- /dev/null +++ b/ccc/src/model/ListAgentStateLogsRequest.cc @@ -0,0 +1,106 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::CCC::Model::ListAgentStateLogsRequest; + +ListAgentStateLogsRequest::ListAgentStateLogsRequest() : + RpcServiceRequest("ccc", "2017-07-05", "ListAgentStateLogs") +{ + setMethod(HttpRequest::Method::Post); +} + +ListAgentStateLogsRequest::~ListAgentStateLogsRequest() +{} + +long ListAgentStateLogsRequest::getEndTime()const +{ + return endTime_; +} + +void ListAgentStateLogsRequest::setEndTime(long endTime) +{ + endTime_ = endTime; + setParameter("EndTime", std::to_string(endTime)); +} + +long ListAgentStateLogsRequest::getStartTime()const +{ + return startTime_; +} + +void ListAgentStateLogsRequest::setStartTime(long startTime) +{ + startTime_ = startTime; + setParameter("StartTime", std::to_string(startTime)); +} + +long ListAgentStateLogsRequest::getRamId()const +{ + return ramId_; +} + +void ListAgentStateLogsRequest::setRamId(long ramId) +{ + ramId_ = ramId; + setParameter("RamId", std::to_string(ramId)); +} + +int ListAgentStateLogsRequest::getPageNumber()const +{ + return pageNumber_; +} + +void ListAgentStateLogsRequest::setPageNumber(int pageNumber) +{ + pageNumber_ = pageNumber; + setParameter("PageNumber", std::to_string(pageNumber)); +} + +std::string ListAgentStateLogsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ListAgentStateLogsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string ListAgentStateLogsRequest::getInstanceId()const +{ + return instanceId_; +} + +void ListAgentStateLogsRequest::setInstanceId(const std::string& instanceId) +{ + instanceId_ = instanceId; + setParameter("InstanceId", instanceId); +} + +int ListAgentStateLogsRequest::getPageSize()const +{ + return pageSize_; +} + +void ListAgentStateLogsRequest::setPageSize(int pageSize) +{ + pageSize_ = pageSize; + setParameter("PageSize", std::to_string(pageSize)); +} + diff --git a/ccc/src/model/ListAgentStateLogsResult.cc b/ccc/src/model/ListAgentStateLogsResult.cc new file mode 100644 index 000000000..d44a8eeb6 --- /dev/null +++ b/ccc/src/model/ListAgentStateLogsResult.cc @@ -0,0 +1,108 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::CCC; +using namespace AlibabaCloud::CCC::Model; + +ListAgentStateLogsResult::ListAgentStateLogsResult() : + ServiceResult() +{} + +ListAgentStateLogsResult::ListAgentStateLogsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAgentStateLogsResult::~ListAgentStateLogsResult() +{} + +void ListAgentStateLogsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto agentStateLogPageNode = value["AgentStateLogPage"]; + if(!agentStateLogPageNode["TotalCount"].isNull()) + agentStateLogPage_.totalCount = std::stoi(agentStateLogPageNode["TotalCount"].asString()); + if(!agentStateLogPageNode["PageNumber"].isNull()) + agentStateLogPage_.pageNumber = std::stoi(agentStateLogPageNode["PageNumber"].asString()); + if(!agentStateLogPageNode["PageSize"].isNull()) + agentStateLogPage_.pageSize = std::stoi(agentStateLogPageNode["PageSize"].asString()); + auto allListNode = agentStateLogPageNode["List"]["AgentStateLog"]; + for (auto agentStateLogPageNodeListAgentStateLog : allListNode) + { + AgentStateLogPage::AgentStateLog agentStateLogObject; + if(!agentStateLogPageNodeListAgentStateLog["InstanceId"].isNull()) + agentStateLogObject.instanceId = agentStateLogPageNodeListAgentStateLog["InstanceId"].asString(); + if(!agentStateLogPageNodeListAgentStateLog["RamId"].isNull()) + agentStateLogObject.ramId = std::stol(agentStateLogPageNodeListAgentStateLog["RamId"].asString()); + if(!agentStateLogPageNodeListAgentStateLog["State"].isNull()) + agentStateLogObject.state = agentStateLogPageNodeListAgentStateLog["State"].asString(); + if(!agentStateLogPageNodeListAgentStateLog["StateCode"].isNull()) + agentStateLogObject.stateCode = agentStateLogPageNodeListAgentStateLog["StateCode"].asString(); + if(!agentStateLogPageNodeListAgentStateLog["StateTime"].isNull()) + agentStateLogObject.stateTime = std::stol(agentStateLogPageNodeListAgentStateLog["StateTime"].asString()); + if(!agentStateLogPageNodeListAgentStateLog["ContactId"].isNull()) + agentStateLogObject.contactId = agentStateLogPageNodeListAgentStateLog["ContactId"].asString(); + if(!agentStateLogPageNodeListAgentStateLog["ConnectId"].isNull()) + agentStateLogObject.connectId = agentStateLogPageNodeListAgentStateLog["ConnectId"].asString(); + if(!agentStateLogPageNodeListAgentStateLog["SkillGroupIds"].isNull()) + agentStateLogObject.skillGroupIds = agentStateLogPageNodeListAgentStateLog["SkillGroupIds"].asString(); + if(!agentStateLogPageNodeListAgentStateLog["CounterParty"].isNull()) + agentStateLogObject.counterParty = agentStateLogPageNodeListAgentStateLog["CounterParty"].asString(); + agentStateLogPage_.list.push_back(agentStateLogObject); + } + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["HttpStatusCode"].isNull()) + httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + +} + +std::string ListAgentStateLogsResult::getMessage()const +{ + return message_; +} + +int ListAgentStateLogsResult::getHttpStatusCode()const +{ + return httpStatusCode_; +} + +std::string ListAgentStateLogsResult::getCode()const +{ + return code_; +} + +ListAgentStateLogsResult::AgentStateLogPage ListAgentStateLogsResult::getAgentStateLogPage()const +{ + return agentStateLogPage_; +} + +bool ListAgentStateLogsResult::getSuccess()const +{ + return success_; +} + diff --git a/ccc/src/model/ListAgentSummaryReportsByIntervalResult.cc b/ccc/src/model/ListAgentSummaryReportsByIntervalResult.cc index 7e94a524a..156a3109f 100644 --- a/ccc/src/model/ListAgentSummaryReportsByIntervalResult.cc +++ b/ccc/src/model/ListAgentSummaryReportsByIntervalResult.cc @@ -52,24 +52,24 @@ void ListAgentSummaryReportsByIntervalResult::parse(const std::string &payload) PagedAgentSummaryReport::AgentTimeIntervalReport agentTimeIntervalReportObject; if(!pagedAgentSummaryReportNodeListAgentTimeIntervalReport["AgentId"].isNull()) agentTimeIntervalReportObject.agentId = pagedAgentSummaryReportNodeListAgentTimeIntervalReport["AgentId"].asString(); - auto allIntervalListNode = allListNode["IntervalList"]["AgentSummaryReport"]; - for (auto allListNodeIntervalListAgentSummaryReport : allIntervalListNode) + auto allIntervalListNode = pagedAgentSummaryReportNodeListAgentTimeIntervalReport["IntervalList"]["AgentSummaryReport"]; + for (auto pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport : allIntervalListNode) { PagedAgentSummaryReport::AgentTimeIntervalReport::AgentSummaryReport intervalListObject; - if(!allListNodeIntervalListAgentSummaryReport["Timestamp"].isNull()) - intervalListObject.timestamp = allListNodeIntervalListAgentSummaryReport["Timestamp"].asString(); - if(!allListNodeIntervalListAgentSummaryReport["InstanceId"].isNull()) - intervalListObject.instanceId = allListNodeIntervalListAgentSummaryReport["InstanceId"].asString(); - if(!allListNodeIntervalListAgentSummaryReport["AgentId"].isNull()) - intervalListObject.agentId = allListNodeIntervalListAgentSummaryReport["AgentId"].asString(); - if(!allListNodeIntervalListAgentSummaryReport["LoginName"].isNull()) - intervalListObject.loginName = allListNodeIntervalListAgentSummaryReport["LoginName"].asString(); - if(!allListNodeIntervalListAgentSummaryReport["AgentName"].isNull()) - intervalListObject.agentName = allListNodeIntervalListAgentSummaryReport["AgentName"].asString(); - if(!allListNodeIntervalListAgentSummaryReport["SkillGroupIds"].isNull()) - intervalListObject.skillGroupIds = allListNodeIntervalListAgentSummaryReport["SkillGroupIds"].asString(); - if(!allListNodeIntervalListAgentSummaryReport["SkillGroupNames"].isNull()) - intervalListObject.skillGroupNames = allListNodeIntervalListAgentSummaryReport["SkillGroupNames"].asString(); + if(!pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["Timestamp"].isNull()) + intervalListObject.timestamp = pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["Timestamp"].asString(); + if(!pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["InstanceId"].isNull()) + intervalListObject.instanceId = pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["InstanceId"].asString(); + if(!pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["AgentId"].isNull()) + intervalListObject.agentId = pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["AgentId"].asString(); + if(!pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["LoginName"].isNull()) + intervalListObject.loginName = pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["LoginName"].asString(); + if(!pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["AgentName"].isNull()) + intervalListObject.agentName = pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["AgentName"].asString(); + if(!pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["SkillGroupIds"].isNull()) + intervalListObject.skillGroupIds = pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["SkillGroupIds"].asString(); + if(!pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["SkillGroupNames"].isNull()) + intervalListObject.skillGroupNames = pagedAgentSummaryReportNodeListAgentTimeIntervalReportIntervalListAgentSummaryReport["SkillGroupNames"].asString(); auto overallNode = value["Overall"]; if(!overallNode["TotalCalls"].isNull()) intervalListObject.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString()); @@ -105,6 +105,10 @@ void ListAgentSummaryReportsByIntervalResult::parse(const std::string &payload) intervalListObject.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].asString()); if(!overallNode["OneTransferCalls"].isNull()) intervalListObject.overall.oneTransferCalls = std::stol(overallNode["OneTransferCalls"].asString()); + if(!overallNode["FirstLogInTime"].isNull()) + intervalListObject.overall.firstLogInTime = overallNode["FirstLogInTime"].asString(); + if(!overallNode["LastLogOutTime"].isNull()) + intervalListObject.overall.lastLogOutTime = overallNode["LastLogOutTime"].asString(); auto inboundNode = value["Inbound"]; if(!inboundNode["CallsOffered"].isNull()) intervalListObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString()); diff --git a/ccc/src/model/ListAgentSummaryReportsResult.cc b/ccc/src/model/ListAgentSummaryReportsResult.cc index 05882c7cd..c1303928f 100644 --- a/ccc/src/model/ListAgentSummaryReportsResult.cc +++ b/ccc/src/model/ListAgentSummaryReportsResult.cc @@ -97,6 +97,10 @@ void ListAgentSummaryReportsResult::parse(const std::string &payload) agentSummaryReportObject.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].asString()); if(!overallNode["OneTransferCalls"].isNull()) agentSummaryReportObject.overall.oneTransferCalls = std::stol(overallNode["OneTransferCalls"].asString()); + if(!overallNode["FirstLogInTime"].isNull()) + agentSummaryReportObject.overall.firstLogInTime = overallNode["FirstLogInTime"].asString(); + if(!overallNode["LastLogOutTime"].isNull()) + agentSummaryReportObject.overall.lastLogOutTime = overallNode["LastLogOutTime"].asString(); auto inboundNode = value["Inbound"]; if(!inboundNode["CallsOffered"].isNull()) agentSummaryReportObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString()); diff --git a/ccc/src/model/ListBasicStatisticsReportSubItemsResult.cc b/ccc/src/model/ListBasicStatisticsReportSubItemsResult.cc index da65edbfb..cff1397b7 100644 --- a/ccc/src/model/ListBasicStatisticsReportSubItemsResult.cc +++ b/ccc/src/model/ListBasicStatisticsReportSubItemsResult.cc @@ -58,14 +58,14 @@ void ListBasicStatisticsReportSubItemsResult::parse(const std::string &payload) basicStatisticsReportSubItemObject.count = std::stoi(subItemsNodeListBasicStatisticsReportSubItem["Count"].asString()); if(!subItemsNodeListBasicStatisticsReportSubItem["Percentage"].isNull()) basicStatisticsReportSubItemObject.percentage = std::stoi(subItemsNodeListBasicStatisticsReportSubItem["Percentage"].asString()); - auto allRowNode = allListNode["Row"]["KeyValuePair"]; - for (auto allListNodeRowKeyValuePair : allRowNode) + auto allRowNode = subItemsNodeListBasicStatisticsReportSubItem["Row"]["KeyValuePair"]; + for (auto subItemsNodeListBasicStatisticsReportSubItemRowKeyValuePair : allRowNode) { SubItems::BasicStatisticsReportSubItem::KeyValuePair rowObject; - if(!allListNodeRowKeyValuePair["Key"].isNull()) - rowObject.key = allListNodeRowKeyValuePair["Key"].asString(); - if(!allListNodeRowKeyValuePair["Value"].isNull()) - rowObject.value = allListNodeRowKeyValuePair["Value"].asString(); + if(!subItemsNodeListBasicStatisticsReportSubItemRowKeyValuePair["Key"].isNull()) + rowObject.key = subItemsNodeListBasicStatisticsReportSubItemRowKeyValuePair["Key"].asString(); + if(!subItemsNodeListBasicStatisticsReportSubItemRowKeyValuePair["Value"].isNull()) + rowObject.value = subItemsNodeListBasicStatisticsReportSubItemRowKeyValuePair["Value"].asString(); basicStatisticsReportSubItemObject.row.push_back(rowObject); } subItems_.list.push_back(basicStatisticsReportSubItemObject); diff --git a/ccc/src/model/ListCallDetailRecordsResult.cc b/ccc/src/model/ListCallDetailRecordsResult.cc index f89260778..68260d322 100644 --- a/ccc/src/model/ListCallDetailRecordsResult.cc +++ b/ccc/src/model/ListCallDetailRecordsResult.cc @@ -78,40 +78,40 @@ void ListCallDetailRecordsResult::parse(const std::string &payload) callDetailRecordObject.instanceId = callDetailRecordsNodeListCallDetailRecord["InstanceId"].asString(); if(!callDetailRecordsNodeListCallDetailRecord["SkillGroupIdList"].isNull()) callDetailRecordObject.skillGroupIdList = callDetailRecordsNodeListCallDetailRecord["SkillGroupIdList"].asString(); - auto allAgentsNode = allListNode["Agents"]["CallDetailAgent"]; - for (auto allListNodeAgentsCallDetailAgent : allAgentsNode) + auto allAgentsNode = callDetailRecordsNodeListCallDetailRecord["Agents"]["CallDetailAgent"]; + for (auto callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent : allAgentsNode) { CallDetailRecords::CallDetailRecord::CallDetailAgent agentsObject; - if(!allListNodeAgentsCallDetailAgent["AgentId"].isNull()) - agentsObject.agentId = allListNodeAgentsCallDetailAgent["AgentId"].asString(); - if(!allListNodeAgentsCallDetailAgent["Satisfaction"].isNull()) - agentsObject.satisfaction = allListNodeAgentsCallDetailAgent["Satisfaction"].asString(); - if(!allListNodeAgentsCallDetailAgent["Feedback"].isNull()) - agentsObject.feedback = allListNodeAgentsCallDetailAgent["Feedback"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["AgentId"].isNull()) + agentsObject.agentId = callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["AgentId"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["Satisfaction"].isNull()) + agentsObject.satisfaction = callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["Satisfaction"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["Feedback"].isNull()) + agentsObject.feedback = callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["Feedback"].asString(); callDetailRecordObject.agents.push_back(agentsObject); } - auto allRecordingsNode = allListNode["Recordings"]["Recording"]; - for (auto allListNodeRecordingsRecording : allRecordingsNode) + auto allRecordingsNode = callDetailRecordsNodeListCallDetailRecord["Recordings"]["Recording"]; + for (auto callDetailRecordsNodeListCallDetailRecordRecordingsRecording : allRecordingsNode) { CallDetailRecords::CallDetailRecord::Recording recordingsObject; - if(!allListNodeRecordingsRecording["ContactId"].isNull()) - recordingsObject.contactId = allListNodeRecordingsRecording["ContactId"].asString(); - if(!allListNodeRecordingsRecording["AgentId"].isNull()) - recordingsObject.agentId = allListNodeRecordingsRecording["AgentId"].asString(); - if(!allListNodeRecordingsRecording["AgentName"].isNull()) - recordingsObject.agentName = allListNodeRecordingsRecording["AgentName"].asString(); - if(!allListNodeRecordingsRecording["StartTime"].isNull()) - recordingsObject.startTime = std::stol(allListNodeRecordingsRecording["StartTime"].asString()); - if(!allListNodeRecordingsRecording["Duration"].isNull()) - recordingsObject.duration = std::stoi(allListNodeRecordingsRecording["Duration"].asString()); - if(!allListNodeRecordingsRecording["FileName"].isNull()) - recordingsObject.fileName = allListNodeRecordingsRecording["FileName"].asString(); - if(!allListNodeRecordingsRecording["FileDescription"].isNull()) - recordingsObject.fileDescription = allListNodeRecordingsRecording["FileDescription"].asString(); - if(!allListNodeRecordingsRecording["QualityCheckTid"].isNull()) - recordingsObject.qualityCheckTid = allListNodeRecordingsRecording["QualityCheckTid"].asString(); - if(!allListNodeRecordingsRecording["QualityCheckTaskId"].isNull()) - recordingsObject.qualityCheckTaskId = allListNodeRecordingsRecording["QualityCheckTaskId"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["ContactId"].isNull()) + recordingsObject.contactId = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["ContactId"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["AgentId"].isNull()) + recordingsObject.agentId = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["AgentId"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["AgentName"].isNull()) + recordingsObject.agentName = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["AgentName"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["StartTime"].isNull()) + recordingsObject.startTime = std::stol(callDetailRecordsNodeListCallDetailRecordRecordingsRecording["StartTime"].asString()); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["Duration"].isNull()) + recordingsObject.duration = std::stoi(callDetailRecordsNodeListCallDetailRecordRecordingsRecording["Duration"].asString()); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["FileName"].isNull()) + recordingsObject.fileName = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["FileName"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["FileDescription"].isNull()) + recordingsObject.fileDescription = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["FileDescription"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["QualityCheckTid"].isNull()) + recordingsObject.qualityCheckTid = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["QualityCheckTid"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["QualityCheckTaskId"].isNull()) + recordingsObject.qualityCheckTaskId = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["QualityCheckTaskId"].asString(); callDetailRecordObject.recordings.push_back(recordingsObject); } callDetailRecords_.list.push_back(callDetailRecordObject); diff --git a/ccc/src/model/ListContactFlowsResult.cc b/ccc/src/model/ListContactFlowsResult.cc index 68fea3888..259a20f4f 100644 --- a/ccc/src/model/ListContactFlowsResult.cc +++ b/ccc/src/model/ListContactFlowsResult.cc @@ -55,48 +55,48 @@ void ListContactFlowsResult::parse(const std::string &payload) contactFlowsObject.type = valueContactFlowsContactFlow["Type"].asString(); if(!valueContactFlowsContactFlow["AppliedVersion"].isNull()) contactFlowsObject.appliedVersion = valueContactFlowsContactFlow["AppliedVersion"].asString(); - auto allVersionsNode = allContactFlowsNode["Versions"]["ContactFlowVersion"]; - for (auto allContactFlowsNodeVersionsContactFlowVersion : allVersionsNode) + auto allVersionsNode = valueContactFlowsContactFlow["Versions"]["ContactFlowVersion"]; + for (auto valueContactFlowsContactFlowVersionsContactFlowVersion : allVersionsNode) { ContactFlow::ContactFlowVersion versionsObject; - if(!allContactFlowsNodeVersionsContactFlowVersion["ContactFlowVersionId"].isNull()) - versionsObject.contactFlowVersionId = allContactFlowsNodeVersionsContactFlowVersion["ContactFlowVersionId"].asString(); - if(!allContactFlowsNodeVersionsContactFlowVersion["Version"].isNull()) - versionsObject.version = allContactFlowsNodeVersionsContactFlowVersion["Version"].asString(); - if(!allContactFlowsNodeVersionsContactFlowVersion["ContactFlowVersionDescription"].isNull()) - versionsObject.contactFlowVersionDescription = allContactFlowsNodeVersionsContactFlowVersion["ContactFlowVersionDescription"].asString(); - if(!allContactFlowsNodeVersionsContactFlowVersion["LastModified"].isNull()) - versionsObject.lastModified = allContactFlowsNodeVersionsContactFlowVersion["LastModified"].asString(); - if(!allContactFlowsNodeVersionsContactFlowVersion["LastModifiedBy"].isNull()) - versionsObject.lastModifiedBy = allContactFlowsNodeVersionsContactFlowVersion["LastModifiedBy"].asString(); - if(!allContactFlowsNodeVersionsContactFlowVersion["LockedBy"].isNull()) - versionsObject.lockedBy = allContactFlowsNodeVersionsContactFlowVersion["LockedBy"].asString(); - if(!allContactFlowsNodeVersionsContactFlowVersion["Status"].isNull()) - versionsObject.status = allContactFlowsNodeVersionsContactFlowVersion["Status"].asString(); + if(!valueContactFlowsContactFlowVersionsContactFlowVersion["ContactFlowVersionId"].isNull()) + versionsObject.contactFlowVersionId = valueContactFlowsContactFlowVersionsContactFlowVersion["ContactFlowVersionId"].asString(); + if(!valueContactFlowsContactFlowVersionsContactFlowVersion["Version"].isNull()) + versionsObject.version = valueContactFlowsContactFlowVersionsContactFlowVersion["Version"].asString(); + if(!valueContactFlowsContactFlowVersionsContactFlowVersion["ContactFlowVersionDescription"].isNull()) + versionsObject.contactFlowVersionDescription = valueContactFlowsContactFlowVersionsContactFlowVersion["ContactFlowVersionDescription"].asString(); + if(!valueContactFlowsContactFlowVersionsContactFlowVersion["LastModified"].isNull()) + versionsObject.lastModified = valueContactFlowsContactFlowVersionsContactFlowVersion["LastModified"].asString(); + if(!valueContactFlowsContactFlowVersionsContactFlowVersion["LastModifiedBy"].isNull()) + versionsObject.lastModifiedBy = valueContactFlowsContactFlowVersionsContactFlowVersion["LastModifiedBy"].asString(); + if(!valueContactFlowsContactFlowVersionsContactFlowVersion["LockedBy"].isNull()) + versionsObject.lockedBy = valueContactFlowsContactFlowVersionsContactFlowVersion["LockedBy"].asString(); + if(!valueContactFlowsContactFlowVersionsContactFlowVersion["Status"].isNull()) + versionsObject.status = valueContactFlowsContactFlowVersionsContactFlowVersion["Status"].asString(); contactFlowsObject.versions.push_back(versionsObject); } - auto allPhoneNumbersNode = allContactFlowsNode["PhoneNumbers"]["PhoneNumber"]; - for (auto allContactFlowsNodePhoneNumbersPhoneNumber : allPhoneNumbersNode) + auto allPhoneNumbersNode = valueContactFlowsContactFlow["PhoneNumbers"]["PhoneNumber"]; + for (auto valueContactFlowsContactFlowPhoneNumbersPhoneNumber : allPhoneNumbersNode) { ContactFlow::PhoneNumber phoneNumbersObject; - if(!allContactFlowsNodePhoneNumbersPhoneNumber["PhoneNumberId"].isNull()) - phoneNumbersObject.phoneNumberId = allContactFlowsNodePhoneNumbersPhoneNumber["PhoneNumberId"].asString(); - if(!allContactFlowsNodePhoneNumbersPhoneNumber["InstanceId"].isNull()) - phoneNumbersObject.instanceId = allContactFlowsNodePhoneNumbersPhoneNumber["InstanceId"].asString(); - if(!allContactFlowsNodePhoneNumbersPhoneNumber["Number"].isNull()) - phoneNumbersObject.number = allContactFlowsNodePhoneNumbersPhoneNumber["Number"].asString(); - if(!allContactFlowsNodePhoneNumbersPhoneNumber["PhoneNumberDescription"].isNull()) - phoneNumbersObject.phoneNumberDescription = allContactFlowsNodePhoneNumbersPhoneNumber["PhoneNumberDescription"].asString(); - if(!allContactFlowsNodePhoneNumbersPhoneNumber["TestOnly"].isNull()) - phoneNumbersObject.testOnly = allContactFlowsNodePhoneNumbersPhoneNumber["TestOnly"].asString() == "true"; - if(!allContactFlowsNodePhoneNumbersPhoneNumber["RemainingTime"].isNull()) - phoneNumbersObject.remainingTime = std::stoi(allContactFlowsNodePhoneNumbersPhoneNumber["RemainingTime"].asString()); - if(!allContactFlowsNodePhoneNumbersPhoneNumber["AllowOutbound"].isNull()) - phoneNumbersObject.allowOutbound = allContactFlowsNodePhoneNumbersPhoneNumber["AllowOutbound"].asString() == "true"; - if(!allContactFlowsNodePhoneNumbersPhoneNumber["Usage"].isNull()) - phoneNumbersObject.usage = allContactFlowsNodePhoneNumbersPhoneNumber["Usage"].asString(); - if(!allContactFlowsNodePhoneNumbersPhoneNumber["Trunks"].isNull()) - phoneNumbersObject.trunks = std::stoi(allContactFlowsNodePhoneNumbersPhoneNumber["Trunks"].asString()); + if(!valueContactFlowsContactFlowPhoneNumbersPhoneNumber["PhoneNumberId"].isNull()) + phoneNumbersObject.phoneNumberId = valueContactFlowsContactFlowPhoneNumbersPhoneNumber["PhoneNumberId"].asString(); + if(!valueContactFlowsContactFlowPhoneNumbersPhoneNumber["InstanceId"].isNull()) + phoneNumbersObject.instanceId = valueContactFlowsContactFlowPhoneNumbersPhoneNumber["InstanceId"].asString(); + if(!valueContactFlowsContactFlowPhoneNumbersPhoneNumber["Number"].isNull()) + phoneNumbersObject.number = valueContactFlowsContactFlowPhoneNumbersPhoneNumber["Number"].asString(); + if(!valueContactFlowsContactFlowPhoneNumbersPhoneNumber["PhoneNumberDescription"].isNull()) + phoneNumbersObject.phoneNumberDescription = valueContactFlowsContactFlowPhoneNumbersPhoneNumber["PhoneNumberDescription"].asString(); + if(!valueContactFlowsContactFlowPhoneNumbersPhoneNumber["TestOnly"].isNull()) + phoneNumbersObject.testOnly = valueContactFlowsContactFlowPhoneNumbersPhoneNumber["TestOnly"].asString() == "true"; + if(!valueContactFlowsContactFlowPhoneNumbersPhoneNumber["RemainingTime"].isNull()) + phoneNumbersObject.remainingTime = std::stoi(valueContactFlowsContactFlowPhoneNumbersPhoneNumber["RemainingTime"].asString()); + if(!valueContactFlowsContactFlowPhoneNumbersPhoneNumber["AllowOutbound"].isNull()) + phoneNumbersObject.allowOutbound = valueContactFlowsContactFlowPhoneNumbersPhoneNumber["AllowOutbound"].asString() == "true"; + if(!valueContactFlowsContactFlowPhoneNumbersPhoneNumber["Usage"].isNull()) + phoneNumbersObject.usage = valueContactFlowsContactFlowPhoneNumbersPhoneNumber["Usage"].asString(); + if(!valueContactFlowsContactFlowPhoneNumbersPhoneNumber["Trunks"].isNull()) + phoneNumbersObject.trunks = std::stoi(valueContactFlowsContactFlowPhoneNumbersPhoneNumber["Trunks"].asString()); contactFlowsObject.phoneNumbers.push_back(phoneNumbersObject); } contactFlows_.push_back(contactFlowsObject); diff --git a/ccc/src/model/ListInstancesOfUserResult.cc b/ccc/src/model/ListInstancesOfUserResult.cc index 34a5ce5bd..8ea209999 100644 --- a/ccc/src/model/ListInstancesOfUserResult.cc +++ b/ccc/src/model/ListInstancesOfUserResult.cc @@ -71,16 +71,16 @@ void ListInstancesOfUserResult::parse(const std::string &payload) instancesObject.createdTime = std::stol(valueInstancesCallCenterInstance["CreatedTime"].asString()); if(!valueInstancesCallCenterInstance["Owner"].isNull()) instancesObject.owner = valueInstancesCallCenterInstance["Owner"].asString(); - auto allAdminNode = allInstancesNode["Admin"]["User"]; - for (auto allInstancesNodeAdminUser : allAdminNode) + auto allAdminNode = valueInstancesCallCenterInstance["Admin"]["User"]; + for (auto valueInstancesCallCenterInstanceAdminUser : allAdminNode) { CallCenterInstance::User adminObject; - if(!allInstancesNodeAdminUser["UserId"].isNull()) - adminObject.userId = allInstancesNodeAdminUser["UserId"].asString(); - if(!allInstancesNodeAdminUser["RamId"].isNull()) - adminObject.ramId = allInstancesNodeAdminUser["RamId"].asString(); - if(!allInstancesNodeAdminUser["InstanceId"].isNull()) - adminObject.instanceId = allInstancesNodeAdminUser["InstanceId"].asString(); + if(!valueInstancesCallCenterInstanceAdminUser["UserId"].isNull()) + adminObject.userId = valueInstancesCallCenterInstanceAdminUser["UserId"].asString(); + if(!valueInstancesCallCenterInstanceAdminUser["RamId"].isNull()) + adminObject.ramId = valueInstancesCallCenterInstanceAdminUser["RamId"].asString(); + if(!valueInstancesCallCenterInstanceAdminUser["InstanceId"].isNull()) + adminObject.instanceId = valueInstancesCallCenterInstanceAdminUser["InstanceId"].asString(); auto detailNode = value["Detail"]; if(!detailNode["LoginName"].isNull()) adminObject.detail.loginName = detailNode["LoginName"].asString(); @@ -94,28 +94,28 @@ void ListInstancesOfUserResult::parse(const std::string &payload) adminObject.detail.department = detailNode["Department"].asString(); instancesObject.admin.push_back(adminObject); } - auto allPhoneNumbersNode = allInstancesNode["PhoneNumbers"]["PhoneNumber"]; - for (auto allInstancesNodePhoneNumbersPhoneNumber : allPhoneNumbersNode) + auto allPhoneNumbersNode = valueInstancesCallCenterInstance["PhoneNumbers"]["PhoneNumber"]; + for (auto valueInstancesCallCenterInstancePhoneNumbersPhoneNumber : allPhoneNumbersNode) { CallCenterInstance::PhoneNumber phoneNumbersObject; - if(!allInstancesNodePhoneNumbersPhoneNumber["PhoneNumberId"].isNull()) - phoneNumbersObject.phoneNumberId = allInstancesNodePhoneNumbersPhoneNumber["PhoneNumberId"].asString(); - if(!allInstancesNodePhoneNumbersPhoneNumber["InstanceId"].isNull()) - phoneNumbersObject.instanceId = allInstancesNodePhoneNumbersPhoneNumber["InstanceId"].asString(); - if(!allInstancesNodePhoneNumbersPhoneNumber["Number"].isNull()) - phoneNumbersObject.number = allInstancesNodePhoneNumbersPhoneNumber["Number"].asString(); - if(!allInstancesNodePhoneNumbersPhoneNumber["PhoneNumberDescription"].isNull()) - phoneNumbersObject.phoneNumberDescription = allInstancesNodePhoneNumbersPhoneNumber["PhoneNumberDescription"].asString(); - if(!allInstancesNodePhoneNumbersPhoneNumber["TestOnly"].isNull()) - phoneNumbersObject.testOnly = allInstancesNodePhoneNumbersPhoneNumber["TestOnly"].asString() == "true"; - if(!allInstancesNodePhoneNumbersPhoneNumber["RemainingTime"].isNull()) - phoneNumbersObject.remainingTime = std::stoi(allInstancesNodePhoneNumbersPhoneNumber["RemainingTime"].asString()); - if(!allInstancesNodePhoneNumbersPhoneNumber["AllowOutbound"].isNull()) - phoneNumbersObject.allowOutbound = allInstancesNodePhoneNumbersPhoneNumber["AllowOutbound"].asString() == "true"; - if(!allInstancesNodePhoneNumbersPhoneNumber["Usage"].isNull()) - phoneNumbersObject.usage = allInstancesNodePhoneNumbersPhoneNumber["Usage"].asString(); - if(!allInstancesNodePhoneNumbersPhoneNumber["Trunks"].isNull()) - phoneNumbersObject.trunks = std::stoi(allInstancesNodePhoneNumbersPhoneNumber["Trunks"].asString()); + if(!valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["PhoneNumberId"].isNull()) + phoneNumbersObject.phoneNumberId = valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["PhoneNumberId"].asString(); + if(!valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["InstanceId"].isNull()) + phoneNumbersObject.instanceId = valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["InstanceId"].asString(); + if(!valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["Number"].isNull()) + phoneNumbersObject.number = valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["Number"].asString(); + if(!valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["PhoneNumberDescription"].isNull()) + phoneNumbersObject.phoneNumberDescription = valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["PhoneNumberDescription"].asString(); + if(!valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["TestOnly"].isNull()) + phoneNumbersObject.testOnly = valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["TestOnly"].asString() == "true"; + if(!valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["RemainingTime"].isNull()) + phoneNumbersObject.remainingTime = std::stoi(valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["RemainingTime"].asString()); + if(!valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["AllowOutbound"].isNull()) + phoneNumbersObject.allowOutbound = valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["AllowOutbound"].asString() == "true"; + if(!valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["Usage"].isNull()) + phoneNumbersObject.usage = valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["Usage"].asString(); + if(!valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["Trunks"].isNull()) + phoneNumbersObject.trunks = std::stoi(valueInstancesCallCenterInstancePhoneNumbersPhoneNumber["Trunks"].asString()); instancesObject.phoneNumbers.push_back(phoneNumbersObject); } instances_.push_back(instancesObject); diff --git a/ccc/src/model/ListJobStatusResult.cc b/ccc/src/model/ListJobStatusResult.cc index 4f7fd6708..5c1d979a1 100644 --- a/ccc/src/model/ListJobStatusResult.cc +++ b/ccc/src/model/ListJobStatusResult.cc @@ -66,66 +66,66 @@ void ListJobStatusResult::parse(const std::string &payload) jobObject.referenceId = jobsNodeListJob["ReferenceId"].asString(); if(!jobsNodeListJob["FailureReason"].isNull()) jobObject.failureReason = jobsNodeListJob["FailureReason"].asString(); - auto allContactsNode = allListNode["Contacts"]["Contact"]; - for (auto allListNodeContactsContact : allContactsNode) + auto allContactsNode = jobsNodeListJob["Contacts"]["Contact"]; + for (auto jobsNodeListJobContactsContact : allContactsNode) { Jobs::Job::Contact contactsObject; - if(!allListNodeContactsContact["ContactId"].isNull()) - contactsObject.contactId = allListNodeContactsContact["ContactId"].asString(); - if(!allListNodeContactsContact["ContactName"].isNull()) - contactsObject.contactName = allListNodeContactsContact["ContactName"].asString(); - if(!allListNodeContactsContact["Honorific"].isNull()) - contactsObject.honorific = allListNodeContactsContact["Honorific"].asString(); - if(!allListNodeContactsContact["Role"].isNull()) - contactsObject.role = allListNodeContactsContact["Role"].asString(); - if(!allListNodeContactsContact["PhoneNumber"].isNull()) - contactsObject.phoneNumber = allListNodeContactsContact["PhoneNumber"].asString(); - if(!allListNodeContactsContact["State"].isNull()) - contactsObject.state = allListNodeContactsContact["State"].asString(); - if(!allListNodeContactsContact["ReferenceId"].isNull()) - contactsObject.referenceId = allListNodeContactsContact["ReferenceId"].asString(); - if(!allListNodeContactsContact["JobId"].isNull()) - contactsObject.jobId = allListNodeContactsContact["JobId"].asString(); + if(!jobsNodeListJobContactsContact["ContactId"].isNull()) + contactsObject.contactId = jobsNodeListJobContactsContact["ContactId"].asString(); + if(!jobsNodeListJobContactsContact["ContactName"].isNull()) + contactsObject.contactName = jobsNodeListJobContactsContact["ContactName"].asString(); + if(!jobsNodeListJobContactsContact["Honorific"].isNull()) + contactsObject.honorific = jobsNodeListJobContactsContact["Honorific"].asString(); + if(!jobsNodeListJobContactsContact["Role"].isNull()) + contactsObject.role = jobsNodeListJobContactsContact["Role"].asString(); + if(!jobsNodeListJobContactsContact["PhoneNumber"].isNull()) + contactsObject.phoneNumber = jobsNodeListJobContactsContact["PhoneNumber"].asString(); + if(!jobsNodeListJobContactsContact["State"].isNull()) + contactsObject.state = jobsNodeListJobContactsContact["State"].asString(); + if(!jobsNodeListJobContactsContact["ReferenceId"].isNull()) + contactsObject.referenceId = jobsNodeListJobContactsContact["ReferenceId"].asString(); + if(!jobsNodeListJobContactsContact["JobId"].isNull()) + contactsObject.jobId = jobsNodeListJobContactsContact["JobId"].asString(); jobObject.contacts.push_back(contactsObject); } - auto allExtrasNode = allListNode["Extras"]["KeyValuePair"]; - for (auto allListNodeExtrasKeyValuePair : allExtrasNode) + auto allExtrasNode = jobsNodeListJob["Extras"]["KeyValuePair"]; + for (auto jobsNodeListJobExtrasKeyValuePair : allExtrasNode) { Jobs::Job::KeyValuePair extrasObject; - if(!allListNodeExtrasKeyValuePair["Key"].isNull()) - extrasObject.key = allListNodeExtrasKeyValuePair["Key"].asString(); - if(!allListNodeExtrasKeyValuePair["Value"].isNull()) - extrasObject.value = allListNodeExtrasKeyValuePair["Value"].asString(); + if(!jobsNodeListJobExtrasKeyValuePair["Key"].isNull()) + extrasObject.key = jobsNodeListJobExtrasKeyValuePair["Key"].asString(); + if(!jobsNodeListJobExtrasKeyValuePair["Value"].isNull()) + extrasObject.value = jobsNodeListJobExtrasKeyValuePair["Value"].asString(); jobObject.extras.push_back(extrasObject); } - auto allTasksNode = allListNode["Tasks"]["Task"]; - for (auto allListNodeTasksTask : allTasksNode) + auto allTasksNode = jobsNodeListJob["Tasks"]["Task"]; + for (auto jobsNodeListJobTasksTask : allTasksNode) { Jobs::Job::Task tasksObject; - if(!allListNodeTasksTask["TaskId"].isNull()) - tasksObject.taskId = allListNodeTasksTask["TaskId"].asString(); - if(!allListNodeTasksTask["JobId"].isNull()) - tasksObject.jobId = allListNodeTasksTask["JobId"].asString(); - if(!allListNodeTasksTask["ScenarioId"].isNull()) - tasksObject.scenarioId = allListNodeTasksTask["ScenarioId"].asString(); - if(!allListNodeTasksTask["ChatbotId"].isNull()) - tasksObject.chatbotId = allListNodeTasksTask["ChatbotId"].asString(); - if(!allListNodeTasksTask["PlanedTime"].isNull()) - tasksObject.planedTime = std::stol(allListNodeTasksTask["PlanedTime"].asString()); - if(!allListNodeTasksTask["ActualTime"].isNull()) - tasksObject.actualTime = std::stol(allListNodeTasksTask["ActualTime"].asString()); - if(!allListNodeTasksTask["CallingNumber"].isNull()) - tasksObject.callingNumber = allListNodeTasksTask["CallingNumber"].asString(); - if(!allListNodeTasksTask["CalledNumber"].isNull()) - tasksObject.calledNumber = allListNodeTasksTask["CalledNumber"].asString(); - if(!allListNodeTasksTask["CallId"].isNull()) - tasksObject.callId = allListNodeTasksTask["CallId"].asString(); - if(!allListNodeTasksTask["Status"].isNull()) - tasksObject.status = allListNodeTasksTask["Status"].asString(); - if(!allListNodeTasksTask["Brief"].isNull()) - tasksObject.brief = allListNodeTasksTask["Brief"].asString(); - if(!allListNodeTasksTask["Duration"].isNull()) - tasksObject.duration = std::stoi(allListNodeTasksTask["Duration"].asString()); + if(!jobsNodeListJobTasksTask["TaskId"].isNull()) + tasksObject.taskId = jobsNodeListJobTasksTask["TaskId"].asString(); + if(!jobsNodeListJobTasksTask["JobId"].isNull()) + tasksObject.jobId = jobsNodeListJobTasksTask["JobId"].asString(); + if(!jobsNodeListJobTasksTask["ScenarioId"].isNull()) + tasksObject.scenarioId = jobsNodeListJobTasksTask["ScenarioId"].asString(); + if(!jobsNodeListJobTasksTask["ChatbotId"].isNull()) + tasksObject.chatbotId = jobsNodeListJobTasksTask["ChatbotId"].asString(); + if(!jobsNodeListJobTasksTask["PlanedTime"].isNull()) + tasksObject.planedTime = std::stol(jobsNodeListJobTasksTask["PlanedTime"].asString()); + if(!jobsNodeListJobTasksTask["ActualTime"].isNull()) + tasksObject.actualTime = std::stol(jobsNodeListJobTasksTask["ActualTime"].asString()); + if(!jobsNodeListJobTasksTask["CallingNumber"].isNull()) + tasksObject.callingNumber = jobsNodeListJobTasksTask["CallingNumber"].asString(); + if(!jobsNodeListJobTasksTask["CalledNumber"].isNull()) + tasksObject.calledNumber = jobsNodeListJobTasksTask["CalledNumber"].asString(); + if(!jobsNodeListJobTasksTask["CallId"].isNull()) + tasksObject.callId = jobsNodeListJobTasksTask["CallId"].asString(); + if(!jobsNodeListJobTasksTask["Status"].isNull()) + tasksObject.status = jobsNodeListJobTasksTask["Status"].asString(); + if(!jobsNodeListJobTasksTask["Brief"].isNull()) + tasksObject.brief = jobsNodeListJobTasksTask["Brief"].asString(); + if(!jobsNodeListJobTasksTask["Duration"].isNull()) + tasksObject.duration = std::stoi(jobsNodeListJobTasksTask["Duration"].asString()); auto contact1Node = value["Contact"]; if(!contact1Node["ContactId"].isNull()) tasksObject.contact1.contactId = contact1Node["ContactId"].asString(); @@ -145,26 +145,26 @@ void ListJobStatusResult::parse(const std::string &payload) tasksObject.contact1.jobId = contact1Node["JobId"].asString(); jobObject.tasks.push_back(tasksObject); } - auto allSummaryNode = allListNode["Summary"]["SummaryItem"]; - for (auto allListNodeSummarySummaryItem : allSummaryNode) + auto allSummaryNode = jobsNodeListJob["Summary"]["SummaryItem"]; + for (auto jobsNodeListJobSummarySummaryItem : allSummaryNode) { Jobs::Job::SummaryItem summaryObject; - if(!allListNodeSummarySummaryItem["SummaryId"].isNull()) - summaryObject.summaryId = allListNodeSummarySummaryItem["SummaryId"].asString(); - if(!allListNodeSummarySummaryItem["GroupId"].isNull()) - summaryObject.groupId = allListNodeSummarySummaryItem["GroupId"].asString(); - if(!allListNodeSummarySummaryItem["JobId"].isNull()) - summaryObject.jobId = allListNodeSummarySummaryItem["JobId"].asString(); - if(!allListNodeSummarySummaryItem["TaskId"].isNull()) - summaryObject.taskId = allListNodeSummarySummaryItem["TaskId"].asString(); - if(!allListNodeSummarySummaryItem["ConversationDetailId"].isNull()) - summaryObject.conversationDetailId = allListNodeSummarySummaryItem["ConversationDetailId"].asString(); - if(!allListNodeSummarySummaryItem["Category"].isNull()) - summaryObject.category = allListNodeSummarySummaryItem["Category"].asString(); - if(!allListNodeSummarySummaryItem["SummaryName"].isNull()) - summaryObject.summaryName = allListNodeSummarySummaryItem["SummaryName"].asString(); - if(!allListNodeSummarySummaryItem["Content"].isNull()) - summaryObject.content = allListNodeSummarySummaryItem["Content"].asString(); + if(!jobsNodeListJobSummarySummaryItem["SummaryId"].isNull()) + summaryObject.summaryId = jobsNodeListJobSummarySummaryItem["SummaryId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["GroupId"].isNull()) + summaryObject.groupId = jobsNodeListJobSummarySummaryItem["GroupId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["JobId"].isNull()) + summaryObject.jobId = jobsNodeListJobSummarySummaryItem["JobId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["TaskId"].isNull()) + summaryObject.taskId = jobsNodeListJobSummarySummaryItem["TaskId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["ConversationDetailId"].isNull()) + summaryObject.conversationDetailId = jobsNodeListJobSummarySummaryItem["ConversationDetailId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["Category"].isNull()) + summaryObject.category = jobsNodeListJobSummarySummaryItem["Category"].asString(); + if(!jobsNodeListJobSummarySummaryItem["SummaryName"].isNull()) + summaryObject.summaryName = jobsNodeListJobSummarySummaryItem["SummaryName"].asString(); + if(!jobsNodeListJobSummarySummaryItem["Content"].isNull()) + summaryObject.content = jobsNodeListJobSummarySummaryItem["Content"].asString(); jobObject.summary.push_back(summaryObject); } auto allCallingNumbers = value["CallingNumbers"]["String"]; diff --git a/ccc/src/model/ListJobsByGroupResult.cc b/ccc/src/model/ListJobsByGroupResult.cc index b562017e8..18f2aee45 100644 --- a/ccc/src/model/ListJobsByGroupResult.cc +++ b/ccc/src/model/ListJobsByGroupResult.cc @@ -68,58 +68,58 @@ void ListJobsByGroupResult::parse(const std::string &payload) jobObject.referenceId = jobsNodeListJob["ReferenceId"].asString(); if(!jobsNodeListJob["FailureReason"].isNull()) jobObject.failureReason = jobsNodeListJob["FailureReason"].asString(); - auto allContactsNode = allListNode["Contacts"]["Contact"]; - for (auto allListNodeContactsContact : allContactsNode) + auto allContactsNode = jobsNodeListJob["Contacts"]["Contact"]; + for (auto jobsNodeListJobContactsContact : allContactsNode) { Jobs::Job::Contact contactsObject; - if(!allListNodeContactsContact["ContactId"].isNull()) - contactsObject.contactId = allListNodeContactsContact["ContactId"].asString(); - if(!allListNodeContactsContact["ContactName"].isNull()) - contactsObject.contactName = allListNodeContactsContact["ContactName"].asString(); - if(!allListNodeContactsContact["Honorific"].isNull()) - contactsObject.honorific = allListNodeContactsContact["Honorific"].asString(); - if(!allListNodeContactsContact["Role"].isNull()) - contactsObject.role = allListNodeContactsContact["Role"].asString(); - if(!allListNodeContactsContact["PhoneNumber"].isNull()) - contactsObject.phoneNumber = allListNodeContactsContact["PhoneNumber"].asString(); - if(!allListNodeContactsContact["State"].isNull()) - contactsObject.state = allListNodeContactsContact["State"].asString(); - if(!allListNodeContactsContact["ReferenceId"].isNull()) - contactsObject.referenceId = allListNodeContactsContact["ReferenceId"].asString(); - if(!allListNodeContactsContact["JobId"].isNull()) - contactsObject.jobId = allListNodeContactsContact["JobId"].asString(); + if(!jobsNodeListJobContactsContact["ContactId"].isNull()) + contactsObject.contactId = jobsNodeListJobContactsContact["ContactId"].asString(); + if(!jobsNodeListJobContactsContact["ContactName"].isNull()) + contactsObject.contactName = jobsNodeListJobContactsContact["ContactName"].asString(); + if(!jobsNodeListJobContactsContact["Honorific"].isNull()) + contactsObject.honorific = jobsNodeListJobContactsContact["Honorific"].asString(); + if(!jobsNodeListJobContactsContact["Role"].isNull()) + contactsObject.role = jobsNodeListJobContactsContact["Role"].asString(); + if(!jobsNodeListJobContactsContact["PhoneNumber"].isNull()) + contactsObject.phoneNumber = jobsNodeListJobContactsContact["PhoneNumber"].asString(); + if(!jobsNodeListJobContactsContact["State"].isNull()) + contactsObject.state = jobsNodeListJobContactsContact["State"].asString(); + if(!jobsNodeListJobContactsContact["ReferenceId"].isNull()) + contactsObject.referenceId = jobsNodeListJobContactsContact["ReferenceId"].asString(); + if(!jobsNodeListJobContactsContact["JobId"].isNull()) + contactsObject.jobId = jobsNodeListJobContactsContact["JobId"].asString(); jobObject.contacts.push_back(contactsObject); } - auto allExtrasNode = allListNode["Extras"]["KeyValuePair"]; - for (auto allListNodeExtrasKeyValuePair : allExtrasNode) + auto allExtrasNode = jobsNodeListJob["Extras"]["KeyValuePair"]; + for (auto jobsNodeListJobExtrasKeyValuePair : allExtrasNode) { Jobs::Job::KeyValuePair extrasObject; - if(!allListNodeExtrasKeyValuePair["Key"].isNull()) - extrasObject.key = allListNodeExtrasKeyValuePair["Key"].asString(); - if(!allListNodeExtrasKeyValuePair["Value"].isNull()) - extrasObject.value = allListNodeExtrasKeyValuePair["Value"].asString(); + if(!jobsNodeListJobExtrasKeyValuePair["Key"].isNull()) + extrasObject.key = jobsNodeListJobExtrasKeyValuePair["Key"].asString(); + if(!jobsNodeListJobExtrasKeyValuePair["Value"].isNull()) + extrasObject.value = jobsNodeListJobExtrasKeyValuePair["Value"].asString(); jobObject.extras.push_back(extrasObject); } - auto allSummaryNode = allListNode["Summary"]["SummaryItem"]; - for (auto allListNodeSummarySummaryItem : allSummaryNode) + auto allSummaryNode = jobsNodeListJob["Summary"]["SummaryItem"]; + for (auto jobsNodeListJobSummarySummaryItem : allSummaryNode) { Jobs::Job::SummaryItem summaryObject; - if(!allListNodeSummarySummaryItem["SummaryId"].isNull()) - summaryObject.summaryId = allListNodeSummarySummaryItem["SummaryId"].asString(); - if(!allListNodeSummarySummaryItem["GroupId"].isNull()) - summaryObject.groupId = allListNodeSummarySummaryItem["GroupId"].asString(); - if(!allListNodeSummarySummaryItem["JobId"].isNull()) - summaryObject.jobId = allListNodeSummarySummaryItem["JobId"].asString(); - if(!allListNodeSummarySummaryItem["TaskId"].isNull()) - summaryObject.taskId = allListNodeSummarySummaryItem["TaskId"].asString(); - if(!allListNodeSummarySummaryItem["ConversationDetailId"].isNull()) - summaryObject.conversationDetailId = allListNodeSummarySummaryItem["ConversationDetailId"].asString(); - if(!allListNodeSummarySummaryItem["Category"].isNull()) - summaryObject.category = allListNodeSummarySummaryItem["Category"].asString(); - if(!allListNodeSummarySummaryItem["SummaryName"].isNull()) - summaryObject.summaryName = allListNodeSummarySummaryItem["SummaryName"].asString(); - if(!allListNodeSummarySummaryItem["Content"].isNull()) - summaryObject.content = allListNodeSummarySummaryItem["Content"].asString(); + if(!jobsNodeListJobSummarySummaryItem["SummaryId"].isNull()) + summaryObject.summaryId = jobsNodeListJobSummarySummaryItem["SummaryId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["GroupId"].isNull()) + summaryObject.groupId = jobsNodeListJobSummarySummaryItem["GroupId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["JobId"].isNull()) + summaryObject.jobId = jobsNodeListJobSummarySummaryItem["JobId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["TaskId"].isNull()) + summaryObject.taskId = jobsNodeListJobSummarySummaryItem["TaskId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["ConversationDetailId"].isNull()) + summaryObject.conversationDetailId = jobsNodeListJobSummarySummaryItem["ConversationDetailId"].asString(); + if(!jobsNodeListJobSummarySummaryItem["Category"].isNull()) + summaryObject.category = jobsNodeListJobSummarySummaryItem["Category"].asString(); + if(!jobsNodeListJobSummarySummaryItem["SummaryName"].isNull()) + summaryObject.summaryName = jobsNodeListJobSummarySummaryItem["SummaryName"].asString(); + if(!jobsNodeListJobSummarySummaryItem["Content"].isNull()) + summaryObject.content = jobsNodeListJobSummarySummaryItem["Content"].asString(); jobObject.summary.push_back(summaryObject); } auto allCallingNumbers = value["CallingNumbers"]["String"]; diff --git a/ccc/src/model/ListPhoneNumbersResult.cc b/ccc/src/model/ListPhoneNumbersResult.cc index c2db7e87e..5c9775a47 100644 --- a/ccc/src/model/ListPhoneNumbersResult.cc +++ b/ccc/src/model/ListPhoneNumbersResult.cc @@ -71,14 +71,14 @@ void ListPhoneNumbersResult::parse(const std::string &payload) phoneNumbersObject.numberCommodityStatus = std::stoi(valuePhoneNumbersPhoneNumber["NumberCommodityStatus"].asString()); if(!valuePhoneNumbersPhoneNumber["SipTelX"].isNull()) phoneNumbersObject.sipTelX = valuePhoneNumbersPhoneNumber["SipTelX"].asString(); - auto allSkillGroupsNode = allPhoneNumbersNode["SkillGroups"]["SkillGroup"]; - for (auto allPhoneNumbersNodeSkillGroupsSkillGroup : allSkillGroupsNode) + auto allSkillGroupsNode = valuePhoneNumbersPhoneNumber["SkillGroups"]["SkillGroup"]; + for (auto valuePhoneNumbersPhoneNumberSkillGroupsSkillGroup : allSkillGroupsNode) { PhoneNumber::SkillGroup skillGroupsObject; - if(!allPhoneNumbersNodeSkillGroupsSkillGroup["SkillGroupId"].isNull()) - skillGroupsObject.skillGroupId = allPhoneNumbersNodeSkillGroupsSkillGroup["SkillGroupId"].asString(); - if(!allPhoneNumbersNodeSkillGroupsSkillGroup["SkillGroupName"].isNull()) - skillGroupsObject.skillGroupName = allPhoneNumbersNodeSkillGroupsSkillGroup["SkillGroupName"].asString(); + if(!valuePhoneNumbersPhoneNumberSkillGroupsSkillGroup["SkillGroupId"].isNull()) + skillGroupsObject.skillGroupId = valuePhoneNumbersPhoneNumberSkillGroupsSkillGroup["SkillGroupId"].asString(); + if(!valuePhoneNumbersPhoneNumberSkillGroupsSkillGroup["SkillGroupName"].isNull()) + skillGroupsObject.skillGroupName = valuePhoneNumbersPhoneNumberSkillGroupsSkillGroup["SkillGroupName"].asString(); phoneNumbersObject.skillGroups.push_back(skillGroupsObject); } auto contactFlowNode = value["ContactFlow"]; diff --git a/ccc/src/model/ListRealTimeAgentResult.cc b/ccc/src/model/ListRealTimeAgentResult.cc index d49dbf34d..49206fb15 100644 --- a/ccc/src/model/ListRealTimeAgentResult.cc +++ b/ccc/src/model/ListRealTimeAgentResult.cc @@ -55,14 +55,14 @@ void ListRealTimeAgentResult::parse(const std::string &payload) dataObject.state = valueDataUser["State"].asString(); if(!valueDataUser["StateDesc"].isNull()) dataObject.stateDesc = valueDataUser["StateDesc"].asString(); - auto allSkillLevelsNode = allDataNode["SkillLevels"]["SkillLevel"]; - for (auto allDataNodeSkillLevelsSkillLevel : allSkillLevelsNode) + auto allSkillLevelsNode = valueDataUser["SkillLevels"]["SkillLevel"]; + for (auto valueDataUserSkillLevelsSkillLevel : allSkillLevelsNode) { User::SkillLevel skillLevelsObject; - if(!allDataNodeSkillLevelsSkillLevel["SkillLevelId"].isNull()) - skillLevelsObject.skillLevelId = allDataNodeSkillLevelsSkillLevel["SkillLevelId"].asString(); - if(!allDataNodeSkillLevelsSkillLevel["Level"].isNull()) - skillLevelsObject.level = std::stoi(allDataNodeSkillLevelsSkillLevel["Level"].asString()); + if(!valueDataUserSkillLevelsSkillLevel["SkillLevelId"].isNull()) + skillLevelsObject.skillLevelId = valueDataUserSkillLevelsSkillLevel["SkillLevelId"].asString(); + if(!valueDataUserSkillLevelsSkillLevel["Level"].isNull()) + skillLevelsObject.level = std::stoi(valueDataUserSkillLevelsSkillLevel["Level"].asString()); auto skillNode = value["Skill"]; if(!skillNode["SkillGroupId"].isNull()) skillLevelsObject.skill.skillGroupId = skillNode["SkillGroupId"].asString(); diff --git a/ccc/src/model/ListRecentCallRecordsResult.cc b/ccc/src/model/ListRecentCallRecordsResult.cc index 3b3a58e85..097f31937 100644 --- a/ccc/src/model/ListRecentCallRecordsResult.cc +++ b/ccc/src/model/ListRecentCallRecordsResult.cc @@ -80,66 +80,66 @@ void ListRecentCallRecordsResult::parse(const std::string &payload) callDetailRecordObject.satisfactionDesc = callDetailRecordsNodeListCallDetailRecord["SatisfactionDesc"].asString(); if(!callDetailRecordsNodeListCallDetailRecord["Feedback"].isNull()) callDetailRecordObject.feedback = callDetailRecordsNodeListCallDetailRecord["Feedback"].asString(); - auto allAgentsNode = allListNode["Agents"]["CallDetailAgent"]; - for (auto allListNodeAgentsCallDetailAgent : allAgentsNode) + auto allAgentsNode = callDetailRecordsNodeListCallDetailRecord["Agents"]["CallDetailAgent"]; + for (auto callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent : allAgentsNode) { CallDetailRecords::CallDetailRecord::CallDetailAgent agentsObject; - if(!allListNodeAgentsCallDetailAgent["ContactId"].isNull()) - agentsObject.contactId = allListNodeAgentsCallDetailAgent["ContactId"].asString(); - if(!allListNodeAgentsCallDetailAgent["AgentId"].isNull()) - agentsObject.agentId = allListNodeAgentsCallDetailAgent["AgentId"].asString(); - if(!allListNodeAgentsCallDetailAgent["AgentName"].isNull()) - agentsObject.agentName = allListNodeAgentsCallDetailAgent["AgentName"].asString(); - if(!allListNodeAgentsCallDetailAgent["SkillGroupName"].isNull()) - agentsObject.skillGroupName = allListNodeAgentsCallDetailAgent["SkillGroupName"].asString(); - if(!allListNodeAgentsCallDetailAgent["QueueTime"].isNull()) - agentsObject.queueTime = std::stoi(allListNodeAgentsCallDetailAgent["QueueTime"].asString()); - if(!allListNodeAgentsCallDetailAgent["RingTime"].isNull()) - agentsObject.ringTime = std::stoi(allListNodeAgentsCallDetailAgent["RingTime"].asString()); - if(!allListNodeAgentsCallDetailAgent["StartTime"].isNull()) - agentsObject.startTime = std::stol(allListNodeAgentsCallDetailAgent["StartTime"].asString()); - if(!allListNodeAgentsCallDetailAgent["TalkTime"].isNull()) - agentsObject.talkTime = std::stoi(allListNodeAgentsCallDetailAgent["TalkTime"].asString()); - if(!allListNodeAgentsCallDetailAgent["HoldTime"].isNull()) - agentsObject.holdTime = std::stoi(allListNodeAgentsCallDetailAgent["HoldTime"].asString()); - if(!allListNodeAgentsCallDetailAgent["WorkTime"].isNull()) - agentsObject.workTime = std::stoi(allListNodeAgentsCallDetailAgent["WorkTime"].asString()); - if(!allListNodeAgentsCallDetailAgent["Satisfaction"].isNull()) - agentsObject.satisfaction = allListNodeAgentsCallDetailAgent["Satisfaction"].asString(); - if(!allListNodeAgentsCallDetailAgent["Feedback"].isNull()) - agentsObject.feedback = allListNodeAgentsCallDetailAgent["Feedback"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["ContactId"].isNull()) + agentsObject.contactId = callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["ContactId"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["AgentId"].isNull()) + agentsObject.agentId = callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["AgentId"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["AgentName"].isNull()) + agentsObject.agentName = callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["AgentName"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["SkillGroupName"].isNull()) + agentsObject.skillGroupName = callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["SkillGroupName"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["QueueTime"].isNull()) + agentsObject.queueTime = std::stoi(callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["QueueTime"].asString()); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["RingTime"].isNull()) + agentsObject.ringTime = std::stoi(callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["RingTime"].asString()); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["StartTime"].isNull()) + agentsObject.startTime = std::stol(callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["StartTime"].asString()); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["TalkTime"].isNull()) + agentsObject.talkTime = std::stoi(callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["TalkTime"].asString()); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["HoldTime"].isNull()) + agentsObject.holdTime = std::stoi(callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["HoldTime"].asString()); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["WorkTime"].isNull()) + agentsObject.workTime = std::stoi(callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["WorkTime"].asString()); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["Satisfaction"].isNull()) + agentsObject.satisfaction = callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["Satisfaction"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["Feedback"].isNull()) + agentsObject.feedback = callDetailRecordsNodeListCallDetailRecordAgentsCallDetailAgent["Feedback"].asString(); callDetailRecordObject.agents.push_back(agentsObject); } - auto allRecordingsNode = allListNode["Recordings"]["Recording"]; - for (auto allListNodeRecordingsRecording : allRecordingsNode) + auto allRecordingsNode = callDetailRecordsNodeListCallDetailRecord["Recordings"]["Recording"]; + for (auto callDetailRecordsNodeListCallDetailRecordRecordingsRecording : allRecordingsNode) { CallDetailRecords::CallDetailRecord::Recording recordingsObject; - if(!allListNodeRecordingsRecording["ContactId"].isNull()) - recordingsObject.contactId = allListNodeRecordingsRecording["ContactId"].asString(); - if(!allListNodeRecordingsRecording["ContactType"].isNull()) - recordingsObject.contactType = allListNodeRecordingsRecording["ContactType"].asString(); - if(!allListNodeRecordingsRecording["AgentId"].isNull()) - recordingsObject.agentId = allListNodeRecordingsRecording["AgentId"].asString(); - if(!allListNodeRecordingsRecording["AgentName"].isNull()) - recordingsObject.agentName = allListNodeRecordingsRecording["AgentName"].asString(); - if(!allListNodeRecordingsRecording["CallingNumber"].isNull()) - recordingsObject.callingNumber = allListNodeRecordingsRecording["CallingNumber"].asString(); - if(!allListNodeRecordingsRecording["CalledNumber"].isNull()) - recordingsObject.calledNumber = allListNodeRecordingsRecording["CalledNumber"].asString(); - if(!allListNodeRecordingsRecording["StartTime"].isNull()) - recordingsObject.startTime = std::stol(allListNodeRecordingsRecording["StartTime"].asString()); - if(!allListNodeRecordingsRecording["Duration"].isNull()) - recordingsObject.duration = std::stoi(allListNodeRecordingsRecording["Duration"].asString()); - if(!allListNodeRecordingsRecording["FileName"].isNull()) - recordingsObject.fileName = allListNodeRecordingsRecording["FileName"].asString(); - if(!allListNodeRecordingsRecording["FilePath"].isNull()) - recordingsObject.filePath = allListNodeRecordingsRecording["FilePath"].asString(); - if(!allListNodeRecordingsRecording["FileDescription"].isNull()) - recordingsObject.fileDescription = allListNodeRecordingsRecording["FileDescription"].asString(); - if(!allListNodeRecordingsRecording["Channel"].isNull()) - recordingsObject.channel = allListNodeRecordingsRecording["Channel"].asString(); - if(!allListNodeRecordingsRecording["InstanceId"].isNull()) - recordingsObject.instanceId = allListNodeRecordingsRecording["InstanceId"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["ContactId"].isNull()) + recordingsObject.contactId = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["ContactId"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["ContactType"].isNull()) + recordingsObject.contactType = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["ContactType"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["AgentId"].isNull()) + recordingsObject.agentId = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["AgentId"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["AgentName"].isNull()) + recordingsObject.agentName = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["AgentName"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["CallingNumber"].isNull()) + recordingsObject.callingNumber = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["CallingNumber"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["CalledNumber"].isNull()) + recordingsObject.calledNumber = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["CalledNumber"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["StartTime"].isNull()) + recordingsObject.startTime = std::stol(callDetailRecordsNodeListCallDetailRecordRecordingsRecording["StartTime"].asString()); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["Duration"].isNull()) + recordingsObject.duration = std::stoi(callDetailRecordsNodeListCallDetailRecordRecordingsRecording["Duration"].asString()); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["FileName"].isNull()) + recordingsObject.fileName = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["FileName"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["FilePath"].isNull()) + recordingsObject.filePath = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["FilePath"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["FileDescription"].isNull()) + recordingsObject.fileDescription = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["FileDescription"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["Channel"].isNull()) + recordingsObject.channel = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["Channel"].asString(); + if(!callDetailRecordsNodeListCallDetailRecordRecordingsRecording["InstanceId"].isNull()) + recordingsObject.instanceId = callDetailRecordsNodeListCallDetailRecordRecordingsRecording["InstanceId"].asString(); callDetailRecordObject.recordings.push_back(recordingsObject); } callDetailRecords_.list.push_back(callDetailRecordObject); diff --git a/ccc/src/model/ListScenarioTemplatesResult.cc b/ccc/src/model/ListScenarioTemplatesResult.cc index 34cea480c..c054c3dc1 100644 --- a/ccc/src/model/ListScenarioTemplatesResult.cc +++ b/ccc/src/model/ListScenarioTemplatesResult.cc @@ -53,32 +53,32 @@ void ListScenarioTemplatesResult::parse(const std::string &payload) scenarioTemplatesObject.type = valueScenarioTemplatesScenario["Type"].asString(); if(!valueScenarioTemplatesScenario["IsTemplate"].isNull()) scenarioTemplatesObject.isTemplate = valueScenarioTemplatesScenario["IsTemplate"].asString() == "true"; - auto allSurveysNode = allScenarioTemplatesNode["Surveys"]["Survey"]; - for (auto allScenarioTemplatesNodeSurveysSurvey : allSurveysNode) + auto allSurveysNode = valueScenarioTemplatesScenario["Surveys"]["Survey"]; + for (auto valueScenarioTemplatesScenarioSurveysSurvey : allSurveysNode) { Scenario::Survey surveysObject; - if(!allScenarioTemplatesNodeSurveysSurvey["Id"].isNull()) - surveysObject.id = allScenarioTemplatesNodeSurveysSurvey["Id"].asString(); - if(!allScenarioTemplatesNodeSurveysSurvey["Name"].isNull()) - surveysObject.name = allScenarioTemplatesNodeSurveysSurvey["Name"].asString(); - if(!allScenarioTemplatesNodeSurveysSurvey["Description"].isNull()) - surveysObject.description = allScenarioTemplatesNodeSurveysSurvey["Description"].asString(); - if(!allScenarioTemplatesNodeSurveysSurvey["Role"].isNull()) - surveysObject.role = allScenarioTemplatesNodeSurveysSurvey["Role"].asString(); - if(!allScenarioTemplatesNodeSurveysSurvey["Round"].isNull()) - surveysObject.round = std::stoi(allScenarioTemplatesNodeSurveysSurvey["Round"].asString()); - if(!allScenarioTemplatesNodeSurveysSurvey["BeebotId"].isNull()) - surveysObject.beebotId = allScenarioTemplatesNodeSurveysSurvey["BeebotId"].asString(); - if(!allScenarioTemplatesNodeSurveysSurvey["GlobalQuestions"].isNull()) - surveysObject.globalQuestions = allScenarioTemplatesNodeSurveysSurvey["GlobalQuestions"].asString(); - auto allIntentsNode = allSurveysNode["Intents"]["IntentNode"]; - for (auto allSurveysNodeIntentsIntentNode : allIntentsNode) + if(!valueScenarioTemplatesScenarioSurveysSurvey["Id"].isNull()) + surveysObject.id = valueScenarioTemplatesScenarioSurveysSurvey["Id"].asString(); + if(!valueScenarioTemplatesScenarioSurveysSurvey["Name"].isNull()) + surveysObject.name = valueScenarioTemplatesScenarioSurveysSurvey["Name"].asString(); + if(!valueScenarioTemplatesScenarioSurveysSurvey["Description"].isNull()) + surveysObject.description = valueScenarioTemplatesScenarioSurveysSurvey["Description"].asString(); + if(!valueScenarioTemplatesScenarioSurveysSurvey["Role"].isNull()) + surveysObject.role = valueScenarioTemplatesScenarioSurveysSurvey["Role"].asString(); + if(!valueScenarioTemplatesScenarioSurveysSurvey["Round"].isNull()) + surveysObject.round = std::stoi(valueScenarioTemplatesScenarioSurveysSurvey["Round"].asString()); + if(!valueScenarioTemplatesScenarioSurveysSurvey["BeebotId"].isNull()) + surveysObject.beebotId = valueScenarioTemplatesScenarioSurveysSurvey["BeebotId"].asString(); + if(!valueScenarioTemplatesScenarioSurveysSurvey["GlobalQuestions"].isNull()) + surveysObject.globalQuestions = valueScenarioTemplatesScenarioSurveysSurvey["GlobalQuestions"].asString(); + auto allIntentsNode = valueScenarioTemplatesScenarioSurveysSurvey["Intents"]["IntentNode"]; + for (auto valueScenarioTemplatesScenarioSurveysSurveyIntentsIntentNode : allIntentsNode) { Scenario::Survey::IntentNode intentsObject; - if(!allSurveysNodeIntentsIntentNode["NodeId"].isNull()) - intentsObject.nodeId = allSurveysNodeIntentsIntentNode["NodeId"].asString(); - if(!allSurveysNodeIntentsIntentNode["IntentId"].isNull()) - intentsObject.intentId = allSurveysNodeIntentsIntentNode["IntentId"].asString(); + if(!valueScenarioTemplatesScenarioSurveysSurveyIntentsIntentNode["NodeId"].isNull()) + intentsObject.nodeId = valueScenarioTemplatesScenarioSurveysSurveyIntentsIntentNode["NodeId"].asString(); + if(!valueScenarioTemplatesScenarioSurveysSurveyIntentsIntentNode["IntentId"].isNull()) + intentsObject.intentId = valueScenarioTemplatesScenarioSurveysSurveyIntentsIntentNode["IntentId"].asString(); surveysObject.intents.push_back(intentsObject); } auto flowNode = value["Flow"]; @@ -90,14 +90,14 @@ void ListScenarioTemplatesResult::parse(const std::string &payload) surveysObject.flow.flowJson = flowNode["FlowJson"].asString(); scenarioTemplatesObject.surveys.push_back(surveysObject); } - auto allVariablesNode = allScenarioTemplatesNode["Variables"]["KeyValuePair"]; - for (auto allScenarioTemplatesNodeVariablesKeyValuePair : allVariablesNode) + auto allVariablesNode = valueScenarioTemplatesScenario["Variables"]["KeyValuePair"]; + for (auto valueScenarioTemplatesScenarioVariablesKeyValuePair : allVariablesNode) { Scenario::KeyValuePair variablesObject; - if(!allScenarioTemplatesNodeVariablesKeyValuePair["Key"].isNull()) - variablesObject.key = allScenarioTemplatesNodeVariablesKeyValuePair["Key"].asString(); - if(!allScenarioTemplatesNodeVariablesKeyValuePair["Value"].isNull()) - variablesObject.value = allScenarioTemplatesNodeVariablesKeyValuePair["Value"].asString(); + if(!valueScenarioTemplatesScenarioVariablesKeyValuePair["Key"].isNull()) + variablesObject.key = valueScenarioTemplatesScenarioVariablesKeyValuePair["Key"].asString(); + if(!valueScenarioTemplatesScenarioVariablesKeyValuePair["Value"].isNull()) + variablesObject.value = valueScenarioTemplatesScenarioVariablesKeyValuePair["Value"].asString(); scenarioTemplatesObject.variables.push_back(variablesObject); } scenarioTemplates_.push_back(scenarioTemplatesObject); diff --git a/ccc/src/model/ListScenariosResult.cc b/ccc/src/model/ListScenariosResult.cc index 7568adf25..538de6075 100644 --- a/ccc/src/model/ListScenariosResult.cc +++ b/ccc/src/model/ListScenariosResult.cc @@ -53,42 +53,42 @@ void ListScenariosResult::parse(const std::string &payload) scenariosObject.type = valueScenariosScenario["Type"].asString(); if(!valueScenariosScenario["IsTemplate"].isNull()) scenariosObject.isTemplate = valueScenariosScenario["IsTemplate"].asString() == "true"; - auto allSurveysNode = allScenariosNode["Surveys"]["Survey"]; - for (auto allScenariosNodeSurveysSurvey : allSurveysNode) + auto allSurveysNode = valueScenariosScenario["Surveys"]["Survey"]; + for (auto valueScenariosScenarioSurveysSurvey : allSurveysNode) { Scenario::Survey surveysObject; - if(!allScenariosNodeSurveysSurvey["Id"].isNull()) - surveysObject.id = allScenariosNodeSurveysSurvey["Id"].asString(); - if(!allScenariosNodeSurveysSurvey["Name"].isNull()) - surveysObject.name = allScenariosNodeSurveysSurvey["Name"].asString(); - if(!allScenariosNodeSurveysSurvey["Description"].isNull()) - surveysObject.description = allScenariosNodeSurveysSurvey["Description"].asString(); - if(!allScenariosNodeSurveysSurvey["Role"].isNull()) - surveysObject.role = allScenariosNodeSurveysSurvey["Role"].asString(); - if(!allScenariosNodeSurveysSurvey["Round"].isNull()) - surveysObject.round = std::stoi(allScenariosNodeSurveysSurvey["Round"].asString()); - if(!allScenariosNodeSurveysSurvey["BeebotId"].isNull()) - surveysObject.beebotId = allScenariosNodeSurveysSurvey["BeebotId"].asString(); - auto allIntentsNode = allSurveysNode["Intents"]["IntentNode"]; - for (auto allSurveysNodeIntentsIntentNode : allIntentsNode) + if(!valueScenariosScenarioSurveysSurvey["Id"].isNull()) + surveysObject.id = valueScenariosScenarioSurveysSurvey["Id"].asString(); + if(!valueScenariosScenarioSurveysSurvey["Name"].isNull()) + surveysObject.name = valueScenariosScenarioSurveysSurvey["Name"].asString(); + if(!valueScenariosScenarioSurveysSurvey["Description"].isNull()) + surveysObject.description = valueScenariosScenarioSurveysSurvey["Description"].asString(); + if(!valueScenariosScenarioSurveysSurvey["Role"].isNull()) + surveysObject.role = valueScenariosScenarioSurveysSurvey["Role"].asString(); + if(!valueScenariosScenarioSurveysSurvey["Round"].isNull()) + surveysObject.round = std::stoi(valueScenariosScenarioSurveysSurvey["Round"].asString()); + if(!valueScenariosScenarioSurveysSurvey["BeebotId"].isNull()) + surveysObject.beebotId = valueScenariosScenarioSurveysSurvey["BeebotId"].asString(); + auto allIntentsNode = valueScenariosScenarioSurveysSurvey["Intents"]["IntentNode"]; + for (auto valueScenariosScenarioSurveysSurveyIntentsIntentNode : allIntentsNode) { Scenario::Survey::IntentNode intentsObject; - if(!allSurveysNodeIntentsIntentNode["NodeId"].isNull()) - intentsObject.nodeId = allSurveysNodeIntentsIntentNode["NodeId"].asString(); - if(!allSurveysNodeIntentsIntentNode["IntentId"].isNull()) - intentsObject.intentId = allSurveysNodeIntentsIntentNode["IntentId"].asString(); + if(!valueScenariosScenarioSurveysSurveyIntentsIntentNode["NodeId"].isNull()) + intentsObject.nodeId = valueScenariosScenarioSurveysSurveyIntentsIntentNode["NodeId"].asString(); + if(!valueScenariosScenarioSurveysSurveyIntentsIntentNode["IntentId"].isNull()) + intentsObject.intentId = valueScenariosScenarioSurveysSurveyIntentsIntentNode["IntentId"].asString(); surveysObject.intents.push_back(intentsObject); } scenariosObject.surveys.push_back(surveysObject); } - auto allVariablesNode = allScenariosNode["Variables"]["KeyValuePair"]; - for (auto allScenariosNodeVariablesKeyValuePair : allVariablesNode) + auto allVariablesNode = valueScenariosScenario["Variables"]["KeyValuePair"]; + for (auto valueScenariosScenarioVariablesKeyValuePair : allVariablesNode) { Scenario::KeyValuePair variablesObject; - if(!allScenariosNodeVariablesKeyValuePair["Key"].isNull()) - variablesObject.key = allScenariosNodeVariablesKeyValuePair["Key"].asString(); - if(!allScenariosNodeVariablesKeyValuePair["Value"].isNull()) - variablesObject.value = allScenariosNodeVariablesKeyValuePair["Value"].asString(); + if(!valueScenariosScenarioVariablesKeyValuePair["Key"].isNull()) + variablesObject.key = valueScenariosScenarioVariablesKeyValuePair["Key"].asString(); + if(!valueScenariosScenarioVariablesKeyValuePair["Value"].isNull()) + variablesObject.value = valueScenariosScenarioVariablesKeyValuePair["Value"].asString(); scenariosObject.variables.push_back(variablesObject); } auto strategyNode = value["Strategy"]; diff --git a/ccc/src/model/ListSkillGroupSummaryReportsByIntervalResult.cc b/ccc/src/model/ListSkillGroupSummaryReportsByIntervalResult.cc index dff38604d..87db54119 100644 --- a/ccc/src/model/ListSkillGroupSummaryReportsByIntervalResult.cc +++ b/ccc/src/model/ListSkillGroupSummaryReportsByIntervalResult.cc @@ -52,18 +52,18 @@ void ListSkillGroupSummaryReportsByIntervalResult::parse(const std::string &payl PagedSkillGroupSummaryReport::SkillGroupTimeIntervalReport skillGroupTimeIntervalReportObject; if(!pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReport["SkillGroupId"].isNull()) skillGroupTimeIntervalReportObject.skillGroupId = pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReport["SkillGroupId"].asString(); - auto allIntervalListNode = allListNode["IntervalList"]["SkillGroupSummaryReport"]; - for (auto allListNodeIntervalListSkillGroupSummaryReport : allIntervalListNode) + auto allIntervalListNode = pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReport["IntervalList"]["SkillGroupSummaryReport"]; + for (auto pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReportIntervalListSkillGroupSummaryReport : allIntervalListNode) { PagedSkillGroupSummaryReport::SkillGroupTimeIntervalReport::SkillGroupSummaryReport intervalListObject; - if(!allListNodeIntervalListSkillGroupSummaryReport["Timestamp"].isNull()) - intervalListObject.timestamp = allListNodeIntervalListSkillGroupSummaryReport["Timestamp"].asString(); - if(!allListNodeIntervalListSkillGroupSummaryReport["InstanceId"].isNull()) - intervalListObject.instanceId = allListNodeIntervalListSkillGroupSummaryReport["InstanceId"].asString(); - if(!allListNodeIntervalListSkillGroupSummaryReport["SkillGroupId"].isNull()) - intervalListObject.skillGroupId = allListNodeIntervalListSkillGroupSummaryReport["SkillGroupId"].asString(); - if(!allListNodeIntervalListSkillGroupSummaryReport["SkillGroupName"].isNull()) - intervalListObject.skillGroupName = allListNodeIntervalListSkillGroupSummaryReport["SkillGroupName"].asString(); + if(!pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReportIntervalListSkillGroupSummaryReport["Timestamp"].isNull()) + intervalListObject.timestamp = pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReportIntervalListSkillGroupSummaryReport["Timestamp"].asString(); + if(!pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReportIntervalListSkillGroupSummaryReport["InstanceId"].isNull()) + intervalListObject.instanceId = pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReportIntervalListSkillGroupSummaryReport["InstanceId"].asString(); + if(!pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReportIntervalListSkillGroupSummaryReport["SkillGroupId"].isNull()) + intervalListObject.skillGroupId = pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReportIntervalListSkillGroupSummaryReport["SkillGroupId"].asString(); + if(!pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReportIntervalListSkillGroupSummaryReport["SkillGroupName"].isNull()) + intervalListObject.skillGroupName = pagedSkillGroupSummaryReportNodeListSkillGroupTimeIntervalReportIntervalListSkillGroupSummaryReport["SkillGroupName"].asString(); auto overallNode = value["Overall"]; if(!overallNode["TotalCalls"].isNull()) intervalListObject.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString()); diff --git a/ccc/src/model/ListSkillGroupsResult.cc b/ccc/src/model/ListSkillGroupsResult.cc index 6dcde3472..3379b230c 100644 --- a/ccc/src/model/ListSkillGroupsResult.cc +++ b/ccc/src/model/ListSkillGroupsResult.cc @@ -59,28 +59,28 @@ void ListSkillGroupsResult::parse(const std::string &payload) skillGroupsObject.routingStrategy = valueSkillGroupsSkillGroup["RoutingStrategy"].asString(); if(!valueSkillGroupsSkillGroup["UserCount"].isNull()) skillGroupsObject.userCount = std::stoi(valueSkillGroupsSkillGroup["UserCount"].asString()); - auto allOutboundPhoneNumbersNode = allSkillGroupsNode["OutboundPhoneNumbers"]["PhoneNumber"]; - for (auto allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber : allOutboundPhoneNumbersNode) + auto allOutboundPhoneNumbersNode = valueSkillGroupsSkillGroup["OutboundPhoneNumbers"]["PhoneNumber"]; + for (auto valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber : allOutboundPhoneNumbersNode) { SkillGroup::PhoneNumber outboundPhoneNumbersObject; - if(!allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["PhoneNumberId"].isNull()) - outboundPhoneNumbersObject.phoneNumberId = allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["PhoneNumberId"].asString(); - if(!allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["InstanceId"].isNull()) - outboundPhoneNumbersObject.instanceId = allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["InstanceId"].asString(); - if(!allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["Number"].isNull()) - outboundPhoneNumbersObject.number = allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["Number"].asString(); - if(!allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["PhoneNumberDescription"].isNull()) - outboundPhoneNumbersObject.phoneNumberDescription = allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["PhoneNumberDescription"].asString(); - if(!allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["TestOnly"].isNull()) - outboundPhoneNumbersObject.testOnly = allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["TestOnly"].asString() == "true"; - if(!allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["RemainingTime"].isNull()) - outboundPhoneNumbersObject.remainingTime = std::stoi(allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["RemainingTime"].asString()); - if(!allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["AllowOutbound"].isNull()) - outboundPhoneNumbersObject.allowOutbound = allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["AllowOutbound"].asString() == "true"; - if(!allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["Usage"].isNull()) - outboundPhoneNumbersObject.usage = allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["Usage"].asString(); - if(!allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["Trunks"].isNull()) - outboundPhoneNumbersObject.trunks = std::stoi(allSkillGroupsNodeOutboundPhoneNumbersPhoneNumber["Trunks"].asString()); + if(!valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["PhoneNumberId"].isNull()) + outboundPhoneNumbersObject.phoneNumberId = valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["PhoneNumberId"].asString(); + if(!valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["InstanceId"].isNull()) + outboundPhoneNumbersObject.instanceId = valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["InstanceId"].asString(); + if(!valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["Number"].isNull()) + outboundPhoneNumbersObject.number = valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["Number"].asString(); + if(!valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["PhoneNumberDescription"].isNull()) + outboundPhoneNumbersObject.phoneNumberDescription = valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["PhoneNumberDescription"].asString(); + if(!valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["TestOnly"].isNull()) + outboundPhoneNumbersObject.testOnly = valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["TestOnly"].asString() == "true"; + if(!valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["RemainingTime"].isNull()) + outboundPhoneNumbersObject.remainingTime = std::stoi(valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["RemainingTime"].asString()); + if(!valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["AllowOutbound"].isNull()) + outboundPhoneNumbersObject.allowOutbound = valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["AllowOutbound"].asString() == "true"; + if(!valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["Usage"].isNull()) + outboundPhoneNumbersObject.usage = valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["Usage"].asString(); + if(!valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["Trunks"].isNull()) + outboundPhoneNumbersObject.trunks = std::stoi(valueSkillGroupsSkillGroupOutboundPhoneNumbersPhoneNumber["Trunks"].asString()); skillGroupsObject.outboundPhoneNumbers.push_back(outboundPhoneNumbersObject); } skillGroups_.push_back(skillGroupsObject); diff --git a/ccc/src/model/ListTransferableSkillGroupsRequest.cc b/ccc/src/model/ListTransferableSkillGroupsRequest.cc new file mode 100644 index 000000000..68ef96050 --- /dev/null +++ b/ccc/src/model/ListTransferableSkillGroupsRequest.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 + +using AlibabaCloud::CCC::Model::ListTransferableSkillGroupsRequest; + +ListTransferableSkillGroupsRequest::ListTransferableSkillGroupsRequest() : + RpcServiceRequest("ccc", "2017-07-05", "ListTransferableSkillGroups") +{ + setMethod(HttpRequest::Method::Post); +} + +ListTransferableSkillGroupsRequest::~ListTransferableSkillGroupsRequest() +{} + +std::string ListTransferableSkillGroupsRequest::getInstanceId()const +{ + return instanceId_; +} + +void ListTransferableSkillGroupsRequest::setInstanceId(const std::string& instanceId) +{ + instanceId_ = instanceId; + setParameter("InstanceId", instanceId); +} + +std::string ListTransferableSkillGroupsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ListTransferableSkillGroupsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/ccc/src/model/ListTransferableSkillGroupsResult.cc b/ccc/src/model/ListTransferableSkillGroupsResult.cc new file mode 100644 index 000000000..8b1a1f831 --- /dev/null +++ b/ccc/src/model/ListTransferableSkillGroupsResult.cc @@ -0,0 +1,101 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::CCC; +using namespace AlibabaCloud::CCC::Model; + +ListTransferableSkillGroupsResult::ListTransferableSkillGroupsResult() : + ServiceResult() +{} + +ListTransferableSkillGroupsResult::ListTransferableSkillGroupsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListTransferableSkillGroupsResult::~ListTransferableSkillGroupsResult() +{} + +void ListTransferableSkillGroupsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allSkillGroupsNode = value["SkillGroups"]["SkillGroup"]; + for (auto valueSkillGroupsSkillGroup : allSkillGroupsNode) + { + SkillGroup skillGroupsObject; + if(!valueSkillGroupsSkillGroup["SkillGroupId"].isNull()) + skillGroupsObject.skillGroupId = valueSkillGroupsSkillGroup["SkillGroupId"].asString(); + if(!valueSkillGroupsSkillGroup["InstanceId"].isNull()) + skillGroupsObject.instanceId = valueSkillGroupsSkillGroup["InstanceId"].asString(); + if(!valueSkillGroupsSkillGroup["SkillGroupName"].isNull()) + skillGroupsObject.skillGroupName = valueSkillGroupsSkillGroup["SkillGroupName"].asString(); + if(!valueSkillGroupsSkillGroup["AccSkillGroupName"].isNull()) + skillGroupsObject.accSkillGroupName = valueSkillGroupsSkillGroup["AccSkillGroupName"].asString(); + if(!valueSkillGroupsSkillGroup["AccQueueName"].isNull()) + skillGroupsObject.accQueueName = valueSkillGroupsSkillGroup["AccQueueName"].asString(); + if(!valueSkillGroupsSkillGroup["SkillGroupDescription"].isNull()) + skillGroupsObject.skillGroupDescription = valueSkillGroupsSkillGroup["SkillGroupDescription"].asString(); + if(!valueSkillGroupsSkillGroup["RoutingStrategy"].isNull()) + skillGroupsObject.routingStrategy = valueSkillGroupsSkillGroup["RoutingStrategy"].asString(); + if(!valueSkillGroupsSkillGroup["AllowPrivateOutboundNumber"].isNull()) + skillGroupsObject.allowPrivateOutboundNumber = valueSkillGroupsSkillGroup["AllowPrivateOutboundNumber"].asString() == "true"; + if(!valueSkillGroupsSkillGroup["UserCount"].isNull()) + skillGroupsObject.userCount = std::stoi(valueSkillGroupsSkillGroup["UserCount"].asString()); + skillGroups_.push_back(skillGroupsObject); + } + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["HttpStatusCode"].isNull()) + httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + +} + +std::string ListTransferableSkillGroupsResult::getMessage()const +{ + return message_; +} + +int ListTransferableSkillGroupsResult::getHttpStatusCode()const +{ + return httpStatusCode_; +} + +std::vector ListTransferableSkillGroupsResult::getSkillGroups()const +{ + return skillGroups_; +} + +std::string ListTransferableSkillGroupsResult::getCode()const +{ + return code_; +} + +bool ListTransferableSkillGroupsResult::getSuccess()const +{ + return success_; +} + diff --git a/ccc/src/model/ListTrunkProvidersRequest.cc b/ccc/src/model/ListTrunkProvidersRequest.cc new file mode 100644 index 000000000..40ad573a0 --- /dev/null +++ b/ccc/src/model/ListTrunkProvidersRequest.cc @@ -0,0 +1,40 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::CCC::Model::ListTrunkProvidersRequest; + +ListTrunkProvidersRequest::ListTrunkProvidersRequest() : + RpcServiceRequest("ccc", "2017-07-05", "ListTrunkProviders") +{ + setMethod(HttpRequest::Method::Post); +} + +ListTrunkProvidersRequest::~ListTrunkProvidersRequest() +{} + +std::string ListTrunkProvidersRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ListTrunkProvidersRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/ccc/src/model/ListTrunkProvidersResult.cc b/ccc/src/model/ListTrunkProvidersResult.cc new file mode 100644 index 000000000..2ad297122 --- /dev/null +++ b/ccc/src/model/ListTrunkProvidersResult.cc @@ -0,0 +1,87 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::CCC; +using namespace AlibabaCloud::CCC::Model; + +ListTrunkProvidersResult::ListTrunkProvidersResult() : + ServiceResult() +{} + +ListTrunkProvidersResult::ListTrunkProvidersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListTrunkProvidersResult::~ListTrunkProvidersResult() +{} + +void ListTrunkProvidersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allTrunkProvidersNode = value["TrunkProviders"]["TrunkProvider"]; + for (auto valueTrunkProvidersTrunkProvider : allTrunkProvidersNode) + { + TrunkProvider trunkProvidersObject; + if(!valueTrunkProvidersTrunkProvider["ProviderName"].isNull()) + trunkProvidersObject.providerName = valueTrunkProvidersTrunkProvider["ProviderName"].asString(); + if(!valueTrunkProvidersTrunkProvider["Status"].isNull()) + trunkProvidersObject.status = valueTrunkProvidersTrunkProvider["Status"].asString(); + trunkProviders_.push_back(trunkProvidersObject); + } + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["HttpStatusCode"].isNull()) + httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + +} + +std::string ListTrunkProvidersResult::getMessage()const +{ + return message_; +} + +int ListTrunkProvidersResult::getHttpStatusCode()const +{ + return httpStatusCode_; +} + +std::vector ListTrunkProvidersResult::getTrunkProviders()const +{ + return trunkProviders_; +} + +std::string ListTrunkProvidersResult::getCode()const +{ + return code_; +} + +bool ListTrunkProvidersResult::getSuccess()const +{ + return success_; +} + diff --git a/ccc/src/model/ListTrunksOfSkillGroupRequest.cc b/ccc/src/model/ListTrunksOfSkillGroupRequest.cc new file mode 100644 index 000000000..fb34b9eaa --- /dev/null +++ b/ccc/src/model/ListTrunksOfSkillGroupRequest.cc @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::CCC::Model::ListTrunksOfSkillGroupRequest; + +ListTrunksOfSkillGroupRequest::ListTrunksOfSkillGroupRequest() : + RpcServiceRequest("ccc", "2017-07-05", "ListTrunksOfSkillGroup") +{ + setMethod(HttpRequest::Method::Post); +} + +ListTrunksOfSkillGroupRequest::~ListTrunksOfSkillGroupRequest() +{} + +std::string ListTrunksOfSkillGroupRequest::getInstanceId()const +{ + return instanceId_; +} + +void ListTrunksOfSkillGroupRequest::setInstanceId(const std::string& instanceId) +{ + instanceId_ = instanceId; + setParameter("InstanceId", instanceId); +} + +std::string ListTrunksOfSkillGroupRequest::getSkillGroupId()const +{ + return skillGroupId_; +} + +void ListTrunksOfSkillGroupRequest::setSkillGroupId(const std::string& skillGroupId) +{ + skillGroupId_ = skillGroupId; + setParameter("SkillGroupId", skillGroupId); +} + +std::string ListTrunksOfSkillGroupRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ListTrunksOfSkillGroupRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/ccc/src/model/ListTrunksOfSkillGroupResult.cc b/ccc/src/model/ListTrunksOfSkillGroupResult.cc new file mode 100644 index 000000000..0c770baee --- /dev/null +++ b/ccc/src/model/ListTrunksOfSkillGroupResult.cc @@ -0,0 +1,87 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::CCC; +using namespace AlibabaCloud::CCC::Model; + +ListTrunksOfSkillGroupResult::ListTrunksOfSkillGroupResult() : + ServiceResult() +{} + +ListTrunksOfSkillGroupResult::ListTrunksOfSkillGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListTrunksOfSkillGroupResult::~ListTrunksOfSkillGroupResult() +{} + +void ListTrunksOfSkillGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allTrunkConfigsNode = value["TrunkConfigs"]["TrunkConfig"]; + for (auto valueTrunkConfigsTrunkConfig : allTrunkConfigsNode) + { + TrunkConfig trunkConfigsObject; + if(!valueTrunkConfigsTrunkConfig["ProviderName"].isNull()) + trunkConfigsObject.providerName = valueTrunkConfigsTrunkConfig["ProviderName"].asString(); + if(!valueTrunkConfigsTrunkConfig["Primary"].isNull()) + trunkConfigsObject.primary = valueTrunkConfigsTrunkConfig["Primary"].asString() == "true"; + trunkConfigs_.push_back(trunkConfigsObject); + } + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["HttpStatusCode"].isNull()) + httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + +} + +std::string ListTrunksOfSkillGroupResult::getMessage()const +{ + return message_; +} + +int ListTrunksOfSkillGroupResult::getHttpStatusCode()const +{ + return httpStatusCode_; +} + +std::vector ListTrunksOfSkillGroupResult::getTrunkConfigs()const +{ + return trunkConfigs_; +} + +std::string ListTrunksOfSkillGroupResult::getCode()const +{ + return code_; +} + +bool ListTrunksOfSkillGroupResult::getSuccess()const +{ + return success_; +} + diff --git a/ccc/src/model/ListUnreachableContactsResult.cc b/ccc/src/model/ListUnreachableContactsResult.cc index 69115eaf6..4e9d2251c 100644 --- a/ccc/src/model/ListUnreachableContactsResult.cc +++ b/ccc/src/model/ListUnreachableContactsResult.cc @@ -52,22 +52,22 @@ void ListUnreachableContactsResult::parse(const std::string &payload) UnreachableContacts::UnreachableContact unreachableContactObject; if(!unreachableContactsNodeListUnreachableContact["TotalAttempts"].isNull()) unreachableContactObject.totalAttempts = std::stoi(unreachableContactsNodeListUnreachableContact["TotalAttempts"].asString()); - auto allContactsNode = allListNode["Contacts"]["Contact"]; - for (auto allListNodeContactsContact : allContactsNode) + auto allContactsNode = unreachableContactsNodeListUnreachableContact["Contacts"]["Contact"]; + for (auto unreachableContactsNodeListUnreachableContactContactsContact : allContactsNode) { UnreachableContacts::UnreachableContact::Contact contactsObject; - if(!allListNodeContactsContact["ContactId"].isNull()) - contactsObject.contactId = allListNodeContactsContact["ContactId"].asString(); - if(!allListNodeContactsContact["ContactName"].isNull()) - contactsObject.contactName = allListNodeContactsContact["ContactName"].asString(); - if(!allListNodeContactsContact["Role"].isNull()) - contactsObject.role = allListNodeContactsContact["Role"].asString(); - if(!allListNodeContactsContact["PhoneNumber"].isNull()) - contactsObject.phoneNumber = allListNodeContactsContact["PhoneNumber"].asString(); - if(!allListNodeContactsContact["State"].isNull()) - contactsObject.state = allListNodeContactsContact["State"].asString(); - if(!allListNodeContactsContact["ReferenceId"].isNull()) - contactsObject.referenceId = allListNodeContactsContact["ReferenceId"].asString(); + if(!unreachableContactsNodeListUnreachableContactContactsContact["ContactId"].isNull()) + contactsObject.contactId = unreachableContactsNodeListUnreachableContactContactsContact["ContactId"].asString(); + if(!unreachableContactsNodeListUnreachableContactContactsContact["ContactName"].isNull()) + contactsObject.contactName = unreachableContactsNodeListUnreachableContactContactsContact["ContactName"].asString(); + if(!unreachableContactsNodeListUnreachableContactContactsContact["Role"].isNull()) + contactsObject.role = unreachableContactsNodeListUnreachableContactContactsContact["Role"].asString(); + if(!unreachableContactsNodeListUnreachableContactContactsContact["PhoneNumber"].isNull()) + contactsObject.phoneNumber = unreachableContactsNodeListUnreachableContactContactsContact["PhoneNumber"].asString(); + if(!unreachableContactsNodeListUnreachableContactContactsContact["State"].isNull()) + contactsObject.state = unreachableContactsNodeListUnreachableContactContactsContact["State"].asString(); + if(!unreachableContactsNodeListUnreachableContactContactsContact["ReferenceId"].isNull()) + contactsObject.referenceId = unreachableContactsNodeListUnreachableContactContactsContact["ReferenceId"].asString(); unreachableContactObject.contacts.push_back(contactsObject); } unreachableContacts_.list.push_back(unreachableContactObject); diff --git a/ccc/src/model/ListUsersOfSkillGroupResult.cc b/ccc/src/model/ListUsersOfSkillGroupResult.cc index d3c68ca24..7c1cb9a6d 100644 --- a/ccc/src/model/ListUsersOfSkillGroupResult.cc +++ b/ccc/src/model/ListUsersOfSkillGroupResult.cc @@ -56,42 +56,42 @@ void ListUsersOfSkillGroupResult::parse(const std::string &payload) userObject.ramId = usersNodeListUser["RamId"].asString(); if(!usersNodeListUser["InstanceId"].isNull()) userObject.instanceId = usersNodeListUser["InstanceId"].asString(); - auto allRolesNode = allListNode["Roles"]["Role"]; - for (auto allListNodeRolesRole : allRolesNode) + auto allRolesNode = usersNodeListUser["Roles"]["Role"]; + for (auto usersNodeListUserRolesRole : allRolesNode) { Users::User::Role rolesObject; - if(!allListNodeRolesRole["RoleId"].isNull()) - rolesObject.roleId = allListNodeRolesRole["RoleId"].asString(); - if(!allListNodeRolesRole["InstanceId"].isNull()) - rolesObject.instanceId = allListNodeRolesRole["InstanceId"].asString(); - if(!allListNodeRolesRole["RoleName"].isNull()) - rolesObject.roleName = allListNodeRolesRole["RoleName"].asString(); - if(!allListNodeRolesRole["RoleDescription"].isNull()) - rolesObject.roleDescription = allListNodeRolesRole["RoleDescription"].asString(); - if(!allListNodeRolesRole["UserCount"].isNull()) - rolesObject.userCount = std::stoi(allListNodeRolesRole["UserCount"].asString()); - auto allPrivilegesNode = allRolesNode["Privileges"]["Privilege"]; - for (auto allRolesNodePrivilegesPrivilege : allPrivilegesNode) + if(!usersNodeListUserRolesRole["RoleId"].isNull()) + rolesObject.roleId = usersNodeListUserRolesRole["RoleId"].asString(); + if(!usersNodeListUserRolesRole["InstanceId"].isNull()) + rolesObject.instanceId = usersNodeListUserRolesRole["InstanceId"].asString(); + if(!usersNodeListUserRolesRole["RoleName"].isNull()) + rolesObject.roleName = usersNodeListUserRolesRole["RoleName"].asString(); + if(!usersNodeListUserRolesRole["RoleDescription"].isNull()) + rolesObject.roleDescription = usersNodeListUserRolesRole["RoleDescription"].asString(); + if(!usersNodeListUserRolesRole["UserCount"].isNull()) + rolesObject.userCount = std::stoi(usersNodeListUserRolesRole["UserCount"].asString()); + auto allPrivilegesNode = usersNodeListUserRolesRole["Privileges"]["Privilege"]; + for (auto usersNodeListUserRolesRolePrivilegesPrivilege : allPrivilegesNode) { Users::User::Role::Privilege privilegesObject; - if(!allRolesNodePrivilegesPrivilege["PrivilegeId"].isNull()) - privilegesObject.privilegeId = allRolesNodePrivilegesPrivilege["PrivilegeId"].asString(); - if(!allRolesNodePrivilegesPrivilege["PrivilegeName"].isNull()) - privilegesObject.privilegeName = allRolesNodePrivilegesPrivilege["PrivilegeName"].asString(); - if(!allRolesNodePrivilegesPrivilege["PrivilegeDescription"].isNull()) - privilegesObject.privilegeDescription = allRolesNodePrivilegesPrivilege["PrivilegeDescription"].asString(); + if(!usersNodeListUserRolesRolePrivilegesPrivilege["PrivilegeId"].isNull()) + privilegesObject.privilegeId = usersNodeListUserRolesRolePrivilegesPrivilege["PrivilegeId"].asString(); + if(!usersNodeListUserRolesRolePrivilegesPrivilege["PrivilegeName"].isNull()) + privilegesObject.privilegeName = usersNodeListUserRolesRolePrivilegesPrivilege["PrivilegeName"].asString(); + if(!usersNodeListUserRolesRolePrivilegesPrivilege["PrivilegeDescription"].isNull()) + privilegesObject.privilegeDescription = usersNodeListUserRolesRolePrivilegesPrivilege["PrivilegeDescription"].asString(); rolesObject.privileges.push_back(privilegesObject); } userObject.roles.push_back(rolesObject); } - auto allSkillLevelsNode = allListNode["SkillLevels"]["SkillLevel"]; - for (auto allListNodeSkillLevelsSkillLevel : allSkillLevelsNode) + auto allSkillLevelsNode = usersNodeListUser["SkillLevels"]["SkillLevel"]; + for (auto usersNodeListUserSkillLevelsSkillLevel : allSkillLevelsNode) { Users::User::SkillLevel skillLevelsObject; - if(!allListNodeSkillLevelsSkillLevel["SkillLevelId"].isNull()) - skillLevelsObject.skillLevelId = allListNodeSkillLevelsSkillLevel["SkillLevelId"].asString(); - if(!allListNodeSkillLevelsSkillLevel["Level"].isNull()) - skillLevelsObject.level = std::stoi(allListNodeSkillLevelsSkillLevel["Level"].asString()); + if(!usersNodeListUserSkillLevelsSkillLevel["SkillLevelId"].isNull()) + skillLevelsObject.skillLevelId = usersNodeListUserSkillLevelsSkillLevel["SkillLevelId"].asString(); + if(!usersNodeListUserSkillLevelsSkillLevel["Level"].isNull()) + skillLevelsObject.level = std::stoi(usersNodeListUserSkillLevelsSkillLevel["Level"].asString()); auto skillNode = value["Skill"]; if(!skillNode["SkillGroupId"].isNull()) skillLevelsObject.skill.skillGroupId = skillNode["SkillGroupId"].asString(); diff --git a/ccc/src/model/ListUsersResult.cc b/ccc/src/model/ListUsersResult.cc index 907e5a402..8e8986ca2 100644 --- a/ccc/src/model/ListUsersResult.cc +++ b/ccc/src/model/ListUsersResult.cc @@ -60,28 +60,28 @@ void ListUsersResult::parse(const std::string &payload) userObject.primary = usersNodeListUser["Primary"].asString() == "true"; if(!usersNodeListUser["PrivateOutboundNumberId"].isNull()) userObject.privateOutboundNumberId = usersNodeListUser["PrivateOutboundNumberId"].asString(); - auto allRolesNode = allListNode["Roles"]["Role"]; - for (auto allListNodeRolesRole : allRolesNode) + auto allRolesNode = usersNodeListUser["Roles"]["Role"]; + for (auto usersNodeListUserRolesRole : allRolesNode) { Users::User::Role rolesObject; - if(!allListNodeRolesRole["RoleId"].isNull()) - rolesObject.roleId = allListNodeRolesRole["RoleId"].asString(); - if(!allListNodeRolesRole["InstanceId"].isNull()) - rolesObject.instanceId = allListNodeRolesRole["InstanceId"].asString(); - if(!allListNodeRolesRole["RoleName"].isNull()) - rolesObject.roleName = allListNodeRolesRole["RoleName"].asString(); - if(!allListNodeRolesRole["RoleDescription"].isNull()) - rolesObject.roleDescription = allListNodeRolesRole["RoleDescription"].asString(); + if(!usersNodeListUserRolesRole["RoleId"].isNull()) + rolesObject.roleId = usersNodeListUserRolesRole["RoleId"].asString(); + if(!usersNodeListUserRolesRole["InstanceId"].isNull()) + rolesObject.instanceId = usersNodeListUserRolesRole["InstanceId"].asString(); + if(!usersNodeListUserRolesRole["RoleName"].isNull()) + rolesObject.roleName = usersNodeListUserRolesRole["RoleName"].asString(); + if(!usersNodeListUserRolesRole["RoleDescription"].isNull()) + rolesObject.roleDescription = usersNodeListUserRolesRole["RoleDescription"].asString(); userObject.roles.push_back(rolesObject); } - auto allSkillLevelsNode = allListNode["SkillLevels"]["SkillLevel"]; - for (auto allListNodeSkillLevelsSkillLevel : allSkillLevelsNode) + auto allSkillLevelsNode = usersNodeListUser["SkillLevels"]["SkillLevel"]; + for (auto usersNodeListUserSkillLevelsSkillLevel : allSkillLevelsNode) { Users::User::SkillLevel skillLevelsObject; - if(!allListNodeSkillLevelsSkillLevel["SkillLevelId"].isNull()) - skillLevelsObject.skillLevelId = allListNodeSkillLevelsSkillLevel["SkillLevelId"].asString(); - if(!allListNodeSkillLevelsSkillLevel["Level"].isNull()) - skillLevelsObject.level = std::stoi(allListNodeSkillLevelsSkillLevel["Level"].asString()); + if(!usersNodeListUserSkillLevelsSkillLevel["SkillLevelId"].isNull()) + skillLevelsObject.skillLevelId = usersNodeListUserSkillLevelsSkillLevel["SkillLevelId"].asString(); + if(!usersNodeListUserSkillLevelsSkillLevel["Level"].isNull()) + skillLevelsObject.level = std::stoi(usersNodeListUserSkillLevelsSkillLevel["Level"].asString()); auto skillNode = value["Skill"]; if(!skillNode["SkillGroupId"].isNull()) skillLevelsObject.skill.skillGroupId = skillNode["SkillGroupId"].asString(); diff --git a/ccc/src/model/ModifyPrimaryTrunksOfSkillGroupRequest.cc b/ccc/src/model/ModifyPrimaryTrunksOfSkillGroupRequest.cc new file mode 100644 index 000000000..650cfeeb1 --- /dev/null +++ b/ccc/src/model/ModifyPrimaryTrunksOfSkillGroupRequest.cc @@ -0,0 +1,75 @@ +/* + * 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 + +using AlibabaCloud::CCC::Model::ModifyPrimaryTrunksOfSkillGroupRequest; + +ModifyPrimaryTrunksOfSkillGroupRequest::ModifyPrimaryTrunksOfSkillGroupRequest() : + RpcServiceRequest("ccc", "2017-07-05", "ModifyPrimaryTrunksOfSkillGroup") +{ + setMethod(HttpRequest::Method::Post); +} + +ModifyPrimaryTrunksOfSkillGroupRequest::~ModifyPrimaryTrunksOfSkillGroupRequest() +{} + +std::string ModifyPrimaryTrunksOfSkillGroupRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ModifyPrimaryTrunksOfSkillGroupRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::vector ModifyPrimaryTrunksOfSkillGroupRequest::getPrimaryProviderName()const +{ + return primaryProviderName_; +} + +void ModifyPrimaryTrunksOfSkillGroupRequest::setPrimaryProviderName(const std::vector& primaryProviderName) +{ + primaryProviderName_ = primaryProviderName; + for(int dep1 = 0; dep1!= primaryProviderName.size(); dep1++) { + setParameter("PrimaryProviderName."+ std::to_string(dep1), primaryProviderName.at(dep1)); + } +} + +std::string ModifyPrimaryTrunksOfSkillGroupRequest::getInstanceId()const +{ + return instanceId_; +} + +void ModifyPrimaryTrunksOfSkillGroupRequest::setInstanceId(const std::string& instanceId) +{ + instanceId_ = instanceId; + setParameter("InstanceId", instanceId); +} + +std::string ModifyPrimaryTrunksOfSkillGroupRequest::getSkillGroupId()const +{ + return skillGroupId_; +} + +void ModifyPrimaryTrunksOfSkillGroupRequest::setSkillGroupId(const std::string& skillGroupId) +{ + skillGroupId_ = skillGroupId; + setParameter("SkillGroupId", skillGroupId); +} + diff --git a/ccc/src/model/ModifyPrimaryTrunksOfSkillGroupResult.cc b/ccc/src/model/ModifyPrimaryTrunksOfSkillGroupResult.cc new file mode 100644 index 000000000..bbac8e997 --- /dev/null +++ b/ccc/src/model/ModifyPrimaryTrunksOfSkillGroupResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::CCC; +using namespace AlibabaCloud::CCC::Model; + +ModifyPrimaryTrunksOfSkillGroupResult::ModifyPrimaryTrunksOfSkillGroupResult() : + ServiceResult() +{} + +ModifyPrimaryTrunksOfSkillGroupResult::ModifyPrimaryTrunksOfSkillGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyPrimaryTrunksOfSkillGroupResult::~ModifyPrimaryTrunksOfSkillGroupResult() +{} + +void ModifyPrimaryTrunksOfSkillGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["HttpStatusCode"].isNull()) + httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + +} + +std::string ModifyPrimaryTrunksOfSkillGroupResult::getMessage()const +{ + return message_; +} + +int ModifyPrimaryTrunksOfSkillGroupResult::getHttpStatusCode()const +{ + return httpStatusCode_; +} + +std::string ModifyPrimaryTrunksOfSkillGroupResult::getCode()const +{ + return code_; +} + +bool ModifyPrimaryTrunksOfSkillGroupResult::getSuccess()const +{ + return success_; +} + diff --git a/ccc/src/model/ModifyScenarioResult.cc b/ccc/src/model/ModifyScenarioResult.cc index 5f0a3759f..7b24b0ce2 100644 --- a/ccc/src/model/ModifyScenarioResult.cc +++ b/ccc/src/model/ModifyScenarioResult.cc @@ -66,14 +66,14 @@ void ModifyScenarioResult::parse(const std::string &payload) surveyObject.round = std::stoi(scenarioNodeSurveysSurvey["Round"].asString()); if(!scenarioNodeSurveysSurvey["BeebotId"].isNull()) surveyObject.beebotId = scenarioNodeSurveysSurvey["BeebotId"].asString(); - auto allIntentsNode = allSurveysNode["Intents"]["IntentNode"]; - for (auto allSurveysNodeIntentsIntentNode : allIntentsNode) + auto allIntentsNode = scenarioNodeSurveysSurvey["Intents"]["IntentNode"]; + for (auto scenarioNodeSurveysSurveyIntentsIntentNode : allIntentsNode) { Scenario::Survey::IntentNode intentsObject; - if(!allSurveysNodeIntentsIntentNode["NodeId"].isNull()) - intentsObject.nodeId = allSurveysNodeIntentsIntentNode["NodeId"].asString(); - if(!allSurveysNodeIntentsIntentNode["IntentId"].isNull()) - intentsObject.intentId = allSurveysNodeIntentsIntentNode["IntentId"].asString(); + if(!scenarioNodeSurveysSurveyIntentsIntentNode["NodeId"].isNull()) + intentsObject.nodeId = scenarioNodeSurveysSurveyIntentsIntentNode["NodeId"].asString(); + if(!scenarioNodeSurveysSurveyIntentsIntentNode["IntentId"].isNull()) + intentsObject.intentId = scenarioNodeSurveysSurveyIntentsIntentNode["IntentId"].asString(); surveyObject.intents.push_back(intentsObject); } scenario_.surveys.push_back(surveyObject); diff --git a/ccc/src/model/RequestLoginInfoRequest.cc b/ccc/src/model/RequestLoginInfoRequest.cc index 8d11e1633..ff991bdeb 100644 --- a/ccc/src/model/RequestLoginInfoRequest.cc +++ b/ccc/src/model/RequestLoginInfoRequest.cc @@ -38,6 +38,17 @@ void RequestLoginInfoRequest::setInstanceId(const std::string& instanceId) setParameter("InstanceId", instanceId); } +std::string RequestLoginInfoRequest::getUserId()const +{ + return userId_; +} + +void RequestLoginInfoRequest::setUserId(const std::string& userId) +{ + userId_ = userId; + setParameter("UserId", userId); +} + std::string RequestLoginInfoRequest::getAccessKeyId()const { return accessKeyId_; diff --git a/ccc/src/model/ResetUserStatusRequest.cc b/ccc/src/model/ResetUserStatusRequest.cc index a90e1b6da..b79a1438d 100644 --- a/ccc/src/model/ResetUserStatusRequest.cc +++ b/ccc/src/model/ResetUserStatusRequest.cc @@ -38,6 +38,19 @@ void ResetUserStatusRequest::setInstanceId(const std::string& instanceId) setParameter("InstanceId", instanceId); } +std::vector ResetUserStatusRequest::getRamIdList()const +{ + return ramIdList_; +} + +void ResetUserStatusRequest::setRamIdList(const std::vector& ramIdList) +{ + ramIdList_ = ramIdList; + for(int dep1 = 0; dep1!= ramIdList.size(); dep1++) { + setParameter("RamIdList."+ std::to_string(dep1), std::to_string(ramIdList.at(dep1))); + } +} + std::string ResetUserStatusRequest::getAccessKeyId()const { return accessKeyId_;