This commit is contained in:
sdk-team
2023-04-04 07:39:28 +00:00
parent ff586b38ea
commit 8cfb9f0b4d
61 changed files with 4612 additions and 1 deletions

View File

@@ -1 +1 @@
1.36.1525
1.36.1526

138
avatar/CMakeLists.txt Normal file
View File

@@ -0,0 +1,138 @@
#
# 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.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(avatar_public_header
include/alibabacloud/avatar/AvatarClient.h
include/alibabacloud/avatar/AvatarExport.h )
set(avatar_public_header_model
include/alibabacloud/avatar/model/CancelVideoTaskRequest.h
include/alibabacloud/avatar/model/CancelVideoTaskResult.h
include/alibabacloud/avatar/model/CloseTimedResetOperateRequest.h
include/alibabacloud/avatar/model/CloseTimedResetOperateResult.h
include/alibabacloud/avatar/model/DuplexDecisionRequest.h
include/alibabacloud/avatar/model/DuplexDecisionResult.h
include/alibabacloud/avatar/model/GetVideoTaskInfoRequest.h
include/alibabacloud/avatar/model/GetVideoTaskInfoResult.h
include/alibabacloud/avatar/model/LicenseAuthRequest.h
include/alibabacloud/avatar/model/LicenseAuthResult.h
include/alibabacloud/avatar/model/QueryRunningInstanceRequest.h
include/alibabacloud/avatar/model/QueryRunningInstanceResult.h
include/alibabacloud/avatar/model/QueryTimedResetOperateStatusRequest.h
include/alibabacloud/avatar/model/QueryTimedResetOperateStatusResult.h
include/alibabacloud/avatar/model/SendMessageRequest.h
include/alibabacloud/avatar/model/SendMessageResult.h
include/alibabacloud/avatar/model/StartInstanceRequest.h
include/alibabacloud/avatar/model/StartInstanceResult.h
include/alibabacloud/avatar/model/StartTimedResetOperateRequest.h
include/alibabacloud/avatar/model/StartTimedResetOperateResult.h
include/alibabacloud/avatar/model/StopInstanceRequest.h
include/alibabacloud/avatar/model/StopInstanceResult.h
include/alibabacloud/avatar/model/SubmitTextTo2DAvatarVideoTaskRequest.h
include/alibabacloud/avatar/model/SubmitTextTo2DAvatarVideoTaskResult.h
include/alibabacloud/avatar/model/SubmitTextTo3DAvatarVideoTaskRequest.h
include/alibabacloud/avatar/model/SubmitTextTo3DAvatarVideoTaskResult.h
include/alibabacloud/avatar/model/SubmitTextToSignVideoTaskRequest.h
include/alibabacloud/avatar/model/SubmitTextToSignVideoTaskResult.h )
set(avatar_src
src/AvatarClient.cc
src/model/CancelVideoTaskRequest.cc
src/model/CancelVideoTaskResult.cc
src/model/CloseTimedResetOperateRequest.cc
src/model/CloseTimedResetOperateResult.cc
src/model/DuplexDecisionRequest.cc
src/model/DuplexDecisionResult.cc
src/model/GetVideoTaskInfoRequest.cc
src/model/GetVideoTaskInfoResult.cc
src/model/LicenseAuthRequest.cc
src/model/LicenseAuthResult.cc
src/model/QueryRunningInstanceRequest.cc
src/model/QueryRunningInstanceResult.cc
src/model/QueryTimedResetOperateStatusRequest.cc
src/model/QueryTimedResetOperateStatusResult.cc
src/model/SendMessageRequest.cc
src/model/SendMessageResult.cc
src/model/StartInstanceRequest.cc
src/model/StartInstanceResult.cc
src/model/StartTimedResetOperateRequest.cc
src/model/StartTimedResetOperateResult.cc
src/model/StopInstanceRequest.cc
src/model/StopInstanceResult.cc
src/model/SubmitTextTo2DAvatarVideoTaskRequest.cc
src/model/SubmitTextTo2DAvatarVideoTaskResult.cc
src/model/SubmitTextTo3DAvatarVideoTaskRequest.cc
src/model/SubmitTextTo3DAvatarVideoTaskResult.cc
src/model/SubmitTextToSignVideoTaskRequest.cc
src/model/SubmitTextToSignVideoTaskResult.cc )
add_library(avatar ${LIB_TYPE}
${avatar_public_header}
${avatar_public_header_model}
${avatar_src})
set_target_properties(avatar
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}avatar
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(avatar
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_AVATAR_LIBRARY)
endif()
target_include_directories(avatar
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(avatar
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(avatar
jsoncpp)
target_include_directories(avatar
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(avatar
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(avatar
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(avatar
PRIVATE /usr/include/jsoncpp)
target_link_libraries(avatar
jsoncpp)
endif()
install(FILES ${avatar_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/avatar)
install(FILES ${avatar_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/avatar/model)
install(TARGETS avatar
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

View File

@@ -0,0 +1,158 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_AVATARCLIENT_H_
#define ALIBABACLOUD_AVATAR_AVATARCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "AvatarExport.h"
#include "model/CancelVideoTaskRequest.h"
#include "model/CancelVideoTaskResult.h"
#include "model/CloseTimedResetOperateRequest.h"
#include "model/CloseTimedResetOperateResult.h"
#include "model/DuplexDecisionRequest.h"
#include "model/DuplexDecisionResult.h"
#include "model/GetVideoTaskInfoRequest.h"
#include "model/GetVideoTaskInfoResult.h"
#include "model/LicenseAuthRequest.h"
#include "model/LicenseAuthResult.h"
#include "model/QueryRunningInstanceRequest.h"
#include "model/QueryRunningInstanceResult.h"
#include "model/QueryTimedResetOperateStatusRequest.h"
#include "model/QueryTimedResetOperateStatusResult.h"
#include "model/SendMessageRequest.h"
#include "model/SendMessageResult.h"
#include "model/StartInstanceRequest.h"
#include "model/StartInstanceResult.h"
#include "model/StartTimedResetOperateRequest.h"
#include "model/StartTimedResetOperateResult.h"
#include "model/StopInstanceRequest.h"
#include "model/StopInstanceResult.h"
#include "model/SubmitTextTo2DAvatarVideoTaskRequest.h"
#include "model/SubmitTextTo2DAvatarVideoTaskResult.h"
#include "model/SubmitTextTo3DAvatarVideoTaskRequest.h"
#include "model/SubmitTextTo3DAvatarVideoTaskResult.h"
#include "model/SubmitTextToSignVideoTaskRequest.h"
#include "model/SubmitTextToSignVideoTaskResult.h"
namespace AlibabaCloud
{
namespace Avatar
{
class ALIBABACLOUD_AVATAR_EXPORT AvatarClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CancelVideoTaskResult> CancelVideoTaskOutcome;
typedef std::future<CancelVideoTaskOutcome> CancelVideoTaskOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::CancelVideoTaskRequest&, const CancelVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelVideoTaskAsyncHandler;
typedef Outcome<Error, Model::CloseTimedResetOperateResult> CloseTimedResetOperateOutcome;
typedef std::future<CloseTimedResetOperateOutcome> CloseTimedResetOperateOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::CloseTimedResetOperateRequest&, const CloseTimedResetOperateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CloseTimedResetOperateAsyncHandler;
typedef Outcome<Error, Model::DuplexDecisionResult> DuplexDecisionOutcome;
typedef std::future<DuplexDecisionOutcome> DuplexDecisionOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::DuplexDecisionRequest&, const DuplexDecisionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DuplexDecisionAsyncHandler;
typedef Outcome<Error, Model::GetVideoTaskInfoResult> GetVideoTaskInfoOutcome;
typedef std::future<GetVideoTaskInfoOutcome> GetVideoTaskInfoOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::GetVideoTaskInfoRequest&, const GetVideoTaskInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVideoTaskInfoAsyncHandler;
typedef Outcome<Error, Model::LicenseAuthResult> LicenseAuthOutcome;
typedef std::future<LicenseAuthOutcome> LicenseAuthOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::LicenseAuthRequest&, const LicenseAuthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LicenseAuthAsyncHandler;
typedef Outcome<Error, Model::QueryRunningInstanceResult> QueryRunningInstanceOutcome;
typedef std::future<QueryRunningInstanceOutcome> QueryRunningInstanceOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::QueryRunningInstanceRequest&, const QueryRunningInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryRunningInstanceAsyncHandler;
typedef Outcome<Error, Model::QueryTimedResetOperateStatusResult> QueryTimedResetOperateStatusOutcome;
typedef std::future<QueryTimedResetOperateStatusOutcome> QueryTimedResetOperateStatusOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::QueryTimedResetOperateStatusRequest&, const QueryTimedResetOperateStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryTimedResetOperateStatusAsyncHandler;
typedef Outcome<Error, Model::SendMessageResult> SendMessageOutcome;
typedef std::future<SendMessageOutcome> SendMessageOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::SendMessageRequest&, const SendMessageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendMessageAsyncHandler;
typedef Outcome<Error, Model::StartInstanceResult> StartInstanceOutcome;
typedef std::future<StartInstanceOutcome> StartInstanceOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::StartInstanceRequest&, const StartInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartInstanceAsyncHandler;
typedef Outcome<Error, Model::StartTimedResetOperateResult> StartTimedResetOperateOutcome;
typedef std::future<StartTimedResetOperateOutcome> StartTimedResetOperateOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::StartTimedResetOperateRequest&, const StartTimedResetOperateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartTimedResetOperateAsyncHandler;
typedef Outcome<Error, Model::StopInstanceResult> StopInstanceOutcome;
typedef std::future<StopInstanceOutcome> StopInstanceOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::StopInstanceRequest&, const StopInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstanceAsyncHandler;
typedef Outcome<Error, Model::SubmitTextTo2DAvatarVideoTaskResult> SubmitTextTo2DAvatarVideoTaskOutcome;
typedef std::future<SubmitTextTo2DAvatarVideoTaskOutcome> SubmitTextTo2DAvatarVideoTaskOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::SubmitTextTo2DAvatarVideoTaskRequest&, const SubmitTextTo2DAvatarVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitTextTo2DAvatarVideoTaskAsyncHandler;
typedef Outcome<Error, Model::SubmitTextTo3DAvatarVideoTaskResult> SubmitTextTo3DAvatarVideoTaskOutcome;
typedef std::future<SubmitTextTo3DAvatarVideoTaskOutcome> SubmitTextTo3DAvatarVideoTaskOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::SubmitTextTo3DAvatarVideoTaskRequest&, const SubmitTextTo3DAvatarVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitTextTo3DAvatarVideoTaskAsyncHandler;
typedef Outcome<Error, Model::SubmitTextToSignVideoTaskResult> SubmitTextToSignVideoTaskOutcome;
typedef std::future<SubmitTextToSignVideoTaskOutcome> SubmitTextToSignVideoTaskOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::SubmitTextToSignVideoTaskRequest&, const SubmitTextToSignVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitTextToSignVideoTaskAsyncHandler;
AvatarClient(const Credentials &credentials, const ClientConfiguration &configuration);
AvatarClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
AvatarClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~AvatarClient();
CancelVideoTaskOutcome cancelVideoTask(const Model::CancelVideoTaskRequest &request)const;
void cancelVideoTaskAsync(const Model::CancelVideoTaskRequest& request, const CancelVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelVideoTaskOutcomeCallable cancelVideoTaskCallable(const Model::CancelVideoTaskRequest& request) const;
CloseTimedResetOperateOutcome closeTimedResetOperate(const Model::CloseTimedResetOperateRequest &request)const;
void closeTimedResetOperateAsync(const Model::CloseTimedResetOperateRequest& request, const CloseTimedResetOperateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CloseTimedResetOperateOutcomeCallable closeTimedResetOperateCallable(const Model::CloseTimedResetOperateRequest& request) const;
DuplexDecisionOutcome duplexDecision(const Model::DuplexDecisionRequest &request)const;
void duplexDecisionAsync(const Model::DuplexDecisionRequest& request, const DuplexDecisionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DuplexDecisionOutcomeCallable duplexDecisionCallable(const Model::DuplexDecisionRequest& request) const;
GetVideoTaskInfoOutcome getVideoTaskInfo(const Model::GetVideoTaskInfoRequest &request)const;
void getVideoTaskInfoAsync(const Model::GetVideoTaskInfoRequest& request, const GetVideoTaskInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVideoTaskInfoOutcomeCallable getVideoTaskInfoCallable(const Model::GetVideoTaskInfoRequest& request) const;
LicenseAuthOutcome licenseAuth(const Model::LicenseAuthRequest &request)const;
void licenseAuthAsync(const Model::LicenseAuthRequest& request, const LicenseAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
LicenseAuthOutcomeCallable licenseAuthCallable(const Model::LicenseAuthRequest& request) const;
QueryRunningInstanceOutcome queryRunningInstance(const Model::QueryRunningInstanceRequest &request)const;
void queryRunningInstanceAsync(const Model::QueryRunningInstanceRequest& request, const QueryRunningInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryRunningInstanceOutcomeCallable queryRunningInstanceCallable(const Model::QueryRunningInstanceRequest& request) const;
QueryTimedResetOperateStatusOutcome queryTimedResetOperateStatus(const Model::QueryTimedResetOperateStatusRequest &request)const;
void queryTimedResetOperateStatusAsync(const Model::QueryTimedResetOperateStatusRequest& request, const QueryTimedResetOperateStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryTimedResetOperateStatusOutcomeCallable queryTimedResetOperateStatusCallable(const Model::QueryTimedResetOperateStatusRequest& request) const;
SendMessageOutcome sendMessage(const Model::SendMessageRequest &request)const;
void sendMessageAsync(const Model::SendMessageRequest& request, const SendMessageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SendMessageOutcomeCallable sendMessageCallable(const Model::SendMessageRequest& request) const;
StartInstanceOutcome startInstance(const Model::StartInstanceRequest &request)const;
void startInstanceAsync(const Model::StartInstanceRequest& request, const StartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartInstanceOutcomeCallable startInstanceCallable(const Model::StartInstanceRequest& request) const;
StartTimedResetOperateOutcome startTimedResetOperate(const Model::StartTimedResetOperateRequest &request)const;
void startTimedResetOperateAsync(const Model::StartTimedResetOperateRequest& request, const StartTimedResetOperateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartTimedResetOperateOutcomeCallable startTimedResetOperateCallable(const Model::StartTimedResetOperateRequest& request) const;
StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const;
void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const;
SubmitTextTo2DAvatarVideoTaskOutcome submitTextTo2DAvatarVideoTask(const Model::SubmitTextTo2DAvatarVideoTaskRequest &request)const;
void submitTextTo2DAvatarVideoTaskAsync(const Model::SubmitTextTo2DAvatarVideoTaskRequest& request, const SubmitTextTo2DAvatarVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SubmitTextTo2DAvatarVideoTaskOutcomeCallable submitTextTo2DAvatarVideoTaskCallable(const Model::SubmitTextTo2DAvatarVideoTaskRequest& request) const;
SubmitTextTo3DAvatarVideoTaskOutcome submitTextTo3DAvatarVideoTask(const Model::SubmitTextTo3DAvatarVideoTaskRequest &request)const;
void submitTextTo3DAvatarVideoTaskAsync(const Model::SubmitTextTo3DAvatarVideoTaskRequest& request, const SubmitTextTo3DAvatarVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SubmitTextTo3DAvatarVideoTaskOutcomeCallable submitTextTo3DAvatarVideoTaskCallable(const Model::SubmitTextTo3DAvatarVideoTaskRequest& request) const;
SubmitTextToSignVideoTaskOutcome submitTextToSignVideoTask(const Model::SubmitTextToSignVideoTaskRequest &request)const;
void submitTextToSignVideoTaskAsync(const Model::SubmitTextToSignVideoTaskRequest& request, const SubmitTextToSignVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SubmitTextToSignVideoTaskOutcomeCallable submitTextToSignVideoTaskCallable(const Model::SubmitTextToSignVideoTaskRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_AVATAR_AVATARCLIENT_H_

View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_AVATAREXPORT_H_
#define ALIBABACLOUD_AVATAR_AVATAREXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_AVATAR_LIBRARY)
# define ALIBABACLOUD_AVATAR_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_AVATAR_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_AVATAR_EXPORT
#endif
#endif // !ALIBABACLOUD_AVATAR_AVATAREXPORT_H_

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_CANCELVIDEOTASKREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_CANCELVIDEOTASKREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT CancelVideoTaskRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
CancelVideoTaskRequest();
~CancelVideoTaskRequest();
App getApp() const;
void setApp(const App &app);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getTaskUuid() const;
void setTaskUuid(const std::string &taskUuid);
private:
App app_;
long tenantId_;
std::string taskUuid_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_CANCELVIDEOTASKREQUEST_H_

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_CANCELVIDEOTASKRESULT_H_
#define ALIBABACLOUD_AVATAR_MODEL_CANCELVIDEOTASKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/avatar/AvatarExport.h>
namespace AlibabaCloud
{
namespace Avatar
{
namespace Model
{
class ALIBABACLOUD_AVATAR_EXPORT CancelVideoTaskResult : public ServiceResult
{
public:
struct Data
{
bool isCancel;
std::string taskUuid;
std::string failReason;
};
CancelVideoTaskResult();
explicit CancelVideoTaskResult(const std::string &payload);
~CancelVideoTaskResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_AVATAR_MODEL_CANCELVIDEOTASKRESULT_H_

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_CLOSETIMEDRESETOPERATEREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_CLOSETIMEDRESETOPERATEREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT CloseTimedResetOperateRequest : public RpcServiceRequest {
public:
CloseTimedResetOperateRequest();
~CloseTimedResetOperateRequest();
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
long getTenantId() const;
void setTenantId(long tenantId);
private:
std::string instanceId_;
long tenantId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_CLOSETIMEDRESETOPERATEREQUEST_H_

View File

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

View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_DUPLEXDECISIONREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_DUPLEXDECISIONREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT DuplexDecisionRequest : public RpcServiceRequest {
public:
struct DialogContext {
struct HistoriesItem {
std::string robot;
std::string user;
};
HistoriesItem historiesItem;
std::vector<HistoriesItem> histories;
int curUtteranceIdx;
};
DuplexDecisionRequest();
~DuplexDecisionRequest();
int getInterruptType() const;
void setInterruptType(int interruptType);
std::vector<std::string> getCustomKeywords() const;
void setCustomKeywords(const std::vector<std::string> &customKeywords);
std::string getSessionId() const;
void setSessionId(const std::string &sessionId);
std::string getDialogStatus() const;
void setDialogStatus(const std::string &dialogStatus);
DialogContext getDialogContext() const;
void setDialogContext(const DialogContext &dialogContext);
int getCallTime() const;
void setCallTime(int callTime);
std::string getAppId() const;
void setAppId(const std::string &appId);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getText() const;
void setText(const std::string &text);
std::string getBizRequestId() const;
void setBizRequestId(const std::string &bizRequestId);
private:
int interruptType_;
std::vector<std::string> customKeywords_;
std::string sessionId_;
std::string dialogStatus_;
DialogContext dialogContext_;
int callTime_;
std::string appId_;
long tenantId_;
std::string text_;
std::string bizRequestId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_DUPLEXDECISIONREQUEST_H_

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_DUPLEXDECISIONRESULT_H_
#define ALIBABACLOUD_AVATAR_MODEL_DUPLEXDECISIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/avatar/AvatarExport.h>
namespace AlibabaCloud
{
namespace Avatar
{
namespace Model
{
class ALIBABACLOUD_AVATAR_EXPORT DuplexDecisionResult : public ServiceResult
{
public:
struct Data
{
std::string actionType;
std::string outputText;
std::string grabType;
};
DuplexDecisionResult();
explicit DuplexDecisionResult(const std::string &payload);
~DuplexDecisionResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
std::string getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
std::string success_;
};
}
}
}
#endif // !ALIBABACLOUD_AVATAR_MODEL_DUPLEXDECISIONRESULT_H_

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_GETVIDEOTASKINFOREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_GETVIDEOTASKINFOREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT GetVideoTaskInfoRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
GetVideoTaskInfoRequest();
~GetVideoTaskInfoRequest();
App getApp() const;
void setApp(const App &app);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getTaskUuid() const;
void setTaskUuid(const std::string &taskUuid);
private:
App app_;
long tenantId_;
std::string taskUuid_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_GETVIDEOTASKINFOREQUEST_H_

View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_GETVIDEOTASKINFORESULT_H_
#define ALIBABACLOUD_AVATAR_MODEL_GETVIDEOTASKINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/avatar/AvatarExport.h>
namespace AlibabaCloud
{
namespace Avatar
{
namespace Model
{
class ALIBABACLOUD_AVATAR_EXPORT GetVideoTaskInfoResult : public ServiceResult
{
public:
struct Data
{
struct TaskResult
{
std::string failCode;
std::string subtitlesUrl;
std::string wordSubtitlesUrl;
std::string failReason;
std::string videoUrl;
};
std::string status;
std::string type;
std::string taskUuid;
TaskResult taskResult;
std::string process;
};
GetVideoTaskInfoResult();
explicit GetVideoTaskInfoResult(const std::string &payload);
~GetVideoTaskInfoResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_AVATAR_MODEL_GETVIDEOTASKINFORESULT_H_

View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_LICENSEAUTHREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_LICENSEAUTHREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT LicenseAuthRequest : public RpcServiceRequest {
public:
LicenseAuthRequest();
~LicenseAuthRequest();
std::string getLicense() const;
void setLicense(const std::string &license);
std::string getAppId() const;
void setAppId(const std::string &appId);
long getTenantId() const;
void setTenantId(long tenantId);
private:
std::string license_;
std::string appId_;
long tenantId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_LICENSEAUTHREQUEST_H_

View File

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

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_QUERYRUNNINGINSTANCEREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_QUERYRUNNINGINSTANCEREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT QueryRunningInstanceRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
QueryRunningInstanceRequest();
~QueryRunningInstanceRequest();
App getApp() const;
void setApp(const App &app);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getSessionId() const;
void setSessionId(const std::string &sessionId);
private:
App app_;
long tenantId_;
std::string sessionId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_QUERYRUNNINGINSTANCEREQUEST_H_

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_QUERYRUNNINGINSTANCERESULT_H_
#define ALIBABACLOUD_AVATAR_MODEL_QUERYRUNNINGINSTANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/avatar/AvatarExport.h>
namespace AlibabaCloud
{
namespace Avatar
{
namespace Model
{
class ALIBABACLOUD_AVATAR_EXPORT QueryRunningInstanceResult : public ServiceResult
{
public:
struct DataItem
{
struct Channel
{
std::string nonce;
std::vector<std::string> gslb;
std::string userInfoInChannel;
std::string type;
std::string appId;
std::string userId;
std::string expiredTime;
std::string token;
std::string channelId;
};
struct User
{
std::string userName;
std::string userId;
};
User user;
Channel channel;
std::string sessionId;
};
QueryRunningInstanceResult();
explicit QueryRunningInstanceResult(const std::string &payload);
~QueryRunningInstanceResult();
std::string getMessage()const;
std::vector<DataItem> getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<DataItem> data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_AVATAR_MODEL_QUERYRUNNINGINSTANCERESULT_H_

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_QUERYTIMEDRESETOPERATESTATUSREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_QUERYTIMEDRESETOPERATESTATUSREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT QueryTimedResetOperateStatusRequest : public RpcServiceRequest {
public:
QueryTimedResetOperateStatusRequest();
~QueryTimedResetOperateStatusRequest();
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
long getTenantId() const;
void setTenantId(long tenantId);
private:
std::string instanceId_;
long tenantId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_QUERYTIMEDRESETOPERATESTATUSREQUEST_H_

View File

@@ -0,0 +1,64 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_QUERYTIMEDRESETOPERATESTATUSRESULT_H_
#define ALIBABACLOUD_AVATAR_MODEL_QUERYTIMEDRESETOPERATESTATUSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/avatar/AvatarExport.h>
namespace AlibabaCloud
{
namespace Avatar
{
namespace Model
{
class ALIBABACLOUD_AVATAR_EXPORT QueryTimedResetOperateStatusResult : public ServiceResult
{
public:
struct Data
{
long status;
std::string statusStr;
std::string tenantId;
std::string instanceId;
};
QueryTimedResetOperateStatusResult();
explicit QueryTimedResetOperateStatusResult(const std::string &payload);
~QueryTimedResetOperateStatusResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_AVATAR_MODEL_QUERYTIMEDRESETOPERATESTATUSRESULT_H_

View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_SENDMESSAGEREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_SENDMESSAGEREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT SendMessageRequest : public RpcServiceRequest {
public:
struct VAMLRequest {
std::string code;
std::string vaml;
};
SendMessageRequest();
~SendMessageRequest();
std::string getTextRequest() const;
void setTextRequest(const std::string &textRequest);
long getTenantId() const;
void setTenantId(long tenantId);
VAMLRequest getVAMLRequest() const;
void setVAMLRequest(const VAMLRequest &vAMLRequest);
std::string getSessionId() const;
void setSessionId(const std::string &sessionId);
private:
std::string textRequest_;
long tenantId_;
VAMLRequest vAMLRequest_;
std::string sessionId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_SENDMESSAGEREQUEST_H_

View File

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

View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_STARTINSTANCEREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_STARTINSTANCEREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT StartInstanceRequest : public RpcServiceRequest {
public:
struct Channel {
std::string type;
std::map<std::string, std::string> reqConfig;
};
struct CommandRequest {
bool alphaSwitch;
};
StartInstanceRequest();
~StartInstanceRequest();
std::string getApp() const;
void setApp(const std::string &app);
long getTenantId() const;
void setTenantId(long tenantId);
Channel getChannel() const;
void setChannel(const Channel &channel);
CommandRequest getCommandRequest() const;
void setCommandRequest(const CommandRequest &commandRequest);
std::string getUser() const;
void setUser(const std::string &user);
private:
std::string app_;
long tenantId_;
Channel channel_;
CommandRequest commandRequest_;
std::string user_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_STARTINSTANCEREQUEST_H_

View File

@@ -0,0 +1,76 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_STARTINSTANCERESULT_H_
#define ALIBABACLOUD_AVATAR_MODEL_STARTINSTANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/avatar/AvatarExport.h>
namespace AlibabaCloud
{
namespace Avatar
{
namespace Model
{
class ALIBABACLOUD_AVATAR_EXPORT StartInstanceResult : public ServiceResult
{
public:
struct Data
{
struct Channel
{
std::string nonce;
std::vector<std::string> gslb;
std::string userInfoInChannel;
std::string type;
std::string appId;
std::string userId;
std::string expiredTime;
std::string token;
std::string channelId;
};
std::string requestId;
Channel channel;
std::string token;
std::string sessionId;
};
StartInstanceResult();
explicit StartInstanceResult(const std::string &payload);
~StartInstanceResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_AVATAR_MODEL_STARTINSTANCERESULT_H_

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_STARTTIMEDRESETOPERATEREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_STARTTIMEDRESETOPERATEREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT StartTimedResetOperateRequest : public RpcServiceRequest {
public:
StartTimedResetOperateRequest();
~StartTimedResetOperateRequest();
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
long getTenantId() const;
void setTenantId(long tenantId);
private:
std::string instanceId_;
long tenantId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_STARTTIMEDRESETOPERATEREQUEST_H_

View File

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

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_STOPINSTANCEREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_STOPINSTANCEREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT StopInstanceRequest : public RpcServiceRequest {
public:
StopInstanceRequest();
~StopInstanceRequest();
long getTenantId() const;
void setTenantId(long tenantId);
std::string getSessionId() const;
void setSessionId(const std::string &sessionId);
private:
long tenantId_;
std::string sessionId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_STOPINSTANCEREQUEST_H_

View File

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

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO2DAVATARVIDEOTASKREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO2DAVATARVIDEOTASKREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT SubmitTextTo2DAvatarVideoTaskRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
struct VideoInfo {
bool isAlpha;
std::string backgroundImageUrl;
bool isSubtitles;
};
struct AudioInfo {
std::string voice;
int volume;
int speechRate;
int pitchRate;
};
struct AvatarInfo {
std::string code;
};
SubmitTextTo2DAvatarVideoTaskRequest();
~SubmitTextTo2DAvatarVideoTaskRequest();
App getApp() const;
void setApp(const App &app);
VideoInfo getVideoInfo() const;
void setVideoInfo(const VideoInfo &videoInfo);
AudioInfo getAudioInfo() const;
void setAudioInfo(const AudioInfo &audioInfo);
AvatarInfo getAvatarInfo() const;
void setAvatarInfo(const AvatarInfo &avatarInfo);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getText() const;
void setText(const std::string &text);
std::string getTitle() const;
void setTitle(const std::string &title);
private:
App app_;
VideoInfo videoInfo_;
AudioInfo audioInfo_;
AvatarInfo avatarInfo_;
long tenantId_;
std::string text_;
std::string title_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO2DAVATARVIDEOTASKREQUEST_H_

View File

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

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.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO3DAVATARVIDEOTASKREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO3DAVATARVIDEOTASKREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT SubmitTextTo3DAvatarVideoTaskRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
struct VideoInfo {
bool isAlpha;
std::string backgroundImageUrl;
bool isSubtitles;
int resolution;
int alphaFormat;
};
struct AvatarInfo {
std::string code;
int locate;
int angle;
};
SubmitTextTo3DAvatarVideoTaskRequest();
~SubmitTextTo3DAvatarVideoTaskRequest();
App getApp() const;
void setApp(const App &app);
VideoInfo getVideoInfo() const;
void setVideoInfo(const VideoInfo &videoInfo);
AvatarInfo getAvatarInfo() const;
void setAvatarInfo(const AvatarInfo &avatarInfo);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getText() const;
void setText(const std::string &text);
std::string getTitle() const;
void setTitle(const std::string &title);
private:
App app_;
VideoInfo videoInfo_;
AvatarInfo avatarInfo_;
long tenantId_;
std::string text_;
std::string title_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO3DAVATARVIDEOTASKREQUEST_H_

View File

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

View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTOSIGNVIDEOTASKREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTOSIGNVIDEOTASKREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT SubmitTextToSignVideoTaskRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
struct VideoInfo {
bool isAlpha;
bool isSubtitles;
int resolution;
};
SubmitTextToSignVideoTaskRequest();
~SubmitTextToSignVideoTaskRequest();
App getApp() const;
void setApp(const App &app);
VideoInfo getVideoInfo() const;
void setVideoInfo(const VideoInfo &videoInfo);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getText() const;
void setText(const std::string &text);
std::string getTitle() const;
void setTitle(const std::string &title);
private:
App app_;
VideoInfo videoInfo_;
long tenantId_;
std::string text_;
std::string title_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTOSIGNVIDEOTASKREQUEST_H_

View File

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

557
avatar/src/AvatarClient.cc Normal file
View File

@@ -0,0 +1,557 @@
/*
* 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/avatar/AvatarClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Avatar;
using namespace AlibabaCloud::Avatar::Model;
namespace
{
const std::string SERVICE_NAME = "avatar";
}
AvatarClient::AvatarClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
AvatarClient::AvatarClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
AvatarClient::AvatarClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
AvatarClient::~AvatarClient()
{}
AvatarClient::CancelVideoTaskOutcome AvatarClient::cancelVideoTask(const CancelVideoTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CancelVideoTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CancelVideoTaskOutcome(CancelVideoTaskResult(outcome.result()));
else
return CancelVideoTaskOutcome(outcome.error());
}
void AvatarClient::cancelVideoTaskAsync(const CancelVideoTaskRequest& request, const CancelVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, cancelVideoTask(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::CancelVideoTaskOutcomeCallable AvatarClient::cancelVideoTaskCallable(const CancelVideoTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CancelVideoTaskOutcome()>>(
[this, request]()
{
return this->cancelVideoTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::CloseTimedResetOperateOutcome AvatarClient::closeTimedResetOperate(const CloseTimedResetOperateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CloseTimedResetOperateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CloseTimedResetOperateOutcome(CloseTimedResetOperateResult(outcome.result()));
else
return CloseTimedResetOperateOutcome(outcome.error());
}
void AvatarClient::closeTimedResetOperateAsync(const CloseTimedResetOperateRequest& request, const CloseTimedResetOperateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, closeTimedResetOperate(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::CloseTimedResetOperateOutcomeCallable AvatarClient::closeTimedResetOperateCallable(const CloseTimedResetOperateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CloseTimedResetOperateOutcome()>>(
[this, request]()
{
return this->closeTimedResetOperate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::DuplexDecisionOutcome AvatarClient::duplexDecision(const DuplexDecisionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DuplexDecisionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DuplexDecisionOutcome(DuplexDecisionResult(outcome.result()));
else
return DuplexDecisionOutcome(outcome.error());
}
void AvatarClient::duplexDecisionAsync(const DuplexDecisionRequest& request, const DuplexDecisionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, duplexDecision(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::DuplexDecisionOutcomeCallable AvatarClient::duplexDecisionCallable(const DuplexDecisionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DuplexDecisionOutcome()>>(
[this, request]()
{
return this->duplexDecision(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::GetVideoTaskInfoOutcome AvatarClient::getVideoTaskInfo(const GetVideoTaskInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetVideoTaskInfoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetVideoTaskInfoOutcome(GetVideoTaskInfoResult(outcome.result()));
else
return GetVideoTaskInfoOutcome(outcome.error());
}
void AvatarClient::getVideoTaskInfoAsync(const GetVideoTaskInfoRequest& request, const GetVideoTaskInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getVideoTaskInfo(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::GetVideoTaskInfoOutcomeCallable AvatarClient::getVideoTaskInfoCallable(const GetVideoTaskInfoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetVideoTaskInfoOutcome()>>(
[this, request]()
{
return this->getVideoTaskInfo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::LicenseAuthOutcome AvatarClient::licenseAuth(const LicenseAuthRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return LicenseAuthOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return LicenseAuthOutcome(LicenseAuthResult(outcome.result()));
else
return LicenseAuthOutcome(outcome.error());
}
void AvatarClient::licenseAuthAsync(const LicenseAuthRequest& request, const LicenseAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, licenseAuth(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::LicenseAuthOutcomeCallable AvatarClient::licenseAuthCallable(const LicenseAuthRequest &request) const
{
auto task = std::make_shared<std::packaged_task<LicenseAuthOutcome()>>(
[this, request]()
{
return this->licenseAuth(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::QueryRunningInstanceOutcome AvatarClient::queryRunningInstance(const QueryRunningInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryRunningInstanceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryRunningInstanceOutcome(QueryRunningInstanceResult(outcome.result()));
else
return QueryRunningInstanceOutcome(outcome.error());
}
void AvatarClient::queryRunningInstanceAsync(const QueryRunningInstanceRequest& request, const QueryRunningInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryRunningInstance(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::QueryRunningInstanceOutcomeCallable AvatarClient::queryRunningInstanceCallable(const QueryRunningInstanceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryRunningInstanceOutcome()>>(
[this, request]()
{
return this->queryRunningInstance(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::QueryTimedResetOperateStatusOutcome AvatarClient::queryTimedResetOperateStatus(const QueryTimedResetOperateStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryTimedResetOperateStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryTimedResetOperateStatusOutcome(QueryTimedResetOperateStatusResult(outcome.result()));
else
return QueryTimedResetOperateStatusOutcome(outcome.error());
}
void AvatarClient::queryTimedResetOperateStatusAsync(const QueryTimedResetOperateStatusRequest& request, const QueryTimedResetOperateStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryTimedResetOperateStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::QueryTimedResetOperateStatusOutcomeCallable AvatarClient::queryTimedResetOperateStatusCallable(const QueryTimedResetOperateStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryTimedResetOperateStatusOutcome()>>(
[this, request]()
{
return this->queryTimedResetOperateStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::SendMessageOutcome AvatarClient::sendMessage(const SendMessageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SendMessageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SendMessageOutcome(SendMessageResult(outcome.result()));
else
return SendMessageOutcome(outcome.error());
}
void AvatarClient::sendMessageAsync(const SendMessageRequest& request, const SendMessageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, sendMessage(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::SendMessageOutcomeCallable AvatarClient::sendMessageCallable(const SendMessageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SendMessageOutcome()>>(
[this, request]()
{
return this->sendMessage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::StartInstanceOutcome AvatarClient::startInstance(const StartInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartInstanceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartInstanceOutcome(StartInstanceResult(outcome.result()));
else
return StartInstanceOutcome(outcome.error());
}
void AvatarClient::startInstanceAsync(const StartInstanceRequest& request, const StartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startInstance(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::StartInstanceOutcomeCallable AvatarClient::startInstanceCallable(const StartInstanceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartInstanceOutcome()>>(
[this, request]()
{
return this->startInstance(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::StartTimedResetOperateOutcome AvatarClient::startTimedResetOperate(const StartTimedResetOperateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartTimedResetOperateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartTimedResetOperateOutcome(StartTimedResetOperateResult(outcome.result()));
else
return StartTimedResetOperateOutcome(outcome.error());
}
void AvatarClient::startTimedResetOperateAsync(const StartTimedResetOperateRequest& request, const StartTimedResetOperateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startTimedResetOperate(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::StartTimedResetOperateOutcomeCallable AvatarClient::startTimedResetOperateCallable(const StartTimedResetOperateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartTimedResetOperateOutcome()>>(
[this, request]()
{
return this->startTimedResetOperate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::StopInstanceOutcome AvatarClient::stopInstance(const StopInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StopInstanceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StopInstanceOutcome(StopInstanceResult(outcome.result()));
else
return StopInstanceOutcome(outcome.error());
}
void AvatarClient::stopInstanceAsync(const StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, stopInstance(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::StopInstanceOutcomeCallable AvatarClient::stopInstanceCallable(const StopInstanceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StopInstanceOutcome()>>(
[this, request]()
{
return this->stopInstance(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::SubmitTextTo2DAvatarVideoTaskOutcome AvatarClient::submitTextTo2DAvatarVideoTask(const SubmitTextTo2DAvatarVideoTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SubmitTextTo2DAvatarVideoTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SubmitTextTo2DAvatarVideoTaskOutcome(SubmitTextTo2DAvatarVideoTaskResult(outcome.result()));
else
return SubmitTextTo2DAvatarVideoTaskOutcome(outcome.error());
}
void AvatarClient::submitTextTo2DAvatarVideoTaskAsync(const SubmitTextTo2DAvatarVideoTaskRequest& request, const SubmitTextTo2DAvatarVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, submitTextTo2DAvatarVideoTask(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::SubmitTextTo2DAvatarVideoTaskOutcomeCallable AvatarClient::submitTextTo2DAvatarVideoTaskCallable(const SubmitTextTo2DAvatarVideoTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SubmitTextTo2DAvatarVideoTaskOutcome()>>(
[this, request]()
{
return this->submitTextTo2DAvatarVideoTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::SubmitTextTo3DAvatarVideoTaskOutcome AvatarClient::submitTextTo3DAvatarVideoTask(const SubmitTextTo3DAvatarVideoTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SubmitTextTo3DAvatarVideoTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SubmitTextTo3DAvatarVideoTaskOutcome(SubmitTextTo3DAvatarVideoTaskResult(outcome.result()));
else
return SubmitTextTo3DAvatarVideoTaskOutcome(outcome.error());
}
void AvatarClient::submitTextTo3DAvatarVideoTaskAsync(const SubmitTextTo3DAvatarVideoTaskRequest& request, const SubmitTextTo3DAvatarVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, submitTextTo3DAvatarVideoTask(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::SubmitTextTo3DAvatarVideoTaskOutcomeCallable AvatarClient::submitTextTo3DAvatarVideoTaskCallable(const SubmitTextTo3DAvatarVideoTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SubmitTextTo3DAvatarVideoTaskOutcome()>>(
[this, request]()
{
return this->submitTextTo3DAvatarVideoTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AvatarClient::SubmitTextToSignVideoTaskOutcome AvatarClient::submitTextToSignVideoTask(const SubmitTextToSignVideoTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SubmitTextToSignVideoTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SubmitTextToSignVideoTaskOutcome(SubmitTextToSignVideoTaskResult(outcome.result()));
else
return SubmitTextToSignVideoTaskOutcome(outcome.error());
}
void AvatarClient::submitTextToSignVideoTaskAsync(const SubmitTextToSignVideoTaskRequest& request, const SubmitTextToSignVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, submitTextToSignVideoTask(request), context);
};
asyncExecute(new Runnable(fn));
}
AvatarClient::SubmitTextToSignVideoTaskOutcomeCallable AvatarClient::submitTextToSignVideoTaskCallable(const SubmitTextToSignVideoTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SubmitTextToSignVideoTaskOutcome()>>(
[this, request]()
{
return this->submitTextToSignVideoTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

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/avatar/model/CancelVideoTaskRequest.h>
using AlibabaCloud::Avatar::Model::CancelVideoTaskRequest;
CancelVideoTaskRequest::CancelVideoTaskRequest()
: RpcServiceRequest("avatar", "2022-01-30", "CancelVideoTask") {
setMethod(HttpRequest::Method::Post);
}
CancelVideoTaskRequest::~CancelVideoTaskRequest() {}
CancelVideoTaskRequest::App CancelVideoTaskRequest::getApp() const {
return app_;
}
void CancelVideoTaskRequest::setApp(const CancelVideoTaskRequest::App &app) {
app_ = app;
setParameter(std::string("App") + ".AppId", app.appId);
}
long CancelVideoTaskRequest::getTenantId() const {
return tenantId_;
}
void CancelVideoTaskRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}
std::string CancelVideoTaskRequest::getTaskUuid() const {
return taskUuid_;
}
void CancelVideoTaskRequest::setTaskUuid(const std::string &taskUuid) {
taskUuid_ = taskUuid;
setParameter(std::string("TaskUuid"), taskUuid);
}

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/avatar/model/CancelVideoTaskResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Avatar;
using namespace AlibabaCloud::Avatar::Model;
CancelVideoTaskResult::CancelVideoTaskResult() :
ServiceResult()
{}
CancelVideoTaskResult::CancelVideoTaskResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CancelVideoTaskResult::~CancelVideoTaskResult()
{}
void CancelVideoTaskResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["TaskUuid"].isNull())
data_.taskUuid = dataNode["TaskUuid"].asString();
if(!dataNode["IsCancel"].isNull())
data_.isCancel = dataNode["IsCancel"].asString() == "true";
if(!dataNode["FailReason"].isNull())
data_.failReason = dataNode["FailReason"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string CancelVideoTaskResult::getMessage()const
{
return message_;
}
CancelVideoTaskResult::Data CancelVideoTaskResult::getData()const
{
return data_;
}
std::string CancelVideoTaskResult::getCode()const
{
return code_;
}
bool CancelVideoTaskResult::getSuccess()const
{
return success_;
}

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/avatar/model/CloseTimedResetOperateRequest.h>
using AlibabaCloud::Avatar::Model::CloseTimedResetOperateRequest;
CloseTimedResetOperateRequest::CloseTimedResetOperateRequest()
: RpcServiceRequest("avatar", "2022-01-30", "CloseTimedResetOperate") {
setMethod(HttpRequest::Method::Post);
}
CloseTimedResetOperateRequest::~CloseTimedResetOperateRequest() {}
std::string CloseTimedResetOperateRequest::getInstanceId() const {
return instanceId_;
}
void CloseTimedResetOperateRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
long CloseTimedResetOperateRequest::getTenantId() const {
return tenantId_;
}
void CloseTimedResetOperateRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}

View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/avatar/model/CloseTimedResetOperateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Avatar;
using namespace AlibabaCloud::Avatar::Model;
CloseTimedResetOperateResult::CloseTimedResetOperateResult() :
ServiceResult()
{}
CloseTimedResetOperateResult::CloseTimedResetOperateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CloseTimedResetOperateResult::~CloseTimedResetOperateResult()
{}
void CloseTimedResetOperateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["InstanceId"].isNull())
data_.instanceId = dataNode["InstanceId"].asString();
if(!dataNode["TenantId"].isNull())
data_.tenantId = std::stol(dataNode["TenantId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string CloseTimedResetOperateResult::getMessage()const
{
return message_;
}
CloseTimedResetOperateResult::Data CloseTimedResetOperateResult::getData()const
{
return data_;
}
std::string CloseTimedResetOperateResult::getCode()const
{
return code_;
}
bool CloseTimedResetOperateResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,123 @@
/*
* 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/avatar/model/DuplexDecisionRequest.h>
using AlibabaCloud::Avatar::Model::DuplexDecisionRequest;
DuplexDecisionRequest::DuplexDecisionRequest()
: RpcServiceRequest("avatar", "2022-01-30", "DuplexDecision") {
setMethod(HttpRequest::Method::Post);
}
DuplexDecisionRequest::~DuplexDecisionRequest() {}
int DuplexDecisionRequest::getInterruptType() const {
return interruptType_;
}
void DuplexDecisionRequest::setInterruptType(int interruptType) {
interruptType_ = interruptType;
setParameter(std::string("InterruptType"), std::to_string(interruptType));
}
std::vector<DuplexDecisionRequest::std::string> DuplexDecisionRequest::getCustomKeywords() const {
return customKeywords_;
}
void DuplexDecisionRequest::setCustomKeywords(const std::vector<DuplexDecisionRequest::std::string> &customKeywords) {
customKeywords_ = customKeywords;
for(int dep1 = 0; dep1 != customKeywords.size(); dep1++) {
setParameter(std::string("CustomKeywords") + "." + std::to_string(dep1 + 1), customKeywords[dep1]);
}
}
std::string DuplexDecisionRequest::getSessionId() const {
return sessionId_;
}
void DuplexDecisionRequest::setSessionId(const std::string &sessionId) {
sessionId_ = sessionId;
setParameter(std::string("SessionId"), sessionId);
}
std::string DuplexDecisionRequest::getDialogStatus() const {
return dialogStatus_;
}
void DuplexDecisionRequest::setDialogStatus(const std::string &dialogStatus) {
dialogStatus_ = dialogStatus;
setParameter(std::string("DialogStatus"), dialogStatus);
}
DuplexDecisionRequest::DialogContext DuplexDecisionRequest::getDialogContext() const {
return dialogContext_;
}
void DuplexDecisionRequest::setDialogContext(const DuplexDecisionRequest::DialogContext &dialogContext) {
dialogContext_ = dialogContext;
for(int dep1 = 0; dep1 != dialogContext.histories.size(); dep1++) {
setParameter(std::string("DialogContext") + ".Histories." + std::to_string(dep1 + 1) + ".Robot", dialogContext.histories[dep1].robot);
setParameter(std::string("DialogContext") + ".Histories." + std::to_string(dep1 + 1) + ".User", dialogContext.histories[dep1].user);
}
setParameter(std::string("DialogContext") + ".CurUtteranceIdx", std::to_string(dialogContext.curUtteranceIdx));
}
int DuplexDecisionRequest::getCallTime() const {
return callTime_;
}
void DuplexDecisionRequest::setCallTime(int callTime) {
callTime_ = callTime;
setParameter(std::string("CallTime"), std::to_string(callTime));
}
std::string DuplexDecisionRequest::getAppId() const {
return appId_;
}
void DuplexDecisionRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
long DuplexDecisionRequest::getTenantId() const {
return tenantId_;
}
void DuplexDecisionRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}
std::string DuplexDecisionRequest::getText() const {
return text_;
}
void DuplexDecisionRequest::setText(const std::string &text) {
text_ = text;
setParameter(std::string("Text"), text);
}
std::string DuplexDecisionRequest::getBizRequestId() const {
return bizRequestId_;
}
void DuplexDecisionRequest::setBizRequestId(const std::string &bizRequestId) {
bizRequestId_ = bizRequestId;
setParameter(std::string("BizRequestId"), bizRequestId);
}

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/avatar/model/DuplexDecisionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Avatar;
using namespace AlibabaCloud::Avatar::Model;
DuplexDecisionResult::DuplexDecisionResult() :
ServiceResult()
{}
DuplexDecisionResult::DuplexDecisionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DuplexDecisionResult::~DuplexDecisionResult()
{}
void DuplexDecisionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["ActionType"].isNull())
data_.actionType = dataNode["ActionType"].asString();
if(!dataNode["OutputText"].isNull())
data_.outputText = dataNode["OutputText"].asString();
if(!dataNode["GrabType"].isNull())
data_.grabType = dataNode["GrabType"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString();
}
std::string DuplexDecisionResult::getMessage()const
{
return message_;
}
DuplexDecisionResult::Data DuplexDecisionResult::getData()const
{
return data_;
}
std::string DuplexDecisionResult::getCode()const
{
return code_;
}
std::string DuplexDecisionResult::getSuccess()const
{
return success_;
}

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/avatar/model/GetVideoTaskInfoRequest.h>
using AlibabaCloud::Avatar::Model::GetVideoTaskInfoRequest;
GetVideoTaskInfoRequest::GetVideoTaskInfoRequest()
: RpcServiceRequest("avatar", "2022-01-30", "GetVideoTaskInfo") {
setMethod(HttpRequest::Method::Get);
}
GetVideoTaskInfoRequest::~GetVideoTaskInfoRequest() {}
GetVideoTaskInfoRequest::App GetVideoTaskInfoRequest::getApp() const {
return app_;
}
void GetVideoTaskInfoRequest::setApp(const GetVideoTaskInfoRequest::App &app) {
app_ = app;
setParameter(std::string("App") + ".AppId", app.appId);
}
long GetVideoTaskInfoRequest::getTenantId() const {
return tenantId_;
}
void GetVideoTaskInfoRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}
std::string GetVideoTaskInfoRequest::getTaskUuid() const {
return taskUuid_;
}
void GetVideoTaskInfoRequest::setTaskUuid(const std::string &taskUuid) {
taskUuid_ = taskUuid;
setParameter(std::string("TaskUuid"), taskUuid);
}

View File

@@ -0,0 +1,90 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/avatar/model/GetVideoTaskInfoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Avatar;
using namespace AlibabaCloud::Avatar::Model;
GetVideoTaskInfoResult::GetVideoTaskInfoResult() :
ServiceResult()
{}
GetVideoTaskInfoResult::GetVideoTaskInfoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetVideoTaskInfoResult::~GetVideoTaskInfoResult()
{}
void GetVideoTaskInfoResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["TaskUuid"].isNull())
data_.taskUuid = dataNode["TaskUuid"].asString();
if(!dataNode["Type"].isNull())
data_.type = dataNode["Type"].asString();
if(!dataNode["Status"].isNull())
data_.status = dataNode["Status"].asString();
if(!dataNode["Process"].isNull())
data_.process = dataNode["Process"].asString();
auto taskResultNode = dataNode["TaskResult"];
if(!taskResultNode["VideoUrl"].isNull())
data_.taskResult.videoUrl = taskResultNode["VideoUrl"].asString();
if(!taskResultNode["SubtitlesUrl"].isNull())
data_.taskResult.subtitlesUrl = taskResultNode["SubtitlesUrl"].asString();
if(!taskResultNode["WordSubtitlesUrl"].isNull())
data_.taskResult.wordSubtitlesUrl = taskResultNode["WordSubtitlesUrl"].asString();
if(!taskResultNode["FailReason"].isNull())
data_.taskResult.failReason = taskResultNode["FailReason"].asString();
if(!taskResultNode["FailCode"].isNull())
data_.taskResult.failCode = taskResultNode["FailCode"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string GetVideoTaskInfoResult::getMessage()const
{
return message_;
}
GetVideoTaskInfoResult::Data GetVideoTaskInfoResult::getData()const
{
return data_;
}
std::string GetVideoTaskInfoResult::getCode()const
{
return code_;
}
bool GetVideoTaskInfoResult::getSuccess()const
{
return success_;
}

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/avatar/model/LicenseAuthRequest.h>
using AlibabaCloud::Avatar::Model::LicenseAuthRequest;
LicenseAuthRequest::LicenseAuthRequest()
: RpcServiceRequest("avatar", "2022-01-30", "LicenseAuth") {
setMethod(HttpRequest::Method::Post);
}
LicenseAuthRequest::~LicenseAuthRequest() {}
std::string LicenseAuthRequest::getLicense() const {
return license_;
}
void LicenseAuthRequest::setLicense(const std::string &license) {
license_ = license;
setParameter(std::string("License"), license);
}
std::string LicenseAuthRequest::getAppId() const {
return appId_;
}
void LicenseAuthRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
long LicenseAuthRequest::getTenantId() const {
return tenantId_;
}
void LicenseAuthRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}

View File

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

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/avatar/model/QueryRunningInstanceRequest.h>
using AlibabaCloud::Avatar::Model::QueryRunningInstanceRequest;
QueryRunningInstanceRequest::QueryRunningInstanceRequest()
: RpcServiceRequest("avatar", "2022-01-30", "QueryRunningInstance") {
setMethod(HttpRequest::Method::Post);
}
QueryRunningInstanceRequest::~QueryRunningInstanceRequest() {}
QueryRunningInstanceRequest::App QueryRunningInstanceRequest::getApp() const {
return app_;
}
void QueryRunningInstanceRequest::setApp(const QueryRunningInstanceRequest::App &app) {
app_ = app;
setParameter(std::string("App") + ".AppId", app.appId);
}
long QueryRunningInstanceRequest::getTenantId() const {
return tenantId_;
}
void QueryRunningInstanceRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}
std::string QueryRunningInstanceRequest::getSessionId() const {
return sessionId_;
}
void QueryRunningInstanceRequest::setSessionId(const std::string &sessionId) {
sessionId_ = sessionId;
setParameter(std::string("SessionId"), sessionId);
}

View File

@@ -0,0 +1,103 @@
/*
* 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/avatar/model/QueryRunningInstanceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Avatar;
using namespace AlibabaCloud::Avatar::Model;
QueryRunningInstanceResult::QueryRunningInstanceResult() :
ServiceResult()
{}
QueryRunningInstanceResult::QueryRunningInstanceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryRunningInstanceResult::~QueryRunningInstanceResult()
{}
void QueryRunningInstanceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDataNode = value["Data"]["dataItem"];
for (auto valueDatadataItem : allDataNode)
{
DataItem dataObject;
if(!valueDatadataItem["SessionId"].isNull())
dataObject.sessionId = valueDatadataItem["SessionId"].asString();
auto channelNode = value["Channel"];
if(!channelNode["ChannelId"].isNull())
dataObject.channel.channelId = channelNode["ChannelId"].asString();
if(!channelNode["Token"].isNull())
dataObject.channel.token = channelNode["Token"].asString();
if(!channelNode["Type"].isNull())
dataObject.channel.type = channelNode["Type"].asString();
if(!channelNode["ExpiredTime"].isNull())
dataObject.channel.expiredTime = channelNode["ExpiredTime"].asString();
if(!channelNode["Nonce"].isNull())
dataObject.channel.nonce = channelNode["Nonce"].asString();
if(!channelNode["UserId"].isNull())
dataObject.channel.userId = channelNode["UserId"].asString();
if(!channelNode["AppId"].isNull())
dataObject.channel.appId = channelNode["AppId"].asString();
if(!channelNode["UserInfoInChannel"].isNull())
dataObject.channel.userInfoInChannel = channelNode["UserInfoInChannel"].asString();
auto allGslb = channelNode["Gslb"]["gslb"];
for (auto value : allGslb)
dataObject.channel.gslb.push_back(value.asString());
auto userNode = value["User"];
if(!userNode["UserId"].isNull())
dataObject.user.userId = userNode["UserId"].asString();
if(!userNode["UserName"].isNull())
dataObject.user.userName = userNode["UserName"].asString();
data_.push_back(dataObject);
}
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string QueryRunningInstanceResult::getMessage()const
{
return message_;
}
std::vector<QueryRunningInstanceResult::DataItem> QueryRunningInstanceResult::getData()const
{
return data_;
}
std::string QueryRunningInstanceResult::getCode()const
{
return code_;
}
bool QueryRunningInstanceResult::getSuccess()const
{
return success_;
}

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/avatar/model/QueryTimedResetOperateStatusRequest.h>
using AlibabaCloud::Avatar::Model::QueryTimedResetOperateStatusRequest;
QueryTimedResetOperateStatusRequest::QueryTimedResetOperateStatusRequest()
: RpcServiceRequest("avatar", "2022-01-30", "QueryTimedResetOperateStatus") {
setMethod(HttpRequest::Method::Post);
}
QueryTimedResetOperateStatusRequest::~QueryTimedResetOperateStatusRequest() {}
std::string QueryTimedResetOperateStatusRequest::getInstanceId() const {
return instanceId_;
}
void QueryTimedResetOperateStatusRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
long QueryTimedResetOperateStatusRequest::getTenantId() const {
return tenantId_;
}
void QueryTimedResetOperateStatusRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}

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/avatar/model/QueryTimedResetOperateStatusResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Avatar;
using namespace AlibabaCloud::Avatar::Model;
QueryTimedResetOperateStatusResult::QueryTimedResetOperateStatusResult() :
ServiceResult()
{}
QueryTimedResetOperateStatusResult::QueryTimedResetOperateStatusResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryTimedResetOperateStatusResult::~QueryTimedResetOperateStatusResult()
{}
void QueryTimedResetOperateStatusResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["InstanceId"].isNull())
data_.instanceId = dataNode["InstanceId"].asString();
if(!dataNode["StatusStr"].isNull())
data_.statusStr = dataNode["StatusStr"].asString();
if(!dataNode["TenantId"].isNull())
data_.tenantId = dataNode["TenantId"].asString();
if(!dataNode["Status"].isNull())
data_.status = std::stol(dataNode["Status"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string QueryTimedResetOperateStatusResult::getMessage()const
{
return message_;
}
QueryTimedResetOperateStatusResult::Data QueryTimedResetOperateStatusResult::getData()const
{
return data_;
}
std::string QueryTimedResetOperateStatusResult::getCode()const
{
return code_;
}
bool QueryTimedResetOperateStatusResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,64 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/avatar/model/SendMessageRequest.h>
using AlibabaCloud::Avatar::Model::SendMessageRequest;
SendMessageRequest::SendMessageRequest()
: RpcServiceRequest("avatar", "2022-01-30", "SendMessage") {
setMethod(HttpRequest::Method::Post);
}
SendMessageRequest::~SendMessageRequest() {}
std::string SendMessageRequest::getTextRequest() const {
return textRequest_;
}
void SendMessageRequest::setTextRequest(const std::string &textRequest) {
textRequest_ = textRequest;
setParameter(std::string("TextRequest"), textRequest);
}
long SendMessageRequest::getTenantId() const {
return tenantId_;
}
void SendMessageRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}
SendMessageRequest::VAMLRequest SendMessageRequest::getVAMLRequest() const {
return vAMLRequest_;
}
void SendMessageRequest::setVAMLRequest(const SendMessageRequest::VAMLRequest &vAMLRequest) {
vAMLRequest_ = vAMLRequest;
setParameter(std::string("VAMLRequest") + ".Code", vAMLRequest.code);
setParameter(std::string("VAMLRequest") + ".Vaml", vAMLRequest.vaml);
}
std::string SendMessageRequest::getSessionId() const {
return sessionId_;
}
void SendMessageRequest::setSessionId(const std::string &sessionId) {
sessionId_ = sessionId;
setParameter(std::string("SessionId"), sessionId);
}

View File

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

View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/avatar/model/StartInstanceRequest.h>
using AlibabaCloud::Avatar::Model::StartInstanceRequest;
StartInstanceRequest::StartInstanceRequest()
: RpcServiceRequest("avatar", "2022-01-30", "StartInstance") {
setMethod(HttpRequest::Method::Post);
}
StartInstanceRequest::~StartInstanceRequest() {}
std::string StartInstanceRequest::getApp() const {
return app_;
}
void StartInstanceRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("App"), app);
}
long StartInstanceRequest::getTenantId() const {
return tenantId_;
}
void StartInstanceRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}
StartInstanceRequest::Channel StartInstanceRequest::getChannel() const {
return channel_;
}
void StartInstanceRequest::setChannel(const StartInstanceRequest::Channel &channel) {
channel_ = channel;
setParameter(std::string("Channel") + ".Type", channel.type);
for(auto const &iter1 : channel.reqConfig) {
setParameter(std::string("Channel") + ".ReqConfig." + iter1.first, iter1.second);
}
}
StartInstanceRequest::CommandRequest StartInstanceRequest::getCommandRequest() const {
return commandRequest_;
}
void StartInstanceRequest::setCommandRequest(const StartInstanceRequest::CommandRequest &commandRequest) {
commandRequest_ = commandRequest;
setParameter(std::string("CommandRequest") + ".AlphaSwitch", commandRequest.alphaSwitch ? "true" : "false");
}
std::string StartInstanceRequest::getUser() const {
return user_;
}
void StartInstanceRequest::setUser(const std::string &user) {
user_ = user;
setParameter(std::string("User"), user);
}

View File

@@ -0,0 +1,97 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/avatar/model/StartInstanceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Avatar;
using namespace AlibabaCloud::Avatar::Model;
StartInstanceResult::StartInstanceResult() :
ServiceResult()
{}
StartInstanceResult::StartInstanceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StartInstanceResult::~StartInstanceResult()
{}
void StartInstanceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["RequestId"].isNull())
data_.requestId = dataNode["RequestId"].asString();
if(!dataNode["SessionId"].isNull())
data_.sessionId = dataNode["SessionId"].asString();
if(!dataNode["Token"].isNull())
data_.token = dataNode["Token"].asString();
auto channelNode = dataNode["Channel"];
if(!channelNode["ChannelId"].isNull())
data_.channel.channelId = channelNode["ChannelId"].asString();
if(!channelNode["Token"].isNull())
data_.channel.token = channelNode["Token"].asString();
if(!channelNode["Type"].isNull())
data_.channel.type = channelNode["Type"].asString();
if(!channelNode["ExpiredTime"].isNull())
data_.channel.expiredTime = channelNode["ExpiredTime"].asString();
if(!channelNode["Nonce"].isNull())
data_.channel.nonce = channelNode["Nonce"].asString();
if(!channelNode["UserId"].isNull())
data_.channel.userId = channelNode["UserId"].asString();
if(!channelNode["AppId"].isNull())
data_.channel.appId = channelNode["AppId"].asString();
if(!channelNode["UserInfoInChannel"].isNull())
data_.channel.userInfoInChannel = channelNode["UserInfoInChannel"].asString();
auto allGslb = channelNode["Gslb"]["gslb"];
for (auto value : allGslb)
data_.channel.gslb.push_back(value.asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string StartInstanceResult::getMessage()const
{
return message_;
}
StartInstanceResult::Data StartInstanceResult::getData()const
{
return data_;
}
std::string StartInstanceResult::getCode()const
{
return code_;
}
bool StartInstanceResult::getSuccess()const
{
return success_;
}

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/avatar/model/StartTimedResetOperateRequest.h>
using AlibabaCloud::Avatar::Model::StartTimedResetOperateRequest;
StartTimedResetOperateRequest::StartTimedResetOperateRequest()
: RpcServiceRequest("avatar", "2022-01-30", "StartTimedResetOperate") {
setMethod(HttpRequest::Method::Post);
}
StartTimedResetOperateRequest::~StartTimedResetOperateRequest() {}
std::string StartTimedResetOperateRequest::getInstanceId() const {
return instanceId_;
}
void StartTimedResetOperateRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
long StartTimedResetOperateRequest::getTenantId() const {
return tenantId_;
}
void StartTimedResetOperateRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}

View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/avatar/model/StartTimedResetOperateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Avatar;
using namespace AlibabaCloud::Avatar::Model;
StartTimedResetOperateResult::StartTimedResetOperateResult() :
ServiceResult()
{}
StartTimedResetOperateResult::StartTimedResetOperateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StartTimedResetOperateResult::~StartTimedResetOperateResult()
{}
void StartTimedResetOperateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["InstanceId"].isNull())
data_.instanceId = dataNode["InstanceId"].asString();
if(!dataNode["TenantId"].isNull())
data_.tenantId = std::stol(dataNode["TenantId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string StartTimedResetOperateResult::getMessage()const
{
return message_;
}
StartTimedResetOperateResult::Data StartTimedResetOperateResult::getData()const
{
return data_;
}
std::string StartTimedResetOperateResult::getCode()const
{
return code_;
}
bool StartTimedResetOperateResult::getSuccess()const
{
return success_;
}

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/avatar/model/StopInstanceRequest.h>
using AlibabaCloud::Avatar::Model::StopInstanceRequest;
StopInstanceRequest::StopInstanceRequest()
: RpcServiceRequest("avatar", "2022-01-30", "StopInstance") {
setMethod(HttpRequest::Method::Post);
}
StopInstanceRequest::~StopInstanceRequest() {}
long StopInstanceRequest::getTenantId() const {
return tenantId_;
}
void StopInstanceRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}
std::string StopInstanceRequest::getSessionId() const {
return sessionId_;
}
void StopInstanceRequest::setSessionId(const std::string &sessionId) {
sessionId_ = sessionId;
setParameter(std::string("SessionId"), sessionId);
}

View File

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

View File

@@ -0,0 +1,95 @@
/*
* 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/avatar/model/SubmitTextTo2DAvatarVideoTaskRequest.h>
using AlibabaCloud::Avatar::Model::SubmitTextTo2DAvatarVideoTaskRequest;
SubmitTextTo2DAvatarVideoTaskRequest::SubmitTextTo2DAvatarVideoTaskRequest()
: RpcServiceRequest("avatar", "2022-01-30", "SubmitTextTo2DAvatarVideoTask") {
setMethod(HttpRequest::Method::Post);
}
SubmitTextTo2DAvatarVideoTaskRequest::~SubmitTextTo2DAvatarVideoTaskRequest() {}
SubmitTextTo2DAvatarVideoTaskRequest::App SubmitTextTo2DAvatarVideoTaskRequest::getApp() const {
return app_;
}
void SubmitTextTo2DAvatarVideoTaskRequest::setApp(const SubmitTextTo2DAvatarVideoTaskRequest::App &app) {
app_ = app;
setParameter(std::string("App") + ".AppId", app.appId);
}
SubmitTextTo2DAvatarVideoTaskRequest::VideoInfo SubmitTextTo2DAvatarVideoTaskRequest::getVideoInfo() const {
return videoInfo_;
}
void SubmitTextTo2DAvatarVideoTaskRequest::setVideoInfo(const SubmitTextTo2DAvatarVideoTaskRequest::VideoInfo &videoInfo) {
videoInfo_ = videoInfo;
setParameter(std::string("VideoInfo") + ".IsAlpha", videoInfo.isAlpha ? "true" : "false");
setParameter(std::string("VideoInfo") + ".BackgroundImageUrl", videoInfo.backgroundImageUrl);
setParameter(std::string("VideoInfo") + ".IsSubtitles", videoInfo.isSubtitles ? "true" : "false");
}
SubmitTextTo2DAvatarVideoTaskRequest::AudioInfo SubmitTextTo2DAvatarVideoTaskRequest::getAudioInfo() const {
return audioInfo_;
}
void SubmitTextTo2DAvatarVideoTaskRequest::setAudioInfo(const SubmitTextTo2DAvatarVideoTaskRequest::AudioInfo &audioInfo) {
audioInfo_ = audioInfo;
setParameter(std::string("AudioInfo") + ".Voice", audioInfo.voice);
setParameter(std::string("AudioInfo") + ".Volume", std::to_string(audioInfo.volume));
setParameter(std::string("AudioInfo") + ".SpeechRate", std::to_string(audioInfo.speechRate));
setParameter(std::string("AudioInfo") + ".PitchRate", std::to_string(audioInfo.pitchRate));
}
SubmitTextTo2DAvatarVideoTaskRequest::AvatarInfo SubmitTextTo2DAvatarVideoTaskRequest::getAvatarInfo() const {
return avatarInfo_;
}
void SubmitTextTo2DAvatarVideoTaskRequest::setAvatarInfo(const SubmitTextTo2DAvatarVideoTaskRequest::AvatarInfo &avatarInfo) {
avatarInfo_ = avatarInfo;
setParameter(std::string("AvatarInfo") + ".Code", avatarInfo.code);
}
long SubmitTextTo2DAvatarVideoTaskRequest::getTenantId() const {
return tenantId_;
}
void SubmitTextTo2DAvatarVideoTaskRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}
std::string SubmitTextTo2DAvatarVideoTaskRequest::getText() const {
return text_;
}
void SubmitTextTo2DAvatarVideoTaskRequest::setText(const std::string &text) {
text_ = text;
setParameter(std::string("Text"), text);
}
std::string SubmitTextTo2DAvatarVideoTaskRequest::getTitle() const {
return title_;
}
void SubmitTextTo2DAvatarVideoTaskRequest::setTitle(const std::string &title) {
title_ = title;
setParameter(std::string("Title"), title);
}

View File

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

View File

@@ -0,0 +1,87 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/avatar/model/SubmitTextTo3DAvatarVideoTaskRequest.h>
using AlibabaCloud::Avatar::Model::SubmitTextTo3DAvatarVideoTaskRequest;
SubmitTextTo3DAvatarVideoTaskRequest::SubmitTextTo3DAvatarVideoTaskRequest()
: RpcServiceRequest("avatar", "2022-01-30", "SubmitTextTo3DAvatarVideoTask") {
setMethod(HttpRequest::Method::Post);
}
SubmitTextTo3DAvatarVideoTaskRequest::~SubmitTextTo3DAvatarVideoTaskRequest() {}
SubmitTextTo3DAvatarVideoTaskRequest::App SubmitTextTo3DAvatarVideoTaskRequest::getApp() const {
return app_;
}
void SubmitTextTo3DAvatarVideoTaskRequest::setApp(const SubmitTextTo3DAvatarVideoTaskRequest::App &app) {
app_ = app;
setParameter(std::string("App") + ".AppId", app.appId);
}
SubmitTextTo3DAvatarVideoTaskRequest::VideoInfo SubmitTextTo3DAvatarVideoTaskRequest::getVideoInfo() const {
return videoInfo_;
}
void SubmitTextTo3DAvatarVideoTaskRequest::setVideoInfo(const SubmitTextTo3DAvatarVideoTaskRequest::VideoInfo &videoInfo) {
videoInfo_ = videoInfo;
setParameter(std::string("VideoInfo") + ".IsAlpha", videoInfo.isAlpha ? "true" : "false");
setParameter(std::string("VideoInfo") + ".BackgroundImageUrl", videoInfo.backgroundImageUrl);
setParameter(std::string("VideoInfo") + ".IsSubtitles", videoInfo.isSubtitles ? "true" : "false");
setParameter(std::string("VideoInfo") + ".Resolution", std::to_string(videoInfo.resolution));
setParameter(std::string("VideoInfo") + ".AlphaFormat", std::to_string(videoInfo.alphaFormat));
}
SubmitTextTo3DAvatarVideoTaskRequest::AvatarInfo SubmitTextTo3DAvatarVideoTaskRequest::getAvatarInfo() const {
return avatarInfo_;
}
void SubmitTextTo3DAvatarVideoTaskRequest::setAvatarInfo(const SubmitTextTo3DAvatarVideoTaskRequest::AvatarInfo &avatarInfo) {
avatarInfo_ = avatarInfo;
setParameter(std::string("AvatarInfo") + ".Code", avatarInfo.code);
setParameter(std::string("AvatarInfo") + ".Locate", std::to_string(avatarInfo.locate));
setParameter(std::string("AvatarInfo") + ".Angle", std::to_string(avatarInfo.angle));
}
long SubmitTextTo3DAvatarVideoTaskRequest::getTenantId() const {
return tenantId_;
}
void SubmitTextTo3DAvatarVideoTaskRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}
std::string SubmitTextTo3DAvatarVideoTaskRequest::getText() const {
return text_;
}
void SubmitTextTo3DAvatarVideoTaskRequest::setText(const std::string &text) {
text_ = text;
setParameter(std::string("Text"), text);
}
std::string SubmitTextTo3DAvatarVideoTaskRequest::getTitle() const {
return title_;
}
void SubmitTextTo3DAvatarVideoTaskRequest::setTitle(const std::string &title) {
title_ = title;
setParameter(std::string("Title"), title);
}

View File

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

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/avatar/model/SubmitTextToSignVideoTaskRequest.h>
using AlibabaCloud::Avatar::Model::SubmitTextToSignVideoTaskRequest;
SubmitTextToSignVideoTaskRequest::SubmitTextToSignVideoTaskRequest()
: RpcServiceRequest("avatar", "2022-01-30", "SubmitTextToSignVideoTask") {
setMethod(HttpRequest::Method::Post);
}
SubmitTextToSignVideoTaskRequest::~SubmitTextToSignVideoTaskRequest() {}
SubmitTextToSignVideoTaskRequest::App SubmitTextToSignVideoTaskRequest::getApp() const {
return app_;
}
void SubmitTextToSignVideoTaskRequest::setApp(const SubmitTextToSignVideoTaskRequest::App &app) {
app_ = app;
setParameter(std::string("App") + ".AppId", app.appId);
}
SubmitTextToSignVideoTaskRequest::VideoInfo SubmitTextToSignVideoTaskRequest::getVideoInfo() const {
return videoInfo_;
}
void SubmitTextToSignVideoTaskRequest::setVideoInfo(const SubmitTextToSignVideoTaskRequest::VideoInfo &videoInfo) {
videoInfo_ = videoInfo;
setParameter(std::string("VideoInfo") + ".IsAlpha", videoInfo.isAlpha ? "true" : "false");
setParameter(std::string("VideoInfo") + ".IsSubtitles", videoInfo.isSubtitles ? "true" : "false");
setParameter(std::string("VideoInfo") + ".Resolution", std::to_string(videoInfo.resolution));
}
long SubmitTextToSignVideoTaskRequest::getTenantId() const {
return tenantId_;
}
void SubmitTextToSignVideoTaskRequest::setTenantId(long tenantId) {
tenantId_ = tenantId;
setParameter(std::string("TenantId"), std::to_string(tenantId));
}
std::string SubmitTextToSignVideoTaskRequest::getText() const {
return text_;
}
void SubmitTextToSignVideoTaskRequest::setText(const std::string &text) {
text_ = text;
setParameter(std::string("Text"), text);
}
std::string SubmitTextToSignVideoTaskRequest::getTitle() const {
return title_;
}
void SubmitTextToSignVideoTaskRequest::setTitle(const std::string &title) {
title_ = title;
setParameter(std::string("Title"), title);
}

View File

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