1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update to support new apis.

Browse Source
This commit is contained in:
sdk-team
2023-10-30 03:33:38 +00:00
parent 2b84cadd9d
commit d486290c14
88 changed files with 6208 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

756
live/src/LiveClient.cc
View File

@@ -1455,6 +1455,78 @@ LiveClient::CancelMuteGroupUserOutcomeCallable LiveClient::cancelMuteGroupUserCa
return task->get_future();
}
LiveClient::CheckLiveMessageUsersInGroupOutcome LiveClient::checkLiveMessageUsersInGroup(const CheckLiveMessageUsersInGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CheckLiveMessageUsersInGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CheckLiveMessageUsersInGroupOutcome(CheckLiveMessageUsersInGroupResult(outcome.result()));
else
return CheckLiveMessageUsersInGroupOutcome(outcome.error());
}
void LiveClient::checkLiveMessageUsersInGroupAsync(const CheckLiveMessageUsersInGroupRequest& request, const CheckLiveMessageUsersInGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, checkLiveMessageUsersInGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::CheckLiveMessageUsersInGroupOutcomeCallable LiveClient::checkLiveMessageUsersInGroupCallable(const CheckLiveMessageUsersInGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CheckLiveMessageUsersInGroupOutcome()>>(
[this, request]()
{
return this->checkLiveMessageUsersInGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::CheckLiveMessageUsersOnlineOutcome LiveClient::checkLiveMessageUsersOnline(const CheckLiveMessageUsersOnlineRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CheckLiveMessageUsersOnlineOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CheckLiveMessageUsersOnlineOutcome(CheckLiveMessageUsersOnlineResult(outcome.result()));
else
return CheckLiveMessageUsersOnlineOutcome(outcome.error());
}
void LiveClient::checkLiveMessageUsersOnlineAsync(const CheckLiveMessageUsersOnlineRequest& request, const CheckLiveMessageUsersOnlineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, checkLiveMessageUsersOnline(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::CheckLiveMessageUsersOnlineOutcomeCallable LiveClient::checkLiveMessageUsersOnlineCallable(const CheckLiveMessageUsersOnlineRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CheckLiveMessageUsersOnlineOutcome()>>(
[this, request]()
{
return this->checkLiveMessageUsersOnline(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::CloseLiveShiftOutcome LiveClient::closeLiveShift(const CloseLiveShiftRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1743,6 +1815,78 @@ LiveClient::CreateLiveDelayConfigOutcomeCallable LiveClient::createLiveDelayConf
return task->get_future();
}
LiveClient::CreateLiveMessageAppOutcome LiveClient::createLiveMessageApp(const CreateLiveMessageAppRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateLiveMessageAppOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateLiveMessageAppOutcome(CreateLiveMessageAppResult(outcome.result()));
else
return CreateLiveMessageAppOutcome(outcome.error());
}
void LiveClient::createLiveMessageAppAsync(const CreateLiveMessageAppRequest& request, const CreateLiveMessageAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createLiveMessageApp(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::CreateLiveMessageAppOutcomeCallable LiveClient::createLiveMessageAppCallable(const CreateLiveMessageAppRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateLiveMessageAppOutcome()>>(
[this, request]()
{
return this->createLiveMessageApp(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::CreateLiveMessageGroupOutcome LiveClient::createLiveMessageGroup(const CreateLiveMessageGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateLiveMessageGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateLiveMessageGroupOutcome(CreateLiveMessageGroupResult(outcome.result()));
else
return CreateLiveMessageGroupOutcome(outcome.error());
}
void LiveClient::createLiveMessageGroupAsync(const CreateLiveMessageGroupRequest& request, const CreateLiveMessageGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createLiveMessageGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::CreateLiveMessageGroupOutcomeCallable LiveClient::createLiveMessageGroupCallable(const CreateLiveMessageGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateLiveMessageGroupOutcome()>>(
[this, request]()
{
return this->createLiveMessageGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::CreateLiveRealTimeLogDeliveryOutcome LiveClient::createLiveRealTimeLogDelivery(const CreateLiveRealTimeLogDeliveryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2859,6 +3003,42 @@ LiveClient::DeleteLiveLazyPullStreamInfoConfigOutcomeCallable LiveClient::delete
return task->get_future();
}
LiveClient::DeleteLiveMessageGroupOutcome LiveClient::deleteLiveMessageGroup(const DeleteLiveMessageGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteLiveMessageGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteLiveMessageGroupOutcome(DeleteLiveMessageGroupResult(outcome.result()));
else
return DeleteLiveMessageGroupOutcome(outcome.error());
}
void LiveClient::deleteLiveMessageGroupAsync(const DeleteLiveMessageGroupRequest& request, const DeleteLiveMessageGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteLiveMessageGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DeleteLiveMessageGroupOutcomeCallable LiveClient::deleteLiveMessageGroupCallable(const DeleteLiveMessageGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteLiveMessageGroupOutcome()>>(
[this, request]()
{
return this->deleteLiveMessageGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DeleteLivePackageConfigOutcome LiveClient::deleteLivePackageConfig(const DeleteLivePackageConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6063,6 +6243,114 @@ LiveClient::DescribeLiveLazyPullStreamConfigOutcomeCallable LiveClient::describe
return task->get_future();
}
LiveClient::DescribeLiveMessageAppOutcome LiveClient::describeLiveMessageApp(const DescribeLiveMessageAppRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveMessageAppOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveMessageAppOutcome(DescribeLiveMessageAppResult(outcome.result()));
else
return DescribeLiveMessageAppOutcome(outcome.error());
}
void LiveClient::describeLiveMessageAppAsync(const DescribeLiveMessageAppRequest& request, const DescribeLiveMessageAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveMessageApp(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveMessageAppOutcomeCallable LiveClient::describeLiveMessageAppCallable(const DescribeLiveMessageAppRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveMessageAppOutcome()>>(
[this, request]()
{
return this->describeLiveMessageApp(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveMessageGroupOutcome LiveClient::describeLiveMessageGroup(const DescribeLiveMessageGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveMessageGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveMessageGroupOutcome(DescribeLiveMessageGroupResult(outcome.result()));
else
return DescribeLiveMessageGroupOutcome(outcome.error());
}
void LiveClient::describeLiveMessageGroupAsync(const DescribeLiveMessageGroupRequest& request, const DescribeLiveMessageGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveMessageGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveMessageGroupOutcomeCallable LiveClient::describeLiveMessageGroupCallable(const DescribeLiveMessageGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveMessageGroupOutcome()>>(
[this, request]()
{
return this->describeLiveMessageGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveMessageGroupBandOutcome LiveClient::describeLiveMessageGroupBand(const DescribeLiveMessageGroupBandRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveMessageGroupBandOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveMessageGroupBandOutcome(DescribeLiveMessageGroupBandResult(outcome.result()));
else
return DescribeLiveMessageGroupBandOutcome(outcome.error());
}
void LiveClient::describeLiveMessageGroupBandAsync(const DescribeLiveMessageGroupBandRequest& request, const DescribeLiveMessageGroupBandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveMessageGroupBand(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveMessageGroupBandOutcomeCallable LiveClient::describeLiveMessageGroupBandCallable(const DescribeLiveMessageGroupBandRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveMessageGroupBandOutcome()>>(
[this, request]()
{
return this->describeLiveMessageGroupBand(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLivePackageConfigOutcome LiveClient::describeLivePackageConfig(const DescribeLivePackageConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -9195,6 +9483,42 @@ LiveClient::JoinMessageGroupOutcomeCallable LiveClient::joinMessageGroupCallable
return task->get_future();
}
LiveClient::KickLiveMessageGroupUserOutcome LiveClient::kickLiveMessageGroupUser(const KickLiveMessageGroupUserRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return KickLiveMessageGroupUserOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return KickLiveMessageGroupUserOutcome(KickLiveMessageGroupUserResult(outcome.result()));
else
return KickLiveMessageGroupUserOutcome(outcome.error());
}
void LiveClient::kickLiveMessageGroupUserAsync(const KickLiveMessageGroupUserRequest& request, const KickLiveMessageGroupUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, kickLiveMessageGroupUser(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::KickLiveMessageGroupUserOutcomeCallable LiveClient::kickLiveMessageGroupUserCallable(const KickLiveMessageGroupUserRequest &request) const
{
auto task = std::make_shared<std::packaged_task<KickLiveMessageGroupUserOutcome()>>(
[this, request]()
{
return this->kickLiveMessageGroupUser(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::LeaveMessageGroupOutcome LiveClient::leaveMessageGroup(const LeaveMessageGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -9339,6 +9663,150 @@ LiveClient::ListLiveDelayConfigOutcomeCallable LiveClient::listLiveDelayConfigCa
return task->get_future();
}
LiveClient::ListLiveMessageAppsOutcome LiveClient::listLiveMessageApps(const ListLiveMessageAppsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListLiveMessageAppsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListLiveMessageAppsOutcome(ListLiveMessageAppsResult(outcome.result()));
else
return ListLiveMessageAppsOutcome(outcome.error());
}
void LiveClient::listLiveMessageAppsAsync(const ListLiveMessageAppsRequest& request, const ListLiveMessageAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listLiveMessageApps(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ListLiveMessageAppsOutcomeCallable LiveClient::listLiveMessageAppsCallable(const ListLiveMessageAppsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListLiveMessageAppsOutcome()>>(
[this, request]()
{
return this->listLiveMessageApps(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ListLiveMessageGroupMessagesOutcome LiveClient::listLiveMessageGroupMessages(const ListLiveMessageGroupMessagesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListLiveMessageGroupMessagesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListLiveMessageGroupMessagesOutcome(ListLiveMessageGroupMessagesResult(outcome.result()));
else
return ListLiveMessageGroupMessagesOutcome(outcome.error());
}
void LiveClient::listLiveMessageGroupMessagesAsync(const ListLiveMessageGroupMessagesRequest& request, const ListLiveMessageGroupMessagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listLiveMessageGroupMessages(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ListLiveMessageGroupMessagesOutcomeCallable LiveClient::listLiveMessageGroupMessagesCallable(const ListLiveMessageGroupMessagesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListLiveMessageGroupMessagesOutcome()>>(
[this, request]()
{
return this->listLiveMessageGroupMessages(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ListLiveMessageGroupUsersOutcome LiveClient::listLiveMessageGroupUsers(const ListLiveMessageGroupUsersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListLiveMessageGroupUsersOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListLiveMessageGroupUsersOutcome(ListLiveMessageGroupUsersResult(outcome.result()));
else
return ListLiveMessageGroupUsersOutcome(outcome.error());
}
void LiveClient::listLiveMessageGroupUsersAsync(const ListLiveMessageGroupUsersRequest& request, const ListLiveMessageGroupUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listLiveMessageGroupUsers(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ListLiveMessageGroupUsersOutcomeCallable LiveClient::listLiveMessageGroupUsersCallable(const ListLiveMessageGroupUsersRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListLiveMessageGroupUsersOutcome()>>(
[this, request]()
{
return this->listLiveMessageGroupUsers(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ListLiveMessageGroupsOutcome LiveClient::listLiveMessageGroups(const ListLiveMessageGroupsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListLiveMessageGroupsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListLiveMessageGroupsOutcome(ListLiveMessageGroupsResult(outcome.result()));
else
return ListLiveMessageGroupsOutcome(outcome.error());
}
void LiveClient::listLiveMessageGroupsAsync(const ListLiveMessageGroupsRequest& request, const ListLiveMessageGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listLiveMessageGroups(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ListLiveMessageGroupsOutcomeCallable LiveClient::listLiveMessageGroupsCallable(const ListLiveMessageGroupsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListLiveMessageGroupsOutcome()>>(
[this, request]()
{
return this->listLiveMessageGroups(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ListLiveRealtimeLogDeliveryOutcome LiveClient::listLiveRealtimeLogDelivery(const ListLiveRealtimeLogDeliveryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -9915,6 +10383,222 @@ LiveClient::ModifyLiveDomainSchdmByPropertyOutcomeCallable LiveClient::modifyLiv
return task->get_future();
}
LiveClient::ModifyLiveMessageAppAuditOutcome LiveClient::modifyLiveMessageAppAudit(const ModifyLiveMessageAppAuditRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyLiveMessageAppAuditOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyLiveMessageAppAuditOutcome(ModifyLiveMessageAppAuditResult(outcome.result()));
else
return ModifyLiveMessageAppAuditOutcome(outcome.error());
}
void LiveClient::modifyLiveMessageAppAuditAsync(const ModifyLiveMessageAppAuditRequest& request, const ModifyLiveMessageAppAuditAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyLiveMessageAppAudit(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ModifyLiveMessageAppAuditOutcomeCallable LiveClient::modifyLiveMessageAppAuditCallable(const ModifyLiveMessageAppAuditRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyLiveMessageAppAuditOutcome()>>(
[this, request]()
{
return this->modifyLiveMessageAppAudit(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ModifyLiveMessageAppCallbackOutcome LiveClient::modifyLiveMessageAppCallback(const ModifyLiveMessageAppCallbackRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyLiveMessageAppCallbackOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyLiveMessageAppCallbackOutcome(ModifyLiveMessageAppCallbackResult(outcome.result()));
else
return ModifyLiveMessageAppCallbackOutcome(outcome.error());
}
void LiveClient::modifyLiveMessageAppCallbackAsync(const ModifyLiveMessageAppCallbackRequest& request, const ModifyLiveMessageAppCallbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyLiveMessageAppCallback(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ModifyLiveMessageAppCallbackOutcomeCallable LiveClient::modifyLiveMessageAppCallbackCallable(const ModifyLiveMessageAppCallbackRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyLiveMessageAppCallbackOutcome()>>(
[this, request]()
{
return this->modifyLiveMessageAppCallback(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ModifyLiveMessageAppDisableOutcome LiveClient::modifyLiveMessageAppDisable(const ModifyLiveMessageAppDisableRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyLiveMessageAppDisableOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyLiveMessageAppDisableOutcome(ModifyLiveMessageAppDisableResult(outcome.result()));
else
return ModifyLiveMessageAppDisableOutcome(outcome.error());
}
void LiveClient::modifyLiveMessageAppDisableAsync(const ModifyLiveMessageAppDisableRequest& request, const ModifyLiveMessageAppDisableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyLiveMessageAppDisable(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ModifyLiveMessageAppDisableOutcomeCallable LiveClient::modifyLiveMessageAppDisableCallable(const ModifyLiveMessageAppDisableRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyLiveMessageAppDisableOutcome()>>(
[this, request]()
{
return this->modifyLiveMessageAppDisable(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ModifyLiveMessageGroupOutcome LiveClient::modifyLiveMessageGroup(const ModifyLiveMessageGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyLiveMessageGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyLiveMessageGroupOutcome(ModifyLiveMessageGroupResult(outcome.result()));
else
return ModifyLiveMessageGroupOutcome(outcome.error());
}
void LiveClient::modifyLiveMessageGroupAsync(const ModifyLiveMessageGroupRequest& request, const ModifyLiveMessageGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyLiveMessageGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ModifyLiveMessageGroupOutcomeCallable LiveClient::modifyLiveMessageGroupCallable(const ModifyLiveMessageGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyLiveMessageGroupOutcome()>>(
[this, request]()
{
return this->modifyLiveMessageGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ModifyLiveMessageGroupBandOutcome LiveClient::modifyLiveMessageGroupBand(const ModifyLiveMessageGroupBandRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyLiveMessageGroupBandOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyLiveMessageGroupBandOutcome(ModifyLiveMessageGroupBandResult(outcome.result()));
else
return ModifyLiveMessageGroupBandOutcome(outcome.error());
}
void LiveClient::modifyLiveMessageGroupBandAsync(const ModifyLiveMessageGroupBandRequest& request, const ModifyLiveMessageGroupBandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyLiveMessageGroupBand(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ModifyLiveMessageGroupBandOutcomeCallable LiveClient::modifyLiveMessageGroupBandCallable(const ModifyLiveMessageGroupBandRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyLiveMessageGroupBandOutcome()>>(
[this, request]()
{
return this->modifyLiveMessageGroupBand(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ModifyLiveMessageUserInfoOutcome LiveClient::modifyLiveMessageUserInfo(const ModifyLiveMessageUserInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyLiveMessageUserInfoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyLiveMessageUserInfoOutcome(ModifyLiveMessageUserInfoResult(outcome.result()));
else
return ModifyLiveMessageUserInfoOutcome(outcome.error());
}
void LiveClient::modifyLiveMessageUserInfoAsync(const ModifyLiveMessageUserInfoRequest& request, const ModifyLiveMessageUserInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyLiveMessageUserInfo(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ModifyLiveMessageUserInfoOutcomeCallable LiveClient::modifyLiveMessageUserInfoCallable(const ModifyLiveMessageUserInfoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyLiveMessageUserInfoOutcome()>>(
[this, request]()
{
return this->modifyLiveMessageUserInfo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ModifyLiveRealtimeLogDeliveryOutcome LiveClient::modifyLiveRealtimeLogDelivery(const ModifyLiveRealtimeLogDeliveryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -10563,6 +11247,78 @@ LiveClient::SendLikeOutcomeCallable LiveClient::sendLikeCallable(const SendLikeR
return task->get_future();
}
LiveClient::SendLiveMessageGroupOutcome LiveClient::sendLiveMessageGroup(const SendLiveMessageGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SendLiveMessageGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SendLiveMessageGroupOutcome(SendLiveMessageGroupResult(outcome.result()));
else
return SendLiveMessageGroupOutcome(outcome.error());
}
void LiveClient::sendLiveMessageGroupAsync(const SendLiveMessageGroupRequest& request, const SendLiveMessageGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, sendLiveMessageGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::SendLiveMessageGroupOutcomeCallable LiveClient::sendLiveMessageGroupCallable(const SendLiveMessageGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SendLiveMessageGroupOutcome()>>(
[this, request]()
{
return this->sendLiveMessageGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::SendLiveMessageUserOutcome LiveClient::sendLiveMessageUser(const SendLiveMessageUserRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SendLiveMessageUserOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SendLiveMessageUserOutcome(SendLiveMessageUserResult(outcome.result()));
else
return SendLiveMessageUserOutcome(outcome.error());
}
void LiveClient::sendLiveMessageUserAsync(const SendLiveMessageUserRequest& request, const SendLiveMessageUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, sendLiveMessageUser(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::SendLiveMessageUserOutcomeCallable LiveClient::sendLiveMessageUserCallable(const SendLiveMessageUserRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SendLiveMessageUserOutcome()>>(
[this, request]()
{
return this->sendLiveMessageUser(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::SendMessageToGroupOutcome LiveClient::sendMessageToGroup(const SendMessageToGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

65
live/src/model/CheckLiveMessageUsersInGroupRequest.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/CheckLiveMessageUsersInGroupRequest.h>
using AlibabaCloud::Live::Model::CheckLiveMessageUsersInGroupRequest;
CheckLiveMessageUsersInGroupRequest::CheckLiveMessageUsersInGroupRequest()
: RpcServiceRequest("live", "2016-11-01", "CheckLiveMessageUsersInGroup") {
setMethod(HttpRequest::Method::Post);
}
CheckLiveMessageUsersInGroupRequest::~CheckLiveMessageUsersInGroupRequest() {}
std::string CheckLiveMessageUsersInGroupRequest::getGroupId() const {
return groupId_;
}
void CheckLiveMessageUsersInGroupRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::string CheckLiveMessageUsersInGroupRequest::getDataCenter() const {
return dataCenter_;
}
void CheckLiveMessageUsersInGroupRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::vector<CheckLiveMessageUsersInGroupRequest::std::string> CheckLiveMessageUsersInGroupRequest::getUserIds() const {
return userIds_;
}
void CheckLiveMessageUsersInGroupRequest::setUserIds(const std::vector<CheckLiveMessageUsersInGroupRequest::std::string> &userIds) {
userIds_ = userIds;
for(int dep1 = 0; dep1 != userIds.size(); dep1++) {
setParameter(std::string("UserIds") + "." + std::to_string(dep1 + 1), userIds[dep1]);
}
}
std::string CheckLiveMessageUsersInGroupRequest::getAppId() const {
return appId_;
}
void CheckLiveMessageUsersInGroupRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}

59
live/src/model/CheckLiveMessageUsersInGroupResult.cc Normal file
View File

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

56
live/src/model/CheckLiveMessageUsersOnlineRequest.cc Normal file
View File

@@ -0,0 +1,56 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/CheckLiveMessageUsersOnlineRequest.h>
using AlibabaCloud::Live::Model::CheckLiveMessageUsersOnlineRequest;
CheckLiveMessageUsersOnlineRequest::CheckLiveMessageUsersOnlineRequest()
: RpcServiceRequest("live", "2016-11-01", "CheckLiveMessageUsersOnline") {
setMethod(HttpRequest::Method::Post);
}
CheckLiveMessageUsersOnlineRequest::~CheckLiveMessageUsersOnlineRequest() {}
std::string CheckLiveMessageUsersOnlineRequest::getDataCenter() const {
return dataCenter_;
}
void CheckLiveMessageUsersOnlineRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::vector<CheckLiveMessageUsersOnlineRequest::std::string> CheckLiveMessageUsersOnlineRequest::getUserIds() const {
return userIds_;
}
void CheckLiveMessageUsersOnlineRequest::setUserIds(const std::vector<CheckLiveMessageUsersOnlineRequest::std::string> &userIds) {
userIds_ = userIds;
for(int dep1 = 0; dep1 != userIds.size(); dep1++) {
setParameter(std::string("UserIds") + "." + std::to_string(dep1 + 1), userIds[dep1]);
}
}
std::string CheckLiveMessageUsersOnlineRequest::getAppId() const {
return appId_;
}
void CheckLiveMessageUsersOnlineRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}

59
live/src/model/CheckLiveMessageUsersOnlineResult.cc Normal file
View File

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

72
live/src/model/CreateLiveMessageAppRequest.cc Normal file
View File

@@ -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 <alibabacloud/live/model/CreateLiveMessageAppRequest.h>
using AlibabaCloud::Live::Model::CreateLiveMessageAppRequest;
CreateLiveMessageAppRequest::CreateLiveMessageAppRequest()
: RpcServiceRequest("live", "2016-11-01", "CreateLiveMessageApp") {
setMethod(HttpRequest::Method::Post);
}
CreateLiveMessageAppRequest::~CreateLiveMessageAppRequest() {}
std::string CreateLiveMessageAppRequest::getDataCenter() const {
return dataCenter_;
}
void CreateLiveMessageAppRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string CreateLiveMessageAppRequest::getAppName() const {
return appName_;
}
void CreateLiveMessageAppRequest::setAppName(const std::string &appName) {
appName_ = appName;
setParameter(std::string("AppName"), appName);
}
int CreateLiveMessageAppRequest::getAuditType() const {
return auditType_;
}
void CreateLiveMessageAppRequest::setAuditType(int auditType) {
auditType_ = auditType;
setParameter(std::string("AuditType"), std::to_string(auditType));
}
std::string CreateLiveMessageAppRequest::getAuditUrl() const {
return auditUrl_;
}
void CreateLiveMessageAppRequest::setAuditUrl(const std::string &auditUrl) {
auditUrl_ = auditUrl;
setParameter(std::string("AuditUrl"), auditUrl);
}
std::string CreateLiveMessageAppRequest::getEventCallbackUrl() const {
return eventCallbackUrl_;
}
void CreateLiveMessageAppRequest::setEventCallbackUrl(const std::string &eventCallbackUrl) {
eventCallbackUrl_ = eventCallbackUrl;
setParameter(std::string("EventCallbackUrl"), eventCallbackUrl);
}

65
live/src/model/CreateLiveMessageAppResult.cc Normal file
View File

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

92
live/src/model/CreateLiveMessageGroupRequest.cc Normal file
View File

@@ -0,0 +1,92 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/CreateLiveMessageGroupRequest.h>
using AlibabaCloud::Live::Model::CreateLiveMessageGroupRequest;
CreateLiveMessageGroupRequest::CreateLiveMessageGroupRequest()
: RpcServiceRequest("live", "2016-11-01", "CreateLiveMessageGroup") {
setMethod(HttpRequest::Method::Post);
}
CreateLiveMessageGroupRequest::~CreateLiveMessageGroupRequest() {}
std::string CreateLiveMessageGroupRequest::getGroupId() const {
return groupId_;
}
void CreateLiveMessageGroupRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::string CreateLiveMessageGroupRequest::getGroupInfo() const {
return groupInfo_;
}
void CreateLiveMessageGroupRequest::setGroupInfo(const std::string &groupInfo) {
groupInfo_ = groupInfo;
setParameter(std::string("GroupInfo"), groupInfo);
}
std::string CreateLiveMessageGroupRequest::getCreatorId() const {
return creatorId_;
}
void CreateLiveMessageGroupRequest::setCreatorId(const std::string &creatorId) {
creatorId_ = creatorId;
setParameter(std::string("CreatorId"), creatorId);
}
std::string CreateLiveMessageGroupRequest::getDataCenter() const {
return dataCenter_;
}
void CreateLiveMessageGroupRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string CreateLiveMessageGroupRequest::getGroupName() const {
return groupName_;
}
void CreateLiveMessageGroupRequest::setGroupName(const std::string &groupName) {
groupName_ = groupName;
setParameter(std::string("GroupName"), groupName);
}
std::string CreateLiveMessageGroupRequest::getAppId() const {
return appId_;
}
void CreateLiveMessageGroupRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
std::vector<CreateLiveMessageGroupRequest::std::string> CreateLiveMessageGroupRequest::getAdministrators() const {
return administrators_;
}
void CreateLiveMessageGroupRequest::setAdministrators(const std::vector<CreateLiveMessageGroupRequest::std::string> &administrators) {
administrators_ = administrators;
for(int dep1 = 0; dep1 != administrators.size(); dep1++) {
setParameter(std::string("Administrators") + "." + std::to_string(dep1 + 1), administrators[dep1]);
}
}

65
live/src/model/CreateLiveMessageGroupResult.cc Normal file
View File

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

63
live/src/model/DeleteLiveMessageGroupRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/DeleteLiveMessageGroupRequest.h>
using AlibabaCloud::Live::Model::DeleteLiveMessageGroupRequest;
DeleteLiveMessageGroupRequest::DeleteLiveMessageGroupRequest()
: RpcServiceRequest("live", "2016-11-01", "DeleteLiveMessageGroup") {
setMethod(HttpRequest::Method::Post);
}
DeleteLiveMessageGroupRequest::~DeleteLiveMessageGroupRequest() {}
std::string DeleteLiveMessageGroupRequest::getGroupId() const {
return groupId_;
}
void DeleteLiveMessageGroupRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::string DeleteLiveMessageGroupRequest::getDataCenter() const {
return dataCenter_;
}
void DeleteLiveMessageGroupRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string DeleteLiveMessageGroupRequest::getAppId() const {
return appId_;
}
void DeleteLiveMessageGroupRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
std::string DeleteLiveMessageGroupRequest::getOperatorId() const {
return operatorId_;
}
void DeleteLiveMessageGroupRequest::setOperatorId(const std::string &operatorId) {
operatorId_ = operatorId;
setParameter(std::string("OperatorId"), operatorId);
}

51
live/src/model/DeleteLiveMessageGroupResult.cc Normal file
View File

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

45
live/src/model/DescribeLiveMessageAppRequest.cc Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/DescribeLiveMessageAppRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveMessageAppRequest;
DescribeLiveMessageAppRequest::DescribeLiveMessageAppRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeLiveMessageApp") {
setMethod(HttpRequest::Method::Post);
}
DescribeLiveMessageAppRequest::~DescribeLiveMessageAppRequest() {}
std::string DescribeLiveMessageAppRequest::getDataCenter() const {
return dataCenter_;
}
void DescribeLiveMessageAppRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string DescribeLiveMessageAppRequest::getAppId() const {
return appId_;
}
void DescribeLiveMessageAppRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}

93
live/src/model/DescribeLiveMessageAppResult.cc Normal file
View File

@@ -0,0 +1,93 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/DescribeLiveMessageAppResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLiveMessageAppResult::DescribeLiveMessageAppResult() :
ServiceResult()
{}
DescribeLiveMessageAppResult::DescribeLiveMessageAppResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLiveMessageAppResult::~DescribeLiveMessageAppResult()
{}
void DescribeLiveMessageAppResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AppId"].isNull())
appId_ = value["AppId"].asString();
if(!value["AppKey"].isNull())
appKey_ = value["AppKey"].asString();
if(!value["AppSign"].isNull())
appSign_ = value["AppSign"].asString();
if(!value["AuditType"].isNull())
auditType_ = std::stoi(value["AuditType"].asString());
if(!value["AuditUrl"].isNull())
auditUrl_ = value["AuditUrl"].asString();
if(!value["CallbackUrl"].isNull())
callbackUrl_ = value["CallbackUrl"].asString();
if(!value["Disable"].isNull())
disable_ = value["Disable"].asString() == "true";
}
std::string DescribeLiveMessageAppResult::getCallbackUrl()const
{
return callbackUrl_;
}
std::string DescribeLiveMessageAppResult::getAuditUrl()const
{
return auditUrl_;
}
std::string DescribeLiveMessageAppResult::getAppId()const
{
return appId_;
}
int DescribeLiveMessageAppResult::getAuditType()const
{
return auditType_;
}
std::string DescribeLiveMessageAppResult::getAppKey()const
{
return appKey_;
}
std::string DescribeLiveMessageAppResult::getAppSign()const
{
return appSign_;
}
bool DescribeLiveMessageAppResult::getDisable()const
{
return disable_;
}

54
live/src/model/DescribeLiveMessageGroupBandRequest.cc Normal file
View File

@@ -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.
*/
#include <alibabacloud/live/model/DescribeLiveMessageGroupBandRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveMessageGroupBandRequest;
DescribeLiveMessageGroupBandRequest::DescribeLiveMessageGroupBandRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeLiveMessageGroupBand") {
setMethod(HttpRequest::Method::Post);
}
DescribeLiveMessageGroupBandRequest::~DescribeLiveMessageGroupBandRequest() {}
std::string DescribeLiveMessageGroupBandRequest::getGroupId() const {
return groupId_;
}
void DescribeLiveMessageGroupBandRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::string DescribeLiveMessageGroupBandRequest::getDataCenter() const {
return dataCenter_;
}
void DescribeLiveMessageGroupBandRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string DescribeLiveMessageGroupBandRequest::getAppId() const {
return appId_;
}
void DescribeLiveMessageGroupBandRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}

74
live/src/model/DescribeLiveMessageGroupBandResult.cc Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/DescribeLiveMessageGroupBandResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLiveMessageGroupBandResult::DescribeLiveMessageGroupBandResult() :
ServiceResult()
{}
DescribeLiveMessageGroupBandResult::DescribeLiveMessageGroupBandResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLiveMessageGroupBandResult::~DescribeLiveMessageGroupBandResult()
{}
void DescribeLiveMessageGroupBandResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allBannedUserList = value["BannedUserList"]["BannedUsers"];
for (const auto &item : allBannedUserList)
bannedUserList_.push_back(item.asString());
auto allUnbannedUserList = value["UnbannedUserList"]["UnbannedUsers"];
for (const auto &item : allUnbannedUserList)
unbannedUserList_.push_back(item.asString());
if(!value["GroupId"].isNull())
groupId_ = value["GroupId"].asString();
if(!value["IsbannedAll"].isNull())
isbannedAll_ = value["IsbannedAll"].asString() == "true";
}
bool DescribeLiveMessageGroupBandResult::getIsbannedAll()const
{
return isbannedAll_;
}
std::vector<std::string> DescribeLiveMessageGroupBandResult::getBannedUserList()const
{
return bannedUserList_;
}
std::vector<std::string> DescribeLiveMessageGroupBandResult::getUnbannedUserList()const
{
return unbannedUserList_;
}
std::string DescribeLiveMessageGroupBandResult::getGroupId()const
{
return groupId_;
}

54
live/src/model/DescribeLiveMessageGroupRequest.cc Normal file
View File

@@ -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.
*/
#include <alibabacloud/live/model/DescribeLiveMessageGroupRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveMessageGroupRequest;
DescribeLiveMessageGroupRequest::DescribeLiveMessageGroupRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeLiveMessageGroup") {
setMethod(HttpRequest::Method::Post);
}
DescribeLiveMessageGroupRequest::~DescribeLiveMessageGroupRequest() {}
std::string DescribeLiveMessageGroupRequest::getGroupId() const {
return groupId_;
}
void DescribeLiveMessageGroupRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::string DescribeLiveMessageGroupRequest::getDataCenter() const {
return dataCenter_;
}
void DescribeLiveMessageGroupRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string DescribeLiveMessageGroupRequest::getAppId() const {
return appId_;
}
void DescribeLiveMessageGroupRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}

129
live/src/model/DescribeLiveMessageGroupResult.cc Normal file
View File

@@ -0,0 +1,129 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/DescribeLiveMessageGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLiveMessageGroupResult::DescribeLiveMessageGroupResult() :
ServiceResult()
{}
DescribeLiveMessageGroupResult::DescribeLiveMessageGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLiveMessageGroupResult::~DescribeLiveMessageGroupResult()
{}
void DescribeLiveMessageGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allAdminList = value["AdminList"]["Admins"];
for (const auto &item : allAdminList)
adminList_.push_back(item.asString());
if(!value["GroupId"].isNull())
groupId_ = value["GroupId"].asString();
if(!value["CreatorId"].isNull())
creatorId_ = value["CreatorId"].asString();
if(!value["Createtime"].isNull())
createtime_ = std::stol(value["Createtime"].asString());
if(!value["GroupName"].isNull())
groupName_ = value["GroupName"].asString();
if(!value["GroupInfo"].isNull())
groupInfo_ = value["GroupInfo"].asString();
if(!value["Delete"].isNull())
_delete_ = value["Delete"].asString() == "true";
if(!value["TotalTimes"].isNull())
totalTimes_ = std::stol(value["TotalTimes"].asString());
if(!value["OnlineUserCounts"].isNull())
onlineUserCounts_ = std::stol(value["OnlineUserCounts"].asString());
if(!value["MsgAmount"].isNull())
msgAmount_ = value["MsgAmount"].asString();
if(!value["Deletatime"].isNull())
deletatime_ = std::stol(value["Deletatime"].asString());
if(!value["Deletor"].isNull())
deletor_ = value["Deletor"].asString();
}
std::string DescribeLiveMessageGroupResult::getGroupName()const
{
return groupName_;
}
std::vector<std::string> DescribeLiveMessageGroupResult::getAdminList()const
{
return adminList_;
}
bool DescribeLiveMessageGroupResult::get_Delete()const
{
return _delete_;
}
long DescribeLiveMessageGroupResult::getDeletatime()const
{
return deletatime_;
}
long DescribeLiveMessageGroupResult::getTotalTimes()const
{
return totalTimes_;
}
std::string DescribeLiveMessageGroupResult::getMsgAmount()const
{
return msgAmount_;
}
long DescribeLiveMessageGroupResult::getCreatetime()const
{
return createtime_;
}
std::string DescribeLiveMessageGroupResult::getGroupInfo()const
{
return groupInfo_;
}
std::string DescribeLiveMessageGroupResult::getCreatorId()const
{
return creatorId_;
}
long DescribeLiveMessageGroupResult::getOnlineUserCounts()const
{
return onlineUserCounts_;
}
std::string DescribeLiveMessageGroupResult::getGroupId()const
{
return groupId_;
}
std::string DescribeLiveMessageGroupResult::getDeletor()const
{
return deletor_;
}

63
live/src/model/KickLiveMessageGroupUserRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/KickLiveMessageGroupUserRequest.h>
using AlibabaCloud::Live::Model::KickLiveMessageGroupUserRequest;
KickLiveMessageGroupUserRequest::KickLiveMessageGroupUserRequest()
: RpcServiceRequest("live", "2016-11-01", "KickLiveMessageGroupUser") {
setMethod(HttpRequest::Method::Post);
}
KickLiveMessageGroupUserRequest::~KickLiveMessageGroupUserRequest() {}
std::string KickLiveMessageGroupUserRequest::getGroupId() const {
return groupId_;
}
void KickLiveMessageGroupUserRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::string KickLiveMessageGroupUserRequest::getDataCenter() const {
return dataCenter_;
}
void KickLiveMessageGroupUserRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string KickLiveMessageGroupUserRequest::getKickoffUser() const {
return kickoffUser_;
}
void KickLiveMessageGroupUserRequest::setKickoffUser(const std::string &kickoffUser) {
kickoffUser_ = kickoffUser;
setParameter(std::string("KickoffUser"), kickoffUser);
}
std::string KickLiveMessageGroupUserRequest::getAppId() const {
return appId_;
}
void KickLiveMessageGroupUserRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}

44
live/src/model/KickLiveMessageGroupUserResult.cc Normal file
View File

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

54
live/src/model/ListLiveMessageAppsRequest.cc Normal file
View File

@@ -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.
*/
#include <alibabacloud/live/model/ListLiveMessageAppsRequest.h>
using AlibabaCloud::Live::Model::ListLiveMessageAppsRequest;
ListLiveMessageAppsRequest::ListLiveMessageAppsRequest()
: RpcServiceRequest("live", "2016-11-01", "ListLiveMessageApps") {
setMethod(HttpRequest::Method::Post);
}
ListLiveMessageAppsRequest::~ListLiveMessageAppsRequest() {}
int ListLiveMessageAppsRequest::getSortType() const {
return sortType_;
}
void ListLiveMessageAppsRequest::setSortType(int sortType) {
sortType_ = sortType;
setParameter(std::string("SortType"), std::to_string(sortType));
}
long ListLiveMessageAppsRequest::getNextPageToken() const {
return nextPageToken_;
}
void ListLiveMessageAppsRequest::setNextPageToken(long nextPageToken) {
nextPageToken_ = nextPageToken;
setParameter(std::string("NextPageToken"), std::to_string(nextPageToken));
}
std::string ListLiveMessageAppsRequest::getDataCenter() const {
return dataCenter_;
}
void ListLiveMessageAppsRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}

77
live/src/model/ListLiveMessageAppsResult.cc Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/ListLiveMessageAppsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
ListLiveMessageAppsResult::ListLiveMessageAppsResult() :
ServiceResult()
{}
ListLiveMessageAppsResult::ListLiveMessageAppsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListLiveMessageAppsResult::~ListLiveMessageAppsResult()
{}
void ListLiveMessageAppsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allAppListNode = value["AppList"]["Apps"];
for (auto valueAppListApps : allAppListNode)
{
Apps appListObject;
if(!valueAppListApps["AppId"].isNull())
appListObject.appId = valueAppListApps["AppId"].asString();
if(!valueAppListApps["AppKey"].isNull())
appListObject.appKey = valueAppListApps["AppKey"].asString();
if(!valueAppListApps["AppSign"].isNull())
appListObject.appSign = valueAppListApps["AppSign"].asString();
if(!valueAppListApps["Disable"].isNull())
appListObject.disable = valueAppListApps["Disable"].asString();
appList_.push_back(appListObject);
}
if(!value["HasMore"].isNull())
hasMore_ = value["HasMore"].asString() == "true";
if(!value["NextPageToken"].isNull())
nextPageToken_ = std::stol(value["NextPageToken"].asString());
}
bool ListLiveMessageAppsResult::getHasMore()const
{
return hasMore_;
}
long ListLiveMessageAppsResult::getNextPageToken()const
{
return nextPageToken_;
}
std::vector<ListLiveMessageAppsResult::Apps> ListLiveMessageAppsResult::getAppList()const
{
return appList_;
}

108
live/src/model/ListLiveMessageGroupMessagesRequest.cc Normal file
View File

@@ -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 <alibabacloud/live/model/ListLiveMessageGroupMessagesRequest.h>
using AlibabaCloud::Live::Model::ListLiveMessageGroupMessagesRequest;
ListLiveMessageGroupMessagesRequest::ListLiveMessageGroupMessagesRequest()
: RpcServiceRequest("live", "2016-11-01", "ListLiveMessageGroupMessages") {
setMethod(HttpRequest::Method::Post);
}
ListLiveMessageGroupMessagesRequest::~ListLiveMessageGroupMessagesRequest() {}
int ListLiveMessageGroupMessagesRequest::getSortType() const {
return sortType_;
}
void ListLiveMessageGroupMessagesRequest::setSortType(int sortType) {
sortType_ = sortType;
setParameter(std::string("SortType"), std::to_string(sortType));
}
long ListLiveMessageGroupMessagesRequest::getNextPageToken() const {
return nextPageToken_;
}
void ListLiveMessageGroupMessagesRequest::setNextPageToken(long nextPageToken) {
nextPageToken_ = nextPageToken;
setParameter(std::string("NextPageToken"), std::to_string(nextPageToken));
}
std::string ListLiveMessageGroupMessagesRequest::getGroupId() const {
return groupId_;
}
void ListLiveMessageGroupMessagesRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
long ListLiveMessageGroupMessagesRequest::getEndTime() const {
return endTime_;
}
void ListLiveMessageGroupMessagesRequest::setEndTime(long endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), std::to_string(endTime));
}
long ListLiveMessageGroupMessagesRequest::getBeginTime() const {
return beginTime_;
}
void ListLiveMessageGroupMessagesRequest::setBeginTime(long beginTime) {
beginTime_ = beginTime;
setParameter(std::string("BeginTime"), std::to_string(beginTime));
}
std::string ListLiveMessageGroupMessagesRequest::getDataCenter() const {
return dataCenter_;
}
void ListLiveMessageGroupMessagesRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string ListLiveMessageGroupMessagesRequest::getAppId() const {
return appId_;
}
void ListLiveMessageGroupMessagesRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
int ListLiveMessageGroupMessagesRequest::getPageSize() const {
return pageSize_;
}
void ListLiveMessageGroupMessagesRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
long ListLiveMessageGroupMessagesRequest::getMsgType() const {
return msgType_;
}
void ListLiveMessageGroupMessagesRequest::setMsgType(long msgType) {
msgType_ = msgType;
setParameter(std::string("MsgType"), std::to_string(msgType));
}

93
live/src/model/ListLiveMessageGroupMessagesResult.cc Normal file
View File

@@ -0,0 +1,93 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/ListLiveMessageGroupMessagesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
ListLiveMessageGroupMessagesResult::ListLiveMessageGroupMessagesResult() :
ServiceResult()
{}
ListLiveMessageGroupMessagesResult::ListLiveMessageGroupMessagesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListLiveMessageGroupMessagesResult::~ListLiveMessageGroupMessagesResult()
{}
void ListLiveMessageGroupMessagesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMessageListNode = value["MessageList"]["Messages"];
for (auto valueMessageListMessages : allMessageListNode)
{
Messages messageListObject;
if(!valueMessageListMessages["Body"].isNull())
messageListObject.body = valueMessageListMessages["Body"].asString();
if(!valueMessageListMessages["Timestamp"].isNull())
messageListObject.timestamp = std::stol(valueMessageListMessages["Timestamp"].asString());
if(!valueMessageListMessages["MsgTid"].isNull())
messageListObject.msgTid = valueMessageListMessages["MsgTid"].asString();
if(!valueMessageListMessages["MsgType"].isNull())
messageListObject.msgType = std::stol(valueMessageListMessages["MsgType"].asString());
if(!valueMessageListMessages["SeqNumber"].isNull())
messageListObject.seqNumber = std::stol(valueMessageListMessages["SeqNumber"].asString());
if(!valueMessageListMessages["TotalMessages"].isNull())
messageListObject.totalMessages = std::stol(valueMessageListMessages["TotalMessages"].asString());
auto senderNode = value["Sender"];
if(!senderNode["UserId"].isNull())
messageListObject.sender.userId = senderNode["UserId"].asString();
if(!senderNode["UserInfo"].isNull())
messageListObject.sender.userInfo = senderNode["UserInfo"].asString();
messageList_.push_back(messageListObject);
}
if(!value["GroupId"].isNull())
groupId_ = value["GroupId"].asString();
if(!value["NextPageToken"].isNull())
nextPageToken_ = std::stol(value["NextPageToken"].asString());
if(!value["Hasmore"].isNull())
hasmore_ = value["Hasmore"].asString() == "true";
}
bool ListLiveMessageGroupMessagesResult::getHasmore()const
{
return hasmore_;
}
long ListLiveMessageGroupMessagesResult::getNextPageToken()const
{
return nextPageToken_;
}
std::vector<ListLiveMessageGroupMessagesResult::Messages> ListLiveMessageGroupMessagesResult::getMessageList()const
{
return messageList_;
}
std::string ListLiveMessageGroupMessagesResult::getGroupId()const
{
return groupId_;
}

81
live/src/model/ListLiveMessageGroupUsersRequest.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/ListLiveMessageGroupUsersRequest.h>
using AlibabaCloud::Live::Model::ListLiveMessageGroupUsersRequest;
ListLiveMessageGroupUsersRequest::ListLiveMessageGroupUsersRequest()
: RpcServiceRequest("live", "2016-11-01", "ListLiveMessageGroupUsers") {
setMethod(HttpRequest::Method::Post);
}
ListLiveMessageGroupUsersRequest::~ListLiveMessageGroupUsersRequest() {}
int ListLiveMessageGroupUsersRequest::getSortType() const {
return sortType_;
}
void ListLiveMessageGroupUsersRequest::setSortType(int sortType) {
sortType_ = sortType;
setParameter(std::string("SortType"), std::to_string(sortType));
}
long ListLiveMessageGroupUsersRequest::getNextPageToken() const {
return nextPageToken_;
}
void ListLiveMessageGroupUsersRequest::setNextPageToken(long nextPageToken) {
nextPageToken_ = nextPageToken;
setParameter(std::string("NextPageToken"), std::to_string(nextPageToken));
}
std::string ListLiveMessageGroupUsersRequest::getGroupId() const {
return groupId_;
}
void ListLiveMessageGroupUsersRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::string ListLiveMessageGroupUsersRequest::getDataCenter() const {
return dataCenter_;
}
void ListLiveMessageGroupUsersRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string ListLiveMessageGroupUsersRequest::getAppId() const {
return appId_;
}
void ListLiveMessageGroupUsersRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
int ListLiveMessageGroupUsersRequest::getPageSize() const {
return pageSize_;
}
void ListLiveMessageGroupUsersRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}

80
live/src/model/ListLiveMessageGroupUsersResult.cc Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/ListLiveMessageGroupUsersResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
ListLiveMessageGroupUsersResult::ListLiveMessageGroupUsersResult() :
ServiceResult()
{}
ListLiveMessageGroupUsersResult::ListLiveMessageGroupUsersResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListLiveMessageGroupUsersResult::~ListLiveMessageGroupUsersResult()
{}
void ListLiveMessageGroupUsersResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allUserListNode = value["UserList"]["Users"];
for (auto valueUserListUsers : allUserListNode)
{
Users userListObject;
if(!valueUserListUsers["UserId"].isNull())
userListObject.userId = valueUserListUsers["UserId"].asString();
if(!valueUserListUsers["UserInfo"].isNull())
userListObject.userInfo = valueUserListUsers["UserInfo"].asString();
userList_.push_back(userListObject);
}
if(!value["GroupId"].isNull())
groupId_ = value["GroupId"].asString();
if(!value["NextPageToken"].isNull())
nextPageToken_ = std::stol(value["NextPageToken"].asString());
if(!value["Hasmore"].isNull())
hasmore_ = value["Hasmore"].asString() == "true";
}
bool ListLiveMessageGroupUsersResult::getHasmore()const
{
return hasmore_;
}
long ListLiveMessageGroupUsersResult::getNextPageToken()const
{
return nextPageToken_;
}
std::vector<ListLiveMessageGroupUsersResult::Users> ListLiveMessageGroupUsersResult::getUserList()const
{
return userList_;
}
std::string ListLiveMessageGroupUsersResult::getGroupId()const
{
return groupId_;
}

63
live/src/model/ListLiveMessageGroupsRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/ListLiveMessageGroupsRequest.h>
using AlibabaCloud::Live::Model::ListLiveMessageGroupsRequest;
ListLiveMessageGroupsRequest::ListLiveMessageGroupsRequest()
: RpcServiceRequest("live", "2016-11-01", "ListLiveMessageGroups") {
setMethod(HttpRequest::Method::Post);
}
ListLiveMessageGroupsRequest::~ListLiveMessageGroupsRequest() {}
int ListLiveMessageGroupsRequest::getSortType() const {
return sortType_;
}
void ListLiveMessageGroupsRequest::setSortType(int sortType) {
sortType_ = sortType;
setParameter(std::string("SortType"), std::to_string(sortType));
}
long ListLiveMessageGroupsRequest::getNextPageToken() const {
return nextPageToken_;
}
void ListLiveMessageGroupsRequest::setNextPageToken(long nextPageToken) {
nextPageToken_ = nextPageToken;
setParameter(std::string("NextPageToken"), std::to_string(nextPageToken));
}
std::string ListLiveMessageGroupsRequest::getDataCenter() const {
return dataCenter_;
}
void ListLiveMessageGroupsRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string ListLiveMessageGroupsRequest::getAppId() const {
return appId_;
}
void ListLiveMessageGroupsRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}

84
live/src/model/ListLiveMessageGroupsResult.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/ListLiveMessageGroupsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
ListLiveMessageGroupsResult::ListLiveMessageGroupsResult() :
ServiceResult()
{}
ListLiveMessageGroupsResult::ListLiveMessageGroupsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListLiveMessageGroupsResult::~ListLiveMessageGroupsResult()
{}
void ListLiveMessageGroupsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allGroupListNode = value["GroupList"]["Groups"];
for (auto valueGroupListGroups : allGroupListNode)
{
Groups groupListObject;
if(!valueGroupListGroups["GroupId"].isNull())
groupListObject.groupId = valueGroupListGroups["GroupId"].asString();
if(!valueGroupListGroups["CreatorId"].isNull())
groupListObject.creatorId = valueGroupListGroups["CreatorId"].asString();
if(!valueGroupListGroups["Createtime"].isNull())
groupListObject.createtime = std::stol(valueGroupListGroups["Createtime"].asString());
if(!valueGroupListGroups["GroupName"].isNull())
groupListObject.groupName = valueGroupListGroups["GroupName"].asString();
if(!valueGroupListGroups["GroupInfo"].isNull())
groupListObject.groupInfo = valueGroupListGroups["GroupInfo"].asString();
if(!valueGroupListGroups["Delete"].isNull())
groupListObject._delete = valueGroupListGroups["Delete"].asString() == "true";
auto allAdminList = value["AdminList"]["Admins"];
for (auto value : allAdminList)
groupListObject.adminList.push_back(value.asString());
groupList_.push_back(groupListObject);
}
if(!value["Hasmore"].isNull())
hasmore_ = value["Hasmore"].asString() == "true";
if(!value["NextpageToken"].isNull())
nextpageToken_ = value["NextpageToken"].asString();
}
bool ListLiveMessageGroupsResult::getHasmore()const
{
return hasmore_;
}
std::vector<ListLiveMessageGroupsResult::Groups> ListLiveMessageGroupsResult::getGroupList()const
{
return groupList_;
}
std::string ListLiveMessageGroupsResult::getNextpageToken()const
{
return nextpageToken_;
}

63
live/src/model/ModifyLiveMessageAppAuditRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/ModifyLiveMessageAppAuditRequest.h>
using AlibabaCloud::Live::Model::ModifyLiveMessageAppAuditRequest;
ModifyLiveMessageAppAuditRequest::ModifyLiveMessageAppAuditRequest()
: RpcServiceRequest("live", "2016-11-01", "ModifyLiveMessageAppAudit") {
setMethod(HttpRequest::Method::Post);
}
ModifyLiveMessageAppAuditRequest::~ModifyLiveMessageAppAuditRequest() {}
std::string ModifyLiveMessageAppAuditRequest::getDataCenter() const {
return dataCenter_;
}
void ModifyLiveMessageAppAuditRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string ModifyLiveMessageAppAuditRequest::getAppId() const {
return appId_;
}
void ModifyLiveMessageAppAuditRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
int ModifyLiveMessageAppAuditRequest::getAuditType() const {
return auditType_;
}
void ModifyLiveMessageAppAuditRequest::setAuditType(int auditType) {
auditType_ = auditType;
setParameter(std::string("AuditType"), std::to_string(auditType));
}
std::string ModifyLiveMessageAppAuditRequest::getAuditUrl() const {
return auditUrl_;
}
void ModifyLiveMessageAppAuditRequest::setAuditUrl(const std::string &auditUrl) {
auditUrl_ = auditUrl;
setParameter(std::string("AuditUrl"), auditUrl);
}

79
live/src/model/ModifyLiveMessageAppAuditResult.cc Normal file
View File

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

54
live/src/model/ModifyLiveMessageAppCallbackRequest.cc Normal file
View File

@@ -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.
*/
#include <alibabacloud/live/model/ModifyLiveMessageAppCallbackRequest.h>
using AlibabaCloud::Live::Model::ModifyLiveMessageAppCallbackRequest;
ModifyLiveMessageAppCallbackRequest::ModifyLiveMessageAppCallbackRequest()
: RpcServiceRequest("live", "2016-11-01", "ModifyLiveMessageAppCallback") {
setMethod(HttpRequest::Method::Post);
}
ModifyLiveMessageAppCallbackRequest::~ModifyLiveMessageAppCallbackRequest() {}
std::string ModifyLiveMessageAppCallbackRequest::getDataCenter() const {
return dataCenter_;
}
void ModifyLiveMessageAppCallbackRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string ModifyLiveMessageAppCallbackRequest::getAppId() const {
return appId_;
}
void ModifyLiveMessageAppCallbackRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
std::string ModifyLiveMessageAppCallbackRequest::getEventCallbackUrl() const {
return eventCallbackUrl_;
}
void ModifyLiveMessageAppCallbackRequest::setEventCallbackUrl(const std::string &eventCallbackUrl) {
eventCallbackUrl_ = eventCallbackUrl;
setParameter(std::string("EventCallbackUrl"), eventCallbackUrl);
}

72
live/src/model/ModifyLiveMessageAppCallbackResult.cc Normal file
View File

@@ -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 <alibabacloud/live/model/ModifyLiveMessageAppCallbackResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
ModifyLiveMessageAppCallbackResult::ModifyLiveMessageAppCallbackResult() :
ServiceResult()
{}
ModifyLiveMessageAppCallbackResult::ModifyLiveMessageAppCallbackResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ModifyLiveMessageAppCallbackResult::~ModifyLiveMessageAppCallbackResult()
{}
void ModifyLiveMessageAppCallbackResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AppId"].isNull())
appId_ = value["AppId"].asString();
if(!value["AppSign"].isNull())
appSign_ = value["AppSign"].asString();
if(!value["EventCallbackUrl"].isNull())
eventCallbackUrl_ = value["EventCallbackUrl"].asString();
if(!value["EventCallbackNeedAuthentication"].isNull())
eventCallbackNeedAuthentication_ = value["EventCallbackNeedAuthentication"].asString() == "true";
}
std::string ModifyLiveMessageAppCallbackResult::getAppId()const
{
return appId_;
}
bool ModifyLiveMessageAppCallbackResult::getEventCallbackNeedAuthentication()const
{
return eventCallbackNeedAuthentication_;
}
std::string ModifyLiveMessageAppCallbackResult::getEventCallbackUrl()const
{
return eventCallbackUrl_;
}
std::string ModifyLiveMessageAppCallbackResult::getAppSign()const
{
return appSign_;
}

54
live/src/model/ModifyLiveMessageAppDisableRequest.cc Normal file
View File

@@ -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.
*/
#include <alibabacloud/live/model/ModifyLiveMessageAppDisableRequest.h>
using AlibabaCloud::Live::Model::ModifyLiveMessageAppDisableRequest;
ModifyLiveMessageAppDisableRequest::ModifyLiveMessageAppDisableRequest()
: RpcServiceRequest("live", "2016-11-01", "ModifyLiveMessageAppDisable") {
setMethod(HttpRequest::Method::Post);
}
ModifyLiveMessageAppDisableRequest::~ModifyLiveMessageAppDisableRequest() {}
std::string ModifyLiveMessageAppDisableRequest::getDataCenter() const {
return dataCenter_;
}
void ModifyLiveMessageAppDisableRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
bool ModifyLiveMessageAppDisableRequest::getDisable() const {
return disable_;
}
void ModifyLiveMessageAppDisableRequest::setDisable(bool disable) {
disable_ = disable;
setParameter(std::string("Disable"), disable ? "true" : "false");
}
std::string ModifyLiveMessageAppDisableRequest::getAppId() const {
return appId_;
}
void ModifyLiveMessageAppDisableRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}

65
live/src/model/ModifyLiveMessageAppDisableResult.cc Normal file
View File

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

85
live/src/model/ModifyLiveMessageGroupBandRequest.cc Normal file
View File

@@ -0,0 +1,85 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/ModifyLiveMessageGroupBandRequest.h>
using AlibabaCloud::Live::Model::ModifyLiveMessageGroupBandRequest;
ModifyLiveMessageGroupBandRequest::ModifyLiveMessageGroupBandRequest()
: RpcServiceRequest("live", "2016-11-01", "ModifyLiveMessageGroupBand") {
setMethod(HttpRequest::Method::Post);
}
ModifyLiveMessageGroupBandRequest::~ModifyLiveMessageGroupBandRequest() {}
bool ModifyLiveMessageGroupBandRequest::getBannedAll() const {
return bannedAll_;
}
void ModifyLiveMessageGroupBandRequest::setBannedAll(bool bannedAll) {
bannedAll_ = bannedAll;
setParameter(std::string("BannedAll"), bannedAll ? "true" : "false");
}
std::string ModifyLiveMessageGroupBandRequest::getGroupId() const {
return groupId_;
}
void ModifyLiveMessageGroupBandRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::vector<ModifyLiveMessageGroupBandRequest::std::string> ModifyLiveMessageGroupBandRequest::getExceptUsers() const {
return exceptUsers_;
}
void ModifyLiveMessageGroupBandRequest::setExceptUsers(const std::vector<ModifyLiveMessageGroupBandRequest::std::string> &exceptUsers) {
exceptUsers_ = exceptUsers;
for(int dep1 = 0; dep1 != exceptUsers.size(); dep1++) {
setParameter(std::string("ExceptUsers") + "." + std::to_string(dep1 + 1), exceptUsers[dep1]);
}
}
std::string ModifyLiveMessageGroupBandRequest::getDataCenter() const {
return dataCenter_;
}
void ModifyLiveMessageGroupBandRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string ModifyLiveMessageGroupBandRequest::getAppId() const {
return appId_;
}
void ModifyLiveMessageGroupBandRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
std::vector<ModifyLiveMessageGroupBandRequest::std::string> ModifyLiveMessageGroupBandRequest::getBannnedUsers() const {
return bannnedUsers_;
}
void ModifyLiveMessageGroupBandRequest::setBannnedUsers(const std::vector<ModifyLiveMessageGroupBandRequest::std::string> &bannnedUsers) {
bannnedUsers_ = bannnedUsers;
for(int dep1 = 0; dep1 != bannnedUsers.size(); dep1++) {
setParameter(std::string("BannnedUsers") + "." + std::to_string(dep1 + 1), bannnedUsers[dep1]);
}
}

44
live/src/model/ModifyLiveMessageGroupBandResult.cc Normal file
View File

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

92
live/src/model/ModifyLiveMessageGroupRequest.cc Normal file
View File

@@ -0,0 +1,92 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/ModifyLiveMessageGroupRequest.h>
using AlibabaCloud::Live::Model::ModifyLiveMessageGroupRequest;
ModifyLiveMessageGroupRequest::ModifyLiveMessageGroupRequest()
: RpcServiceRequest("live", "2016-11-01", "ModifyLiveMessageGroup") {
setMethod(HttpRequest::Method::Post);
}
ModifyLiveMessageGroupRequest::~ModifyLiveMessageGroupRequest() {}
std::string ModifyLiveMessageGroupRequest::getGroupId() const {
return groupId_;
}
void ModifyLiveMessageGroupRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::string ModifyLiveMessageGroupRequest::getGroupInfo() const {
return groupInfo_;
}
void ModifyLiveMessageGroupRequest::setGroupInfo(const std::string &groupInfo) {
groupInfo_ = groupInfo;
setParameter(std::string("GroupInfo"), groupInfo);
}
std::string ModifyLiveMessageGroupRequest::getDataCenter() const {
return dataCenter_;
}
void ModifyLiveMessageGroupRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
bool ModifyLiveMessageGroupRequest::getModifyInfo() const {
return modifyInfo_;
}
void ModifyLiveMessageGroupRequest::setModifyInfo(bool modifyInfo) {
modifyInfo_ = modifyInfo;
setParameter(std::string("ModifyInfo"), modifyInfo ? "true" : "false");
}
std::vector<ModifyLiveMessageGroupRequest::std::string> ModifyLiveMessageGroupRequest::getAdminList() const {
return adminList_;
}
void ModifyLiveMessageGroupRequest::setAdminList(const std::vector<ModifyLiveMessageGroupRequest::std::string> &adminList) {
adminList_ = adminList;
for(int dep1 = 0; dep1 != adminList.size(); dep1++) {
setParameter(std::string("AdminList") + "." + std::to_string(dep1 + 1), adminList[dep1]);
}
}
std::string ModifyLiveMessageGroupRequest::getAppId() const {
return appId_;
}
void ModifyLiveMessageGroupRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
bool ModifyLiveMessageGroupRequest::getModifyAdmin() const {
return modifyAdmin_;
}
void ModifyLiveMessageGroupRequest::setModifyAdmin(bool modifyAdmin) {
modifyAdmin_ = modifyAdmin;
setParameter(std::string("ModifyAdmin"), modifyAdmin ? "true" : "false");
}

44
live/src/model/ModifyLiveMessageGroupResult.cc Normal file
View File

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

63
live/src/model/ModifyLiveMessageUserInfoRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/ModifyLiveMessageUserInfoRequest.h>
using AlibabaCloud::Live::Model::ModifyLiveMessageUserInfoRequest;
ModifyLiveMessageUserInfoRequest::ModifyLiveMessageUserInfoRequest()
: RpcServiceRequest("live", "2016-11-01", "ModifyLiveMessageUserInfo") {
setMethod(HttpRequest::Method::Post);
}
ModifyLiveMessageUserInfoRequest::~ModifyLiveMessageUserInfoRequest() {}
std::string ModifyLiveMessageUserInfoRequest::getDataCenter() const {
return dataCenter_;
}
void ModifyLiveMessageUserInfoRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string ModifyLiveMessageUserInfoRequest::getUserId() const {
return userId_;
}
void ModifyLiveMessageUserInfoRequest::setUserId(const std::string &userId) {
userId_ = userId;
setParameter(std::string("UserId"), userId);
}
std::string ModifyLiveMessageUserInfoRequest::getUserMetaInfo() const {
return userMetaInfo_;
}
void ModifyLiveMessageUserInfoRequest::setUserMetaInfo(const std::string &userMetaInfo) {
userMetaInfo_ = userMetaInfo;
setParameter(std::string("UserMetaInfo"), userMetaInfo);
}
std::string ModifyLiveMessageUserInfoRequest::getAppId() const {
return appId_;
}
void ModifyLiveMessageUserInfoRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}

44
live/src/model/ModifyLiveMessageUserInfoResult.cc Normal file
View File

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

99
live/src/model/SendLiveMessageGroupRequest.cc Normal file
View File

@@ -0,0 +1,99 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/SendLiveMessageGroupRequest.h>
using AlibabaCloud::Live::Model::SendLiveMessageGroupRequest;
SendLiveMessageGroupRequest::SendLiveMessageGroupRequest()
: RpcServiceRequest("live", "2016-11-01", "SendLiveMessageGroup") {
setMethod(HttpRequest::Method::Post);
}
SendLiveMessageGroupRequest::~SendLiveMessageGroupRequest() {}
std::string SendLiveMessageGroupRequest::getGroupId() const {
return groupId_;
}
void SendLiveMessageGroupRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setParameter(std::string("GroupId"), groupId);
}
std::string SendLiveMessageGroupRequest::getSenderMetaInfo() const {
return senderMetaInfo_;
}
void SendLiveMessageGroupRequest::setSenderMetaInfo(const std::string &senderMetaInfo) {
senderMetaInfo_ = senderMetaInfo;
setParameter(std::string("SenderMetaInfo"), senderMetaInfo);
}
std::string SendLiveMessageGroupRequest::getDataCenter() const {
return dataCenter_;
}
void SendLiveMessageGroupRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string SendLiveMessageGroupRequest::getMsgTid() const {
return msgTid_;
}
void SendLiveMessageGroupRequest::setMsgTid(const std::string &msgTid) {
msgTid_ = msgTid;
setParameter(std::string("MsgTid"), msgTid);
}
std::string SendLiveMessageGroupRequest::getBody() const {
return body_;
}
void SendLiveMessageGroupRequest::setBody(const std::string &body) {
body_ = body;
setParameter(std::string("Body"), body);
}
std::string SendLiveMessageGroupRequest::getSenderId() const {
return senderId_;
}
void SendLiveMessageGroupRequest::setSenderId(const std::string &senderId) {
senderId_ = senderId;
setParameter(std::string("SenderId"), senderId);
}
std::string SendLiveMessageGroupRequest::getAppId() const {
return appId_;
}
void SendLiveMessageGroupRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
long SendLiveMessageGroupRequest::getMsgType() const {
return msgType_;
}
void SendLiveMessageGroupRequest::setMsgType(long msgType) {
msgType_ = msgType;
setParameter(std::string("MsgType"), std::to_string(msgType));
}

44
live/src/model/SendLiveMessageGroupResult.cc Normal file
View File

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

99
live/src/model/SendLiveMessageUserRequest.cc Normal file
View File

@@ -0,0 +1,99 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/SendLiveMessageUserRequest.h>
using AlibabaCloud::Live::Model::SendLiveMessageUserRequest;
SendLiveMessageUserRequest::SendLiveMessageUserRequest()
: RpcServiceRequest("live", "2016-11-01", "SendLiveMessageUser") {
setMethod(HttpRequest::Method::Post);
}
SendLiveMessageUserRequest::~SendLiveMessageUserRequest() {}
std::string SendLiveMessageUserRequest::getDataCenter() const {
return dataCenter_;
}
void SendLiveMessageUserRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
std::string SendLiveMessageUserRequest::getMsgTid() const {
return msgTid_;
}
void SendLiveMessageUserRequest::setMsgTid(const std::string &msgTid) {
msgTid_ = msgTid;
setParameter(std::string("MsgTid"), msgTid);
}
std::string SendLiveMessageUserRequest::getBody() const {
return body_;
}
void SendLiveMessageUserRequest::setBody(const std::string &body) {
body_ = body;
setParameter(std::string("Body"), body);
}
std::string SendLiveMessageUserRequest::getSenderId() const {
return senderId_;
}
void SendLiveMessageUserRequest::setSenderId(const std::string &senderId) {
senderId_ = senderId;
setParameter(std::string("SenderId"), senderId);
}
std::string SendLiveMessageUserRequest::getReceiverId() const {
return receiverId_;
}
void SendLiveMessageUserRequest::setReceiverId(const std::string &receiverId) {
receiverId_ = receiverId;
setParameter(std::string("ReceiverId"), receiverId);
}
std::string SendLiveMessageUserRequest::getAppId() const {
return appId_;
}
void SendLiveMessageUserRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
std::string SendLiveMessageUserRequest::getSenderInfo() const {
return senderInfo_;
}
void SendLiveMessageUserRequest::setSenderInfo(const std::string &senderInfo) {
senderInfo_ = senderInfo;
setParameter(std::string("SenderInfo"), senderInfo);
}
long SendLiveMessageUserRequest::getMsgType() const {
return msgType_;
}
void SendLiveMessageUserRequest::setMsgType(long msgType) {
msgType_ = msgType;
setParameter(std::string("MsgType"), std::to_string(msgType));
}

44
live/src/model/SendLiveMessageUserResult.cc Normal file
View File

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