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

Added param for ActivateLicenseResponse .

Browse Source
This commit is contained in:
sdk-team
2024-07-10 06:30:49 +00:00
parent 8c7efaba0f
commit 2e0f1478c6
69 changed files with 7251 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

629
mseap/src/MseapClient.cc Normal file
View File

@@ -0,0 +1,629 @@
/*
* 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/mseap/MseapClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
namespace
{
const std::string SERVICE_NAME = "mseap";
}
MseapClient::MseapClient(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, "");
}
MseapClient::MseapClient(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, "");
}
MseapClient::MseapClient(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, "");
}
MseapClient::~MseapClient()
{}
MseapClient::ActivateLicenseOutcome MseapClient::activateLicense(const ActivateLicenseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ActivateLicenseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ActivateLicenseOutcome(ActivateLicenseResult(outcome.result()));
else
return ActivateLicenseOutcome(outcome.error());
}
void MseapClient::activateLicenseAsync(const ActivateLicenseRequest& request, const ActivateLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, activateLicense(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::ActivateLicenseOutcomeCallable MseapClient::activateLicenseCallable(const ActivateLicenseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ActivateLicenseOutcome()>>(
[this, request]()
{
return this->activateLicense(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::CallbackTaskOutcome MseapClient::callbackTask(const CallbackTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CallbackTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CallbackTaskOutcome(CallbackTaskResult(outcome.result()));
else
return CallbackTaskOutcome(outcome.error());
}
void MseapClient::callbackTaskAsync(const CallbackTaskRequest& request, const CallbackTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, callbackTask(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::CallbackTaskOutcomeCallable MseapClient::callbackTaskCallable(const CallbackTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CallbackTaskOutcome()>>(
[this, request]()
{
return this->callbackTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::DescribeAgreementStatusOutcome MseapClient::describeAgreementStatus(const DescribeAgreementStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeAgreementStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeAgreementStatusOutcome(DescribeAgreementStatusResult(outcome.result()));
else
return DescribeAgreementStatusOutcome(outcome.error());
}
void MseapClient::describeAgreementStatusAsync(const DescribeAgreementStatusRequest& request, const DescribeAgreementStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeAgreementStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::DescribeAgreementStatusOutcomeCallable MseapClient::describeAgreementStatusCallable(const DescribeAgreementStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeAgreementStatusOutcome()>>(
[this, request]()
{
return this->describeAgreementStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::GenerateUploadFilePolicyForPartnerOutcome MseapClient::generateUploadFilePolicyForPartner(const GenerateUploadFilePolicyForPartnerRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GenerateUploadFilePolicyForPartnerOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GenerateUploadFilePolicyForPartnerOutcome(GenerateUploadFilePolicyForPartnerResult(outcome.result()));
else
return GenerateUploadFilePolicyForPartnerOutcome(outcome.error());
}
void MseapClient::generateUploadFilePolicyForPartnerAsync(const GenerateUploadFilePolicyForPartnerRequest& request, const GenerateUploadFilePolicyForPartnerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, generateUploadFilePolicyForPartner(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::GenerateUploadFilePolicyForPartnerOutcomeCallable MseapClient::generateUploadFilePolicyForPartnerCallable(const GenerateUploadFilePolicyForPartnerRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GenerateUploadFilePolicyForPartnerOutcome()>>(
[this, request]()
{
return this->generateUploadFilePolicyForPartner(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::GetNodeByFlowIdOutcome MseapClient::getNodeByFlowId(const GetNodeByFlowIdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetNodeByFlowIdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetNodeByFlowIdOutcome(GetNodeByFlowIdResult(outcome.result()));
else
return GetNodeByFlowIdOutcome(outcome.error());
}
void MseapClient::getNodeByFlowIdAsync(const GetNodeByFlowIdRequest& request, const GetNodeByFlowIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getNodeByFlowId(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::GetNodeByFlowIdOutcomeCallable MseapClient::getNodeByFlowIdCallable(const GetNodeByFlowIdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetNodeByFlowIdOutcome()>>(
[this, request]()
{
return this->getNodeByFlowId(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::GetNodeByTemplateIdOutcome MseapClient::getNodeByTemplateId(const GetNodeByTemplateIdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetNodeByTemplateIdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetNodeByTemplateIdOutcome(GetNodeByTemplateIdResult(outcome.result()));
else
return GetNodeByTemplateIdOutcome(outcome.error());
}
void MseapClient::getNodeByTemplateIdAsync(const GetNodeByTemplateIdRequest& request, const GetNodeByTemplateIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getNodeByTemplateId(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::GetNodeByTemplateIdOutcomeCallable MseapClient::getNodeByTemplateIdCallable(const GetNodeByTemplateIdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetNodeByTemplateIdOutcome()>>(
[this, request]()
{
return this->getNodeByTemplateId(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::GetProxyByTypeOutcome MseapClient::getProxyByType(const GetProxyByTypeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetProxyByTypeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetProxyByTypeOutcome(GetProxyByTypeResult(outcome.result()));
else
return GetProxyByTypeOutcome(outcome.error());
}
void MseapClient::getProxyByTypeAsync(const GetProxyByTypeRequest& request, const GetProxyByTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getProxyByType(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::GetProxyByTypeOutcomeCallable MseapClient::getProxyByTypeCallable(const GetProxyByTypeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetProxyByTypeOutcome()>>(
[this, request]()
{
return this->getProxyByType(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::GetRedisValueOutcome MseapClient::getRedisValue(const GetRedisValueRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetRedisValueOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetRedisValueOutcome(GetRedisValueResult(outcome.result()));
else
return GetRedisValueOutcome(outcome.error());
}
void MseapClient::getRedisValueAsync(const GetRedisValueRequest& request, const GetRedisValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getRedisValue(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::GetRedisValueOutcomeCallable MseapClient::getRedisValueCallable(const GetRedisValueRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetRedisValueOutcome()>>(
[this, request]()
{
return this->getRedisValue(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::GetVariableOutcome MseapClient::getVariable(const GetVariableRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetVariableOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetVariableOutcome(GetVariableResult(outcome.result()));
else
return GetVariableOutcome(outcome.error());
}
void MseapClient::getVariableAsync(const GetVariableRequest& request, const GetVariableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getVariable(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::GetVariableOutcomeCallable MseapClient::getVariableCallable(const GetVariableRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetVariableOutcome()>>(
[this, request]()
{
return this->getVariable(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::IdentifyCodeOutcome MseapClient::identifyCode(const IdentifyCodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return IdentifyCodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return IdentifyCodeOutcome(IdentifyCodeResult(outcome.result()));
else
return IdentifyCodeOutcome(outcome.error());
}
void MseapClient::identifyCodeAsync(const IdentifyCodeRequest& request, const IdentifyCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, identifyCode(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::IdentifyCodeOutcomeCallable MseapClient::identifyCodeCallable(const IdentifyCodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<IdentifyCodeOutcome()>>(
[this, request]()
{
return this->identifyCode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::PullRpaModelOutcome MseapClient::pullRpaModel(const PullRpaModelRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return PullRpaModelOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return PullRpaModelOutcome(PullRpaModelResult(outcome.result()));
else
return PullRpaModelOutcome(outcome.error());
}
void MseapClient::pullRpaModelAsync(const PullRpaModelRequest& request, const PullRpaModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, pullRpaModel(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::PullRpaModelOutcomeCallable MseapClient::pullRpaModelCallable(const PullRpaModelRequest &request) const
{
auto task = std::make_shared<std::packaged_task<PullRpaModelOutcome()>>(
[this, request]()
{
return this->pullRpaModel(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::PullTaskOutcome MseapClient::pullTask(const PullTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return PullTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return PullTaskOutcome(PullTaskResult(outcome.result()));
else
return PullTaskOutcome(outcome.error());
}
void MseapClient::pullTaskAsync(const PullTaskRequest& request, const PullTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, pullTask(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::PullTaskOutcomeCallable MseapClient::pullTaskCallable(const PullTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<PullTaskOutcome()>>(
[this, request]()
{
return this->pullTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::PushRpaTaskOutcome MseapClient::pushRpaTask(const PushRpaTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return PushRpaTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return PushRpaTaskOutcome(PushRpaTaskResult(outcome.result()));
else
return PushRpaTaskOutcome(outcome.error());
}
void MseapClient::pushRpaTaskAsync(const PushRpaTaskRequest& request, const PushRpaTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, pushRpaTask(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::PushRpaTaskOutcomeCallable MseapClient::pushRpaTaskCallable(const PushRpaTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<PushRpaTaskOutcome()>>(
[this, request]()
{
return this->pushRpaTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::PushRpaTaskDetailOutcome MseapClient::pushRpaTaskDetail(const PushRpaTaskDetailRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return PushRpaTaskDetailOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return PushRpaTaskDetailOutcome(PushRpaTaskDetailResult(outcome.result()));
else
return PushRpaTaskDetailOutcome(outcome.error());
}
void MseapClient::pushRpaTaskDetailAsync(const PushRpaTaskDetailRequest& request, const PushRpaTaskDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, pushRpaTaskDetail(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::PushRpaTaskDetailOutcomeCallable MseapClient::pushRpaTaskDetailCallable(const PushRpaTaskDetailRequest &request) const
{
auto task = std::make_shared<std::packaged_task<PushRpaTaskDetailOutcome()>>(
[this, request]()
{
return this->pushRpaTaskDetail(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::SetRedisValueOutcome MseapClient::setRedisValue(const SetRedisValueRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetRedisValueOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetRedisValueOutcome(SetRedisValueResult(outcome.result()));
else
return SetRedisValueOutcome(outcome.error());
}
void MseapClient::setRedisValueAsync(const SetRedisValueRequest& request, const SetRedisValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setRedisValue(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::SetRedisValueOutcomeCallable MseapClient::setRedisValueCallable(const SetRedisValueRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetRedisValueOutcome()>>(
[this, request]()
{
return this->setRedisValue(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MseapClient::UpdateAgreementStatusOutcome MseapClient::updateAgreementStatus(const UpdateAgreementStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateAgreementStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateAgreementStatusOutcome(UpdateAgreementStatusResult(outcome.result()));
else
return UpdateAgreementStatusOutcome(outcome.error());
}
void MseapClient::updateAgreementStatusAsync(const UpdateAgreementStatusRequest& request, const UpdateAgreementStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateAgreementStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
MseapClient::UpdateAgreementStatusOutcomeCallable MseapClient::updateAgreementStatusCallable(const UpdateAgreementStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateAgreementStatusOutcome()>>(
[this, request]()
{
return this->updateAgreementStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

72
mseap/src/model/ActivateLicenseRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/mseap/model/ActivateLicenseRequest.h>
using AlibabaCloud::Mseap::Model::ActivateLicenseRequest;
ActivateLicenseRequest::ActivateLicenseRequest()
: RpcServiceRequest("mseap", "2021-01-18", "ActivateLicense") {
setMethod(HttpRequest::Method::Post);
}
ActivateLicenseRequest::~ActivateLicenseRequest() {}
std::string ActivateLicenseRequest::getLicenseNo() const {
return licenseNo_;
}
void ActivateLicenseRequest::setLicenseNo(const std::string &licenseNo) {
licenseNo_ = licenseNo;
setParameter(std::string("LicenseNo"), licenseNo);
}
std::string ActivateLicenseRequest::getBizType() const {
return bizType_;
}
void ActivateLicenseRequest::setBizType(const std::string &bizType) {
bizType_ = bizType;
setParameter(std::string("BizType"), bizType);
}
std::string ActivateLicenseRequest::getLicensePublisher() const {
return licensePublisher_;
}
void ActivateLicenseRequest::setLicensePublisher(const std::string &licensePublisher) {
licensePublisher_ = licensePublisher;
setParameter(std::string("LicensePublisher"), licensePublisher);
}
std::string ActivateLicenseRequest::getBizId() const {
return bizId_;
}
void ActivateLicenseRequest::setBizId(const std::string &bizId) {
bizId_ = bizId;
setParameter(std::string("BizId"), bizId);
}
std::string ActivateLicenseRequest::getLicenseCode() const {
return licenseCode_;
}
void ActivateLicenseRequest::setLicenseCode(const std::string &licenseCode) {
licenseCode_ = licenseCode;
setParameter(std::string("LicenseCode"), licenseCode);
}

51
mseap/src/model/ActivateLicenseResult.cc Normal file
View File

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

216
mseap/src/model/CallbackTaskRequest.cc Normal file
View File

@@ -0,0 +1,216 @@
/*
* 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/mseap/model/CallbackTaskRequest.h>
using AlibabaCloud::Mseap::Model::CallbackTaskRequest;
CallbackTaskRequest::CallbackTaskRequest()
: RpcServiceRequest("mseap", "2021-01-18", "CallbackTask") {
setMethod(HttpRequest::Method::Post);
}
CallbackTaskRequest::~CallbackTaskRequest() {}
long CallbackTaskRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void CallbackTaskRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string CallbackTaskRequest::getOutTaskId() const {
return outTaskId_;
}
void CallbackTaskRequest::setOutTaskId(const std::string &outTaskId) {
outTaskId_ = outTaskId;
setParameter(std::string("OutTaskId"), outTaskId);
}
std::string CallbackTaskRequest::getApiType() const {
return apiType_;
}
void CallbackTaskRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
bool CallbackTaskRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void CallbackTaskRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string CallbackTaskRequest::getUserKp() const {
return userKp_;
}
void CallbackTaskRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string CallbackTaskRequest::getLang() const {
return lang_;
}
void CallbackTaskRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string CallbackTaskRequest::getTaskId() const {
return taskId_;
}
void CallbackTaskRequest::setTaskId(const std::string &taskId) {
taskId_ = taskId;
setParameter(std::string("TaskId"), taskId);
}
std::string CallbackTaskRequest::getUserCallerType() const {
return userCallerType_;
}
void CallbackTaskRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string CallbackTaskRequest::getTaskType() const {
return taskType_;
}
void CallbackTaskRequest::setTaskType(const std::string &taskType) {
taskType_ = taskType;
setParameter(std::string("TaskType"), taskType);
}
std::string CallbackTaskRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void CallbackTaskRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string CallbackTaskRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void CallbackTaskRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string CallbackTaskRequest::getOrderId() const {
return orderId_;
}
void CallbackTaskRequest::setOrderId(const std::string &orderId) {
orderId_ = orderId;
setParameter(std::string("OrderId"), orderId);
}
std::string CallbackTaskRequest::getAliyunKp() const {
return aliyunKp_;
}
void CallbackTaskRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string CallbackTaskRequest::getUserBid() const {
return userBid_;
}
void CallbackTaskRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string CallbackTaskRequest::getOriginalRequest() const {
return originalRequest_;
}
void CallbackTaskRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
std::string CallbackTaskRequest::getPrincipalKey() const {
return principalKey_;
}
void CallbackTaskRequest::setPrincipalKey(const std::string &principalKey) {
principalKey_ = principalKey;
setParameter(std::string("PrincipalKey"), principalKey);
}
bool CallbackTaskRequest::getUserCallerSecurityTransport() const {
return userCallerSecurityTransport_;
}
void CallbackTaskRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
userCallerSecurityTransport_ = userCallerSecurityTransport;
setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
}
std::string CallbackTaskRequest::getBizCode() const {
return bizCode_;
}
void CallbackTaskRequest::setBizCode(const std::string &bizCode) {
bizCode_ = bizCode;
setParameter(std::string("BizCode"), bizCode);
}
std::string CallbackTaskRequest::getUserClientIp() const {
return userClientIp_;
}
void CallbackTaskRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string CallbackTaskRequest::getTaskData() const {
return taskData_;
}
void CallbackTaskRequest::setTaskData(const std::string &taskData) {
taskData_ = taskData;
setParameter(std::string("TaskData"), taskData);
}
std::string CallbackTaskRequest::getBid() const {
return bid_;
}
void CallbackTaskRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}

107
mseap/src/model/CallbackTaskResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/CallbackTaskResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
CallbackTaskResult::CallbackTaskResult() :
ServiceResult()
{}
CallbackTaskResult::CallbackTaskResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CallbackTaskResult::~CallbackTaskResult()
{}
void CallbackTaskResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString() == "true";
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool CallbackTaskResult::getAllowRetry()const
{
return allowRetry_;
}
std::string CallbackTaskResult::getErrorMsg()const
{
return errorMsg_;
}
int CallbackTaskResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string CallbackTaskResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string CallbackTaskResult::getErrorCode()const
{
return errorCode_;
}
std::string CallbackTaskResult::getDynamicMessage()const
{
return dynamicMessage_;
}
bool CallbackTaskResult::getModule()const
{
return module_;
}
bool CallbackTaskResult::getSuccess()const
{
return success_;
}
std::string CallbackTaskResult::getAppName()const
{
return appName_;
}

36
mseap/src/model/DescribeAgreementStatusRequest.cc Normal file
View File

@@ -0,0 +1,36 @@
/*
* 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/mseap/model/DescribeAgreementStatusRequest.h>
using AlibabaCloud::Mseap::Model::DescribeAgreementStatusRequest;
DescribeAgreementStatusRequest::DescribeAgreementStatusRequest()
: RpcServiceRequest("mseap", "2021-01-18", "DescribeAgreementStatus") {
setMethod(HttpRequest::Method::Post);
}
DescribeAgreementStatusRequest::~DescribeAgreementStatusRequest() {}
std::string DescribeAgreementStatusRequest::getAgreementCode() const {
return agreementCode_;
}
void DescribeAgreementStatusRequest::setAgreementCode(const std::string &agreementCode) {
agreementCode_ = agreementCode;
setParameter(std::string("AgreementCode"), agreementCode);
}

65
mseap/src/model/DescribeAgreementStatusResult.cc Normal file
View File

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

54
mseap/src/model/GenerateUploadFilePolicyForPartnerRequest.cc Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/mseap/model/GenerateUploadFilePolicyForPartnerRequest.h>
using AlibabaCloud::Mseap::Model::GenerateUploadFilePolicyForPartnerRequest;
GenerateUploadFilePolicyForPartnerRequest::GenerateUploadFilePolicyForPartnerRequest()
: RpcServiceRequest("mseap", "2021-01-18", "GenerateUploadFilePolicyForPartner") {
setMethod(HttpRequest::Method::Post);
}
GenerateUploadFilePolicyForPartnerRequest::~GenerateUploadFilePolicyForPartnerRequest() {}
std::string GenerateUploadFilePolicyForPartnerRequest::getFileType() const {
return fileType_;
}
void GenerateUploadFilePolicyForPartnerRequest::setFileType(const std::string &fileType) {
fileType_ = fileType;
setParameter(std::string("FileType"), fileType);
}
std::string GenerateUploadFilePolicyForPartnerRequest::getBizType() const {
return bizType_;
}
void GenerateUploadFilePolicyForPartnerRequest::setBizType(const std::string &bizType) {
bizType_ = bizType;
setParameter(std::string("BizType"), bizType);
}
std::string GenerateUploadFilePolicyForPartnerRequest::getFileName() const {
return fileName_;
}
void GenerateUploadFilePolicyForPartnerRequest::setFileName(const std::string &fileName) {
fileName_ = fileName;
setParameter(std::string("FileName"), fileName);
}

128
mseap/src/model/GenerateUploadFilePolicyForPartnerResult.cc Normal file
View File

@@ -0,0 +1,128 @@
/*
* 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/mseap/model/GenerateUploadFilePolicyForPartnerResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
GenerateUploadFilePolicyForPartnerResult::GenerateUploadFilePolicyForPartnerResult() :
ServiceResult()
{}
GenerateUploadFilePolicyForPartnerResult::GenerateUploadFilePolicyForPartnerResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GenerateUploadFilePolicyForPartnerResult::~GenerateUploadFilePolicyForPartnerResult()
{}
void GenerateUploadFilePolicyForPartnerResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto moduleNode = value["Module"];
if(!moduleNode["AccessId"].isNull())
module_.accessId = moduleNode["AccessId"].asString();
if(!moduleNode["EncodedPolicy"].isNull())
module_.encodedPolicy = moduleNode["EncodedPolicy"].asString();
if(!moduleNode["Signature"].isNull())
module_.signature = moduleNode["Signature"].asString();
if(!moduleNode["FileDir"].isNull())
module_.fileDir = moduleNode["FileDir"].asString();
if(!moduleNode["Host"].isNull())
module_.host = moduleNode["Host"].asString();
if(!moduleNode["ExpireTime"].isNull())
module_.expireTime = std::stol(moduleNode["ExpireTime"].asString());
if(!moduleNode["OssUrl"].isNull())
module_.ossUrl = moduleNode["OssUrl"].asString();
auto allErrorArgs = value["ErrorArgs"]["ErrorArg"];
for (const auto &item : allErrorArgs)
errorArgs_.push_back(item.asString());
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool GenerateUploadFilePolicyForPartnerResult::getAllowRetry()const
{
return allowRetry_;
}
std::vector<std::string> GenerateUploadFilePolicyForPartnerResult::getErrorArgs()const
{
return errorArgs_;
}
int GenerateUploadFilePolicyForPartnerResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string GenerateUploadFilePolicyForPartnerResult::getErrorMsg()const
{
return errorMsg_;
}
std::string GenerateUploadFilePolicyForPartnerResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string GenerateUploadFilePolicyForPartnerResult::getDynamicMessage()const
{
return dynamicMessage_;
}
std::string GenerateUploadFilePolicyForPartnerResult::getErrorCode()const
{
return errorCode_;
}
GenerateUploadFilePolicyForPartnerResult::Module GenerateUploadFilePolicyForPartnerResult::getModule()const
{
return module_;
}
bool GenerateUploadFilePolicyForPartnerResult::getSuccess()const
{
return success_;
}
std::string GenerateUploadFilePolicyForPartnerResult::getAppName()const
{
return appName_;
}

162
mseap/src/model/GetNodeByFlowIdRequest.cc Normal file
View File

@@ -0,0 +1,162 @@
/*
* 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/mseap/model/GetNodeByFlowIdRequest.h>
using AlibabaCloud::Mseap::Model::GetNodeByFlowIdRequest;
GetNodeByFlowIdRequest::GetNodeByFlowIdRequest()
: RpcServiceRequest("mseap", "2021-01-18", "GetNodeByFlowId") {
setMethod(HttpRequest::Method::Post);
}
GetNodeByFlowIdRequest::~GetNodeByFlowIdRequest() {}
long GetNodeByFlowIdRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void GetNodeByFlowIdRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string GetNodeByFlowIdRequest::getApiType() const {
return apiType_;
}
void GetNodeByFlowIdRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
bool GetNodeByFlowIdRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void GetNodeByFlowIdRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string GetNodeByFlowIdRequest::getUserKp() const {
return userKp_;
}
void GetNodeByFlowIdRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string GetNodeByFlowIdRequest::getLang() const {
return lang_;
}
void GetNodeByFlowIdRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string GetNodeByFlowIdRequest::getUserCallerType() const {
return userCallerType_;
}
void GetNodeByFlowIdRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string GetNodeByFlowIdRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void GetNodeByFlowIdRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string GetNodeByFlowIdRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void GetNodeByFlowIdRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string GetNodeByFlowIdRequest::getAliyunKp() const {
return aliyunKp_;
}
void GetNodeByFlowIdRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string GetNodeByFlowIdRequest::getUserBid() const {
return userBid_;
}
void GetNodeByFlowIdRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string GetNodeByFlowIdRequest::getOriginalRequest() const {
return originalRequest_;
}
void GetNodeByFlowIdRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
bool GetNodeByFlowIdRequest::getUserCallerSecurityTransport() const {
return userCallerSecurityTransport_;
}
void GetNodeByFlowIdRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
userCallerSecurityTransport_ = userCallerSecurityTransport;
setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
}
std::string GetNodeByFlowIdRequest::getUserClientIp() const {
return userClientIp_;
}
void GetNodeByFlowIdRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string GetNodeByFlowIdRequest::getBid() const {
return bid_;
}
void GetNodeByFlowIdRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}
long GetNodeByFlowIdRequest::getFlowId() const {
return flowId_;
}
void GetNodeByFlowIdRequest::setFlowId(long flowId) {
flowId_ = flowId;
setParameter(std::string("FlowId"), std::to_string(flowId));
}

107
mseap/src/model/GetNodeByFlowIdResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/GetNodeByFlowIdResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
GetNodeByFlowIdResult::GetNodeByFlowIdResult() :
ServiceResult()
{}
GetNodeByFlowIdResult::GetNodeByFlowIdResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetNodeByFlowIdResult::~GetNodeByFlowIdResult()
{}
void GetNodeByFlowIdResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool GetNodeByFlowIdResult::getAllowRetry()const
{
return allowRetry_;
}
std::string GetNodeByFlowIdResult::getErrorMsg()const
{
return errorMsg_;
}
int GetNodeByFlowIdResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string GetNodeByFlowIdResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string GetNodeByFlowIdResult::getErrorCode()const
{
return errorCode_;
}
std::string GetNodeByFlowIdResult::getDynamicMessage()const
{
return dynamicMessage_;
}
std::string GetNodeByFlowIdResult::getModule()const
{
return module_;
}
bool GetNodeByFlowIdResult::getSuccess()const
{
return success_;
}
std::string GetNodeByFlowIdResult::getAppName()const
{
return appName_;
}

162
mseap/src/model/GetNodeByTemplateIdRequest.cc Normal file
View File

@@ -0,0 +1,162 @@
/*
* 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/mseap/model/GetNodeByTemplateIdRequest.h>
using AlibabaCloud::Mseap::Model::GetNodeByTemplateIdRequest;
GetNodeByTemplateIdRequest::GetNodeByTemplateIdRequest()
: RpcServiceRequest("mseap", "2021-01-18", "GetNodeByTemplateId") {
setMethod(HttpRequest::Method::Post);
}
GetNodeByTemplateIdRequest::~GetNodeByTemplateIdRequest() {}
long GetNodeByTemplateIdRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void GetNodeByTemplateIdRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string GetNodeByTemplateIdRequest::getApiType() const {
return apiType_;
}
void GetNodeByTemplateIdRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
bool GetNodeByTemplateIdRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void GetNodeByTemplateIdRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string GetNodeByTemplateIdRequest::getUserKp() const {
return userKp_;
}
void GetNodeByTemplateIdRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string GetNodeByTemplateIdRequest::getLang() const {
return lang_;
}
void GetNodeByTemplateIdRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string GetNodeByTemplateIdRequest::getUserCallerType() const {
return userCallerType_;
}
void GetNodeByTemplateIdRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string GetNodeByTemplateIdRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void GetNodeByTemplateIdRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string GetNodeByTemplateIdRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void GetNodeByTemplateIdRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string GetNodeByTemplateIdRequest::getAliyunKp() const {
return aliyunKp_;
}
void GetNodeByTemplateIdRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string GetNodeByTemplateIdRequest::getUserBid() const {
return userBid_;
}
void GetNodeByTemplateIdRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string GetNodeByTemplateIdRequest::getOriginalRequest() const {
return originalRequest_;
}
void GetNodeByTemplateIdRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
long GetNodeByTemplateIdRequest::getTemplateId() const {
return templateId_;
}
void GetNodeByTemplateIdRequest::setTemplateId(long templateId) {
templateId_ = templateId;
setParameter(std::string("TemplateId"), std::to_string(templateId));
}
bool GetNodeByTemplateIdRequest::getUserCallerSecurityTransport() const {
return userCallerSecurityTransport_;
}
void GetNodeByTemplateIdRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
userCallerSecurityTransport_ = userCallerSecurityTransport;
setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
}
std::string GetNodeByTemplateIdRequest::getUserClientIp() const {
return userClientIp_;
}
void GetNodeByTemplateIdRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string GetNodeByTemplateIdRequest::getBid() const {
return bid_;
}
void GetNodeByTemplateIdRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}

107
mseap/src/model/GetNodeByTemplateIdResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/GetNodeByTemplateIdResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
GetNodeByTemplateIdResult::GetNodeByTemplateIdResult() :
ServiceResult()
{}
GetNodeByTemplateIdResult::GetNodeByTemplateIdResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetNodeByTemplateIdResult::~GetNodeByTemplateIdResult()
{}
void GetNodeByTemplateIdResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool GetNodeByTemplateIdResult::getAllowRetry()const
{
return allowRetry_;
}
std::string GetNodeByTemplateIdResult::getErrorMsg()const
{
return errorMsg_;
}
int GetNodeByTemplateIdResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string GetNodeByTemplateIdResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string GetNodeByTemplateIdResult::getErrorCode()const
{
return errorCode_;
}
std::string GetNodeByTemplateIdResult::getDynamicMessage()const
{
return dynamicMessage_;
}
std::string GetNodeByTemplateIdResult::getModule()const
{
return module_;
}
bool GetNodeByTemplateIdResult::getSuccess()const
{
return success_;
}
std::string GetNodeByTemplateIdResult::getAppName()const
{
return appName_;
}

162
mseap/src/model/GetProxyByTypeRequest.cc Normal file
View File

@@ -0,0 +1,162 @@
/*
* 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/mseap/model/GetProxyByTypeRequest.h>
using AlibabaCloud::Mseap::Model::GetProxyByTypeRequest;
GetProxyByTypeRequest::GetProxyByTypeRequest()
: RpcServiceRequest("mseap", "2021-01-18", "GetProxyByType") {
setMethod(HttpRequest::Method::Post);
}
GetProxyByTypeRequest::~GetProxyByTypeRequest() {}
long GetProxyByTypeRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void GetProxyByTypeRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
int GetProxyByTypeRequest::getType() const {
return type_;
}
void GetProxyByTypeRequest::setType(int type) {
type_ = type;
setParameter(std::string("Type"), std::to_string(type));
}
std::string GetProxyByTypeRequest::getApiType() const {
return apiType_;
}
void GetProxyByTypeRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
bool GetProxyByTypeRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void GetProxyByTypeRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string GetProxyByTypeRequest::getUserKp() const {
return userKp_;
}
void GetProxyByTypeRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string GetProxyByTypeRequest::getLang() const {
return lang_;
}
void GetProxyByTypeRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string GetProxyByTypeRequest::getUserCallerType() const {
return userCallerType_;
}
void GetProxyByTypeRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string GetProxyByTypeRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void GetProxyByTypeRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string GetProxyByTypeRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void GetProxyByTypeRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string GetProxyByTypeRequest::getAliyunKp() const {
return aliyunKp_;
}
void GetProxyByTypeRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string GetProxyByTypeRequest::getUserBid() const {
return userBid_;
}
void GetProxyByTypeRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string GetProxyByTypeRequest::getOriginalRequest() const {
return originalRequest_;
}
void GetProxyByTypeRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
bool GetProxyByTypeRequest::getUserCallerSecurityTransport() const {
return userCallerSecurityTransport_;
}
void GetProxyByTypeRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
userCallerSecurityTransport_ = userCallerSecurityTransport;
setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
}
std::string GetProxyByTypeRequest::getUserClientIp() const {
return userClientIp_;
}
void GetProxyByTypeRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string GetProxyByTypeRequest::getBid() const {
return bid_;
}
void GetProxyByTypeRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}

107
mseap/src/model/GetProxyByTypeResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/GetProxyByTypeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
GetProxyByTypeResult::GetProxyByTypeResult() :
ServiceResult()
{}
GetProxyByTypeResult::GetProxyByTypeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetProxyByTypeResult::~GetProxyByTypeResult()
{}
void GetProxyByTypeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool GetProxyByTypeResult::getAllowRetry()const
{
return allowRetry_;
}
std::string GetProxyByTypeResult::getErrorMsg()const
{
return errorMsg_;
}
int GetProxyByTypeResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string GetProxyByTypeResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string GetProxyByTypeResult::getErrorCode()const
{
return errorCode_;
}
std::string GetProxyByTypeResult::getDynamicMessage()const
{
return dynamicMessage_;
}
std::string GetProxyByTypeResult::getModule()const
{
return module_;
}
bool GetProxyByTypeResult::getSuccess()const
{
return success_;
}
std::string GetProxyByTypeResult::getAppName()const
{
return appName_;
}

180
mseap/src/model/GetRedisValueRequest.cc Normal file
View File

@@ -0,0 +1,180 @@
/*
* 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/mseap/model/GetRedisValueRequest.h>
using AlibabaCloud::Mseap::Model::GetRedisValueRequest;
GetRedisValueRequest::GetRedisValueRequest()
: RpcServiceRequest("mseap", "2021-01-18", "GetRedisValue") {
setMethod(HttpRequest::Method::Post);
}
GetRedisValueRequest::~GetRedisValueRequest() {}
long GetRedisValueRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void GetRedisValueRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string GetRedisValueRequest::getApiType() const {
return apiType_;
}
void GetRedisValueRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
long GetRedisValueRequest::getTimeout() const {
return timeout_;
}
void GetRedisValueRequest::setTimeout(long timeout) {
timeout_ = timeout;
setParameter(std::string("Timeout"), std::to_string(timeout));
}
bool GetRedisValueRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void GetRedisValueRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string GetRedisValueRequest::getUserKp() const {
return userKp_;
}
void GetRedisValueRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string GetRedisValueRequest::getLang() const {
return lang_;
}
void GetRedisValueRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string GetRedisValueRequest::getValue() const {
return value_;
}
void GetRedisValueRequest::setValue(const std::string &value) {
value_ = value;
setParameter(std::string("Value"), value);
}
std::string GetRedisValueRequest::getKey() const {
return key_;
}
void GetRedisValueRequest::setKey(const std::string &key) {
key_ = key;
setParameter(std::string("Key"), key);
}
std::string GetRedisValueRequest::getUserCallerType() const {
return userCallerType_;
}
void GetRedisValueRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string GetRedisValueRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void GetRedisValueRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string GetRedisValueRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void GetRedisValueRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string GetRedisValueRequest::getAliyunKp() const {
return aliyunKp_;
}
void GetRedisValueRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string GetRedisValueRequest::getUserBid() const {
return userBid_;
}
void GetRedisValueRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string GetRedisValueRequest::getOriginalRequest() const {
return originalRequest_;
}
void GetRedisValueRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
bool GetRedisValueRequest::getUserCallerSecurityTransport() const {
return userCallerSecurityTransport_;
}
void GetRedisValueRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
userCallerSecurityTransport_ = userCallerSecurityTransport;
setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
}
std::string GetRedisValueRequest::getUserClientIp() const {
return userClientIp_;
}
void GetRedisValueRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string GetRedisValueRequest::getBid() const {
return bid_;
}
void GetRedisValueRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}

107
mseap/src/model/GetRedisValueResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/GetRedisValueResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
GetRedisValueResult::GetRedisValueResult() :
ServiceResult()
{}
GetRedisValueResult::GetRedisValueResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetRedisValueResult::~GetRedisValueResult()
{}
void GetRedisValueResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool GetRedisValueResult::getAllowRetry()const
{
return allowRetry_;
}
std::string GetRedisValueResult::getErrorMsg()const
{
return errorMsg_;
}
int GetRedisValueResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string GetRedisValueResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string GetRedisValueResult::getErrorCode()const
{
return errorCode_;
}
std::string GetRedisValueResult::getDynamicMessage()const
{
return dynamicMessage_;
}
std::string GetRedisValueResult::getModule()const
{
return module_;
}
bool GetRedisValueResult::getSuccess()const
{
return success_;
}
std::string GetRedisValueResult::getAppName()const
{
return appName_;
}

162
mseap/src/model/GetVariableRequest.cc Normal file
View File

@@ -0,0 +1,162 @@
/*
* 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/mseap/model/GetVariableRequest.h>
using AlibabaCloud::Mseap::Model::GetVariableRequest;
GetVariableRequest::GetVariableRequest()
: RpcServiceRequest("mseap", "2021-01-18", "GetVariable") {
setMethod(HttpRequest::Method::Post);
}
GetVariableRequest::~GetVariableRequest() {}
long GetVariableRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void GetVariableRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string GetVariableRequest::getApiType() const {
return apiType_;
}
void GetVariableRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
bool GetVariableRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void GetVariableRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string GetVariableRequest::getUserKp() const {
return userKp_;
}
void GetVariableRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string GetVariableRequest::getLang() const {
return lang_;
}
void GetVariableRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string GetVariableRequest::getUserCallerType() const {
return userCallerType_;
}
void GetVariableRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string GetVariableRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void GetVariableRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string GetVariableRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void GetVariableRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string GetVariableRequest::getAliyunKp() const {
return aliyunKp_;
}
void GetVariableRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string GetVariableRequest::getUserBid() const {
return userBid_;
}
void GetVariableRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string GetVariableRequest::getOriginalRequest() const {
return originalRequest_;
}
void GetVariableRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
long GetVariableRequest::getTemplateId() const {
return templateId_;
}
void GetVariableRequest::setTemplateId(long templateId) {
templateId_ = templateId;
setParameter(std::string("TemplateId"), std::to_string(templateId));
}
bool GetVariableRequest::getUserCallerSecurityTransport() const {
return userCallerSecurityTransport_;
}
void GetVariableRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
userCallerSecurityTransport_ = userCallerSecurityTransport;
setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
}
std::string GetVariableRequest::getUserClientIp() const {
return userClientIp_;
}
void GetVariableRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string GetVariableRequest::getBid() const {
return bid_;
}
void GetVariableRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}

107
mseap/src/model/GetVariableResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/GetVariableResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
GetVariableResult::GetVariableResult() :
ServiceResult()
{}
GetVariableResult::GetVariableResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetVariableResult::~GetVariableResult()
{}
void GetVariableResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool GetVariableResult::getAllowRetry()const
{
return allowRetry_;
}
std::string GetVariableResult::getErrorMsg()const
{
return errorMsg_;
}
int GetVariableResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string GetVariableResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string GetVariableResult::getErrorCode()const
{
return errorCode_;
}
std::string GetVariableResult::getDynamicMessage()const
{
return dynamicMessage_;
}
std::string GetVariableResult::getModule()const
{
return module_;
}
bool GetVariableResult::getSuccess()const
{
return success_;
}
std::string GetVariableResult::getAppName()const
{
return appName_;
}

180
mseap/src/model/IdentifyCodeRequest.cc Normal file
View File

@@ -0,0 +1,180 @@
/*
* 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/mseap/model/IdentifyCodeRequest.h>
using AlibabaCloud::Mseap::Model::IdentifyCodeRequest;
IdentifyCodeRequest::IdentifyCodeRequest()
: RpcServiceRequest("mseap", "2021-01-18", "IdentifyCode") {
setMethod(HttpRequest::Method::Post);
}
IdentifyCodeRequest::~IdentifyCodeRequest() {}
std::string IdentifyCodeRequest::getData() const {
return data_;
}
void IdentifyCodeRequest::setData(const std::string &data) {
data_ = data;
setParameter(std::string("Data"), data);
}
long IdentifyCodeRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void IdentifyCodeRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string IdentifyCodeRequest::getType() const {
return type_;
}
void IdentifyCodeRequest::setType(const std::string &type) {
type_ = type;
setParameter(std::string("Type"), type);
}
std::string IdentifyCodeRequest::getApiType() const {
return apiType_;
}
void IdentifyCodeRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
bool IdentifyCodeRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void IdentifyCodeRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string IdentifyCodeRequest::getUserKp() const {
return userKp_;
}
void IdentifyCodeRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string IdentifyCodeRequest::getLang() const {
return lang_;
}
void IdentifyCodeRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string IdentifyCodeRequest::getUserCallerType() const {
return userCallerType_;
}
void IdentifyCodeRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string IdentifyCodeRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void IdentifyCodeRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string IdentifyCodeRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void IdentifyCodeRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string IdentifyCodeRequest::getAliyunKp() const {
return aliyunKp_;
}
void IdentifyCodeRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string IdentifyCodeRequest::getUserBid() const {
return userBid_;
}
void IdentifyCodeRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string IdentifyCodeRequest::getOriginalRequest() const {
return originalRequest_;
}
void IdentifyCodeRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
std::string IdentifyCodeRequest::getLabel() const {
return label_;
}
void IdentifyCodeRequest::setLabel(const std::string &label) {
label_ = label;
setParameter(std::string("Label"), label);
}
bool IdentifyCodeRequest::getUserCallerSecurityTransport() const {
return userCallerSecurityTransport_;
}
void IdentifyCodeRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
userCallerSecurityTransport_ = userCallerSecurityTransport;
setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
}
std::string IdentifyCodeRequest::getUserClientIp() const {
return userClientIp_;
}
void IdentifyCodeRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string IdentifyCodeRequest::getBid() const {
return bid_;
}
void IdentifyCodeRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}

107
mseap/src/model/IdentifyCodeResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/IdentifyCodeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
IdentifyCodeResult::IdentifyCodeResult() :
ServiceResult()
{}
IdentifyCodeResult::IdentifyCodeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
IdentifyCodeResult::~IdentifyCodeResult()
{}
void IdentifyCodeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool IdentifyCodeResult::getAllowRetry()const
{
return allowRetry_;
}
std::string IdentifyCodeResult::getErrorMsg()const
{
return errorMsg_;
}
int IdentifyCodeResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string IdentifyCodeResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string IdentifyCodeResult::getErrorCode()const
{
return errorCode_;
}
std::string IdentifyCodeResult::getDynamicMessage()const
{
return dynamicMessage_;
}
std::string IdentifyCodeResult::getModule()const
{
return module_;
}
bool IdentifyCodeResult::getSuccess()const
{
return success_;
}
std::string IdentifyCodeResult::getAppName()const
{
return appName_;
}

153
mseap/src/model/PullRpaModelRequest.cc Normal file
View File

@@ -0,0 +1,153 @@
/*
* 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/mseap/model/PullRpaModelRequest.h>
using AlibabaCloud::Mseap::Model::PullRpaModelRequest;
PullRpaModelRequest::PullRpaModelRequest()
: RpcServiceRequest("mseap", "2021-01-18", "PullRpaModel") {
setMethod(HttpRequest::Method::Post);
}
PullRpaModelRequest::~PullRpaModelRequest() {}
long PullRpaModelRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void PullRpaModelRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string PullRpaModelRequest::getApiType() const {
return apiType_;
}
void PullRpaModelRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
bool PullRpaModelRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void PullRpaModelRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string PullRpaModelRequest::getUserKp() const {
return userKp_;
}
void PullRpaModelRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string PullRpaModelRequest::getLang() const {
return lang_;
}
void PullRpaModelRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string PullRpaModelRequest::getUserCallerType() const {
return userCallerType_;
}
void PullRpaModelRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string PullRpaModelRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void PullRpaModelRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string PullRpaModelRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void PullRpaModelRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string PullRpaModelRequest::getAliyunKp() const {
return aliyunKp_;
}
void PullRpaModelRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string PullRpaModelRequest::getUserBid() const {
return userBid_;
}
void PullRpaModelRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string PullRpaModelRequest::getOriginalRequest() const {
return originalRequest_;
}
void PullRpaModelRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
long PullRpaModelRequest::getTemplateId() const {
return templateId_;
}
void PullRpaModelRequest::setTemplateId(long templateId) {
templateId_ = templateId;
setParameter(std::string("TemplateId"), std::to_string(templateId));
}
std::string PullRpaModelRequest::getUserClientIp() const {
return userClientIp_;
}
void PullRpaModelRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string PullRpaModelRequest::getBid() const {
return bid_;
}
void PullRpaModelRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}

107
mseap/src/model/PullRpaModelResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/PullRpaModelResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
PullRpaModelResult::PullRpaModelResult() :
ServiceResult()
{}
PullRpaModelResult::PullRpaModelResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
PullRpaModelResult::~PullRpaModelResult()
{}
void PullRpaModelResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool PullRpaModelResult::getAllowRetry()const
{
return allowRetry_;
}
std::string PullRpaModelResult::getErrorMsg()const
{
return errorMsg_;
}
int PullRpaModelResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string PullRpaModelResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string PullRpaModelResult::getErrorCode()const
{
return errorCode_;
}
std::string PullRpaModelResult::getDynamicMessage()const
{
return dynamicMessage_;
}
std::string PullRpaModelResult::getModule()const
{
return module_;
}
bool PullRpaModelResult::getSuccess()const
{
return success_;
}
std::string PullRpaModelResult::getAppName()const
{
return appName_;
}

189
mseap/src/model/PullTaskRequest.cc Normal file
View File

@@ -0,0 +1,189 @@
/*
* 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/mseap/model/PullTaskRequest.h>
using AlibabaCloud::Mseap::Model::PullTaskRequest;
PullTaskRequest::PullTaskRequest()
: RpcServiceRequest("mseap", "2021-01-18", "PullTask") {
setMethod(HttpRequest::Method::Post);
}
PullTaskRequest::~PullTaskRequest() {}
long PullTaskRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void PullTaskRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string PullTaskRequest::getApiType() const {
return apiType_;
}
void PullTaskRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
bool PullTaskRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void PullTaskRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string PullTaskRequest::getUserKp() const {
return userKp_;
}
void PullTaskRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string PullTaskRequest::getLang() const {
return lang_;
}
void PullTaskRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string PullTaskRequest::getUserCallerType() const {
return userCallerType_;
}
void PullTaskRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string PullTaskRequest::getTaskType() const {
return taskType_;
}
void PullTaskRequest::setTaskType(const std::string &taskType) {
taskType_ = taskType;
setParameter(std::string("TaskType"), taskType);
}
std::string PullTaskRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void PullTaskRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string PullTaskRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void PullTaskRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string PullTaskRequest::getOrderId() const {
return orderId_;
}
void PullTaskRequest::setOrderId(const std::string &orderId) {
orderId_ = orderId;
setParameter(std::string("OrderId"), orderId);
}
std::string PullTaskRequest::getAliyunKp() const {
return aliyunKp_;
}
void PullTaskRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string PullTaskRequest::getUserBid() const {
return userBid_;
}
void PullTaskRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string PullTaskRequest::getOriginalRequest() const {
return originalRequest_;
}
void PullTaskRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
std::string PullTaskRequest::getPrincipalKey() const {
return principalKey_;
}
void PullTaskRequest::setPrincipalKey(const std::string &principalKey) {
principalKey_ = principalKey;
setParameter(std::string("PrincipalKey"), principalKey);
}
bool PullTaskRequest::getUserCallerSecurityTransport() const {
return userCallerSecurityTransport_;
}
void PullTaskRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
userCallerSecurityTransport_ = userCallerSecurityTransport;
setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
}
std::string PullTaskRequest::getBizCode() const {
return bizCode_;
}
void PullTaskRequest::setBizCode(const std::string &bizCode) {
bizCode_ = bizCode;
setParameter(std::string("BizCode"), bizCode);
}
std::string PullTaskRequest::getUserClientIp() const {
return userClientIp_;
}
void PullTaskRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string PullTaskRequest::getBid() const {
return bid_;
}
void PullTaskRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}

120
mseap/src/model/PullTaskResult.cc Normal file
View File

@@ -0,0 +1,120 @@
/*
* 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/mseap/model/PullTaskResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
PullTaskResult::PullTaskResult() :
ServiceResult()
{}
PullTaskResult::PullTaskResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
PullTaskResult::~PullTaskResult()
{}
void PullTaskResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto moduleNode = value["Module"];
if(!moduleNode["TaskId"].isNull())
module_.taskId = moduleNode["TaskId"].asString();
if(!moduleNode["OutTaskId"].isNull())
module_.outTaskId = moduleNode["OutTaskId"].asString();
if(!moduleNode["TaskType"].isNull())
module_.taskType = moduleNode["TaskType"].asString();
if(!moduleNode["TaskData"].isNull())
module_.taskData = moduleNode["TaskData"].asString();
if(!moduleNode["OrderId"].isNull())
module_.orderId = moduleNode["OrderId"].asString();
if(!moduleNode["BizCode"].isNull())
module_.bizCode = moduleNode["BizCode"].asString();
if(!moduleNode["PrincipalKey"].isNull())
module_.principalKey = moduleNode["PrincipalKey"].asString();
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool PullTaskResult::getAllowRetry()const
{
return allowRetry_;
}
std::string PullTaskResult::getErrorMsg()const
{
return errorMsg_;
}
int PullTaskResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string PullTaskResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string PullTaskResult::getErrorCode()const
{
return errorCode_;
}
std::string PullTaskResult::getDynamicMessage()const
{
return dynamicMessage_;
}
PullTaskResult::Module PullTaskResult::getModule()const
{
return module_;
}
bool PullTaskResult::getSuccess()const
{
return success_;
}
std::string PullTaskResult::getAppName()const
{
return appName_;
}

225
mseap/src/model/PushRpaTaskDetailRequest.cc Normal file
View File

@@ -0,0 +1,225 @@
/*
* 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/mseap/model/PushRpaTaskDetailRequest.h>
using AlibabaCloud::Mseap::Model::PushRpaTaskDetailRequest;
PushRpaTaskDetailRequest::PushRpaTaskDetailRequest()
: RpcServiceRequest("mseap", "2021-01-18", "PushRpaTaskDetail") {
setMethod(HttpRequest::Method::Post);
}
PushRpaTaskDetailRequest::~PushRpaTaskDetailRequest() {}
long PushRpaTaskDetailRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void PushRpaTaskDetailRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string PushRpaTaskDetailRequest::getApiType() const {
return apiType_;
}
void PushRpaTaskDetailRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
long PushRpaTaskDetailRequest::getModelDetailId() const {
return modelDetailId_;
}
void PushRpaTaskDetailRequest::setModelDetailId(long modelDetailId) {
modelDetailId_ = modelDetailId;
setParameter(std::string("ModelDetailId"), std::to_string(modelDetailId));
}
std::string PushRpaTaskDetailRequest::getUserKp() const {
return userKp_;
}
void PushRpaTaskDetailRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string PushRpaTaskDetailRequest::getLang() const {
return lang_;
}
void PushRpaTaskDetailRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
long PushRpaTaskDetailRequest::getTaskId() const {
return taskId_;
}
void PushRpaTaskDetailRequest::setTaskId(long taskId) {
taskId_ = taskId;
setParameter(std::string("TaskId"), std::to_string(taskId));
}
std::string PushRpaTaskDetailRequest::getUserCallerType() const {
return userCallerType_;
}
void PushRpaTaskDetailRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string PushRpaTaskDetailRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void PushRpaTaskDetailRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string PushRpaTaskDetailRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void PushRpaTaskDetailRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string PushRpaTaskDetailRequest::getAliyunKp() const {
return aliyunKp_;
}
void PushRpaTaskDetailRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string PushRpaTaskDetailRequest::getUserBid() const {
return userBid_;
}
void PushRpaTaskDetailRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string PushRpaTaskDetailRequest::getOriginalRequest() const {
return originalRequest_;
}
void PushRpaTaskDetailRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
std::string PushRpaTaskDetailRequest::getInputScreenshot() const {
return inputScreenshot_;
}
void PushRpaTaskDetailRequest::setInputScreenshot(const std::string &inputScreenshot) {
inputScreenshot_ = inputScreenshot;
setParameter(std::string("InputScreenshot"), inputScreenshot);
}
std::string PushRpaTaskDetailRequest::getInputData() const {
return inputData_;
}
void PushRpaTaskDetailRequest::setInputData(const std::string &inputData) {
inputData_ = inputData;
setParameter(std::string("InputData"), inputData);
}
std::string PushRpaTaskDetailRequest::getOutputData() const {
return outputData_;
}
void PushRpaTaskDetailRequest::setOutputData(const std::string &outputData) {
outputData_ = outputData;
setParameter(std::string("OutputData"), outputData);
}
std::string PushRpaTaskDetailRequest::getInputHtml() const {
return inputHtml_;
}
void PushRpaTaskDetailRequest::setInputHtml(const std::string &inputHtml) {
inputHtml_ = inputHtml;
setParameter(std::string("InputHtml"), inputHtml);
}
long PushRpaTaskDetailRequest::getTaskDetailId() const {
return taskDetailId_;
}
void PushRpaTaskDetailRequest::setTaskDetailId(long taskDetailId) {
taskDetailId_ = taskDetailId;
setParameter(std::string("TaskDetailId"), std::to_string(taskDetailId));
}
std::string PushRpaTaskDetailRequest::getOutputHtml() const {
return outputHtml_;
}
void PushRpaTaskDetailRequest::setOutputHtml(const std::string &outputHtml) {
outputHtml_ = outputHtml;
setParameter(std::string("OutputHtml"), outputHtml);
}
std::string PushRpaTaskDetailRequest::getUserClientIp() const {
return userClientIp_;
}
void PushRpaTaskDetailRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string PushRpaTaskDetailRequest::getBid() const {
return bid_;
}
void PushRpaTaskDetailRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}
std::string PushRpaTaskDetailRequest::getOutputScreenshot() const {
return outputScreenshot_;
}
void PushRpaTaskDetailRequest::setOutputScreenshot(const std::string &outputScreenshot) {
outputScreenshot_ = outputScreenshot;
setParameter(std::string("OutputScreenshot"), outputScreenshot);
}
int PushRpaTaskDetailRequest::getStatus() const {
return status_;
}
void PushRpaTaskDetailRequest::setStatus(int status) {
status_ = status;
setParameter(std::string("Status"), std::to_string(status));
}

107
mseap/src/model/PushRpaTaskDetailResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/PushRpaTaskDetailResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
PushRpaTaskDetailResult::PushRpaTaskDetailResult() :
ServiceResult()
{}
PushRpaTaskDetailResult::PushRpaTaskDetailResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
PushRpaTaskDetailResult::~PushRpaTaskDetailResult()
{}
void PushRpaTaskDetailResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool PushRpaTaskDetailResult::getAllowRetry()const
{
return allowRetry_;
}
std::string PushRpaTaskDetailResult::getErrorMsg()const
{
return errorMsg_;
}
int PushRpaTaskDetailResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string PushRpaTaskDetailResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string PushRpaTaskDetailResult::getErrorCode()const
{
return errorCode_;
}
std::string PushRpaTaskDetailResult::getDynamicMessage()const
{
return dynamicMessage_;
}
std::string PushRpaTaskDetailResult::getModule()const
{
return module_;
}
bool PushRpaTaskDetailResult::getSuccess()const
{
return success_;
}
std::string PushRpaTaskDetailResult::getAppName()const
{
return appName_;
}

198
mseap/src/model/PushRpaTaskRequest.cc Normal file
View File

@@ -0,0 +1,198 @@
/*
* 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/mseap/model/PushRpaTaskRequest.h>
using AlibabaCloud::Mseap::Model::PushRpaTaskRequest;
PushRpaTaskRequest::PushRpaTaskRequest()
: RpcServiceRequest("mseap", "2021-01-18", "PushRpaTask") {
setMethod(HttpRequest::Method::Post);
}
PushRpaTaskRequest::~PushRpaTaskRequest() {}
std::string PushRpaTaskRequest::getRequest() const {
return request_;
}
void PushRpaTaskRequest::setRequest(const std::string &request) {
request_ = request;
setParameter(std::string("Request"), request);
}
long PushRpaTaskRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void PushRpaTaskRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string PushRpaTaskRequest::getApiType() const {
return apiType_;
}
void PushRpaTaskRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
bool PushRpaTaskRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void PushRpaTaskRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string PushRpaTaskRequest::getUserKp() const {
return userKp_;
}
void PushRpaTaskRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string PushRpaTaskRequest::getLang() const {
return lang_;
}
void PushRpaTaskRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
long PushRpaTaskRequest::getTaskId() const {
return taskId_;
}
void PushRpaTaskRequest::setTaskId(long taskId) {
taskId_ = taskId;
setParameter(std::string("TaskId"), std::to_string(taskId));
}
std::string PushRpaTaskRequest::getUserCallerType() const {
return userCallerType_;
}
void PushRpaTaskRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string PushRpaTaskRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void PushRpaTaskRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string PushRpaTaskRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void PushRpaTaskRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
long PushRpaTaskRequest::getModelId() const {
return modelId_;
}
void PushRpaTaskRequest::setModelId(long modelId) {
modelId_ = modelId;
setParameter(std::string("ModelId"), std::to_string(modelId));
}
std::string PushRpaTaskRequest::getAliyunKp() const {
return aliyunKp_;
}
void PushRpaTaskRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string PushRpaTaskRequest::getUserBid() const {
return userBid_;
}
void PushRpaTaskRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string PushRpaTaskRequest::getOriginalRequest() const {
return originalRequest_;
}
void PushRpaTaskRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
long PushRpaTaskRequest::getTemplateId() const {
return templateId_;
}
void PushRpaTaskRequest::setTemplateId(long templateId) {
templateId_ = templateId;
setParameter(std::string("TemplateId"), std::to_string(templateId));
}
std::string PushRpaTaskRequest::getUserClientIp() const {
return userClientIp_;
}
void PushRpaTaskRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string PushRpaTaskRequest::getName() const {
return name_;
}
void PushRpaTaskRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
std::string PushRpaTaskRequest::getBid() const {
return bid_;
}
void PushRpaTaskRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}
int PushRpaTaskRequest::getStatus() const {
return status_;
}
void PushRpaTaskRequest::setStatus(int status) {
status_ = status;
setParameter(std::string("Status"), std::to_string(status));
}

107
mseap/src/model/PushRpaTaskResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/PushRpaTaskResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
PushRpaTaskResult::PushRpaTaskResult() :
ServiceResult()
{}
PushRpaTaskResult::PushRpaTaskResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
PushRpaTaskResult::~PushRpaTaskResult()
{}
void PushRpaTaskResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool PushRpaTaskResult::getAllowRetry()const
{
return allowRetry_;
}
std::string PushRpaTaskResult::getErrorMsg()const
{
return errorMsg_;
}
int PushRpaTaskResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string PushRpaTaskResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string PushRpaTaskResult::getErrorCode()const
{
return errorCode_;
}
std::string PushRpaTaskResult::getDynamicMessage()const
{
return dynamicMessage_;
}
std::string PushRpaTaskResult::getModule()const
{
return module_;
}
bool PushRpaTaskResult::getSuccess()const
{
return success_;
}
std::string PushRpaTaskResult::getAppName()const
{
return appName_;
}

180
mseap/src/model/SetRedisValueRequest.cc Normal file
View File

@@ -0,0 +1,180 @@
/*
* 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/mseap/model/SetRedisValueRequest.h>
using AlibabaCloud::Mseap::Model::SetRedisValueRequest;
SetRedisValueRequest::SetRedisValueRequest()
: RpcServiceRequest("mseap", "2021-01-18", "SetRedisValue") {
setMethod(HttpRequest::Method::Post);
}
SetRedisValueRequest::~SetRedisValueRequest() {}
long SetRedisValueRequest::getUserCallerParentId() const {
return userCallerParentId_;
}
void SetRedisValueRequest::setUserCallerParentId(long userCallerParentId) {
userCallerParentId_ = userCallerParentId;
setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
}
std::string SetRedisValueRequest::getApiType() const {
return apiType_;
}
void SetRedisValueRequest::setApiType(const std::string &apiType) {
apiType_ = apiType;
setParameter(std::string("ApiType"), apiType);
}
long SetRedisValueRequest::getTimeout() const {
return timeout_;
}
void SetRedisValueRequest::setTimeout(long timeout) {
timeout_ = timeout;
setParameter(std::string("Timeout"), std::to_string(timeout));
}
bool SetRedisValueRequest::getUserMfaPresent() const {
return userMfaPresent_;
}
void SetRedisValueRequest::setUserMfaPresent(bool userMfaPresent) {
userMfaPresent_ = userMfaPresent;
setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
}
std::string SetRedisValueRequest::getUserKp() const {
return userKp_;
}
void SetRedisValueRequest::setUserKp(const std::string &userKp) {
userKp_ = userKp;
setParameter(std::string("UserKp"), userKp);
}
std::string SetRedisValueRequest::getLang() const {
return lang_;
}
void SetRedisValueRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string SetRedisValueRequest::getValue() const {
return value_;
}
void SetRedisValueRequest::setValue(const std::string &value) {
value_ = value;
setParameter(std::string("Value"), value);
}
std::string SetRedisValueRequest::getKey() const {
return key_;
}
void SetRedisValueRequest::setKey(const std::string &key) {
key_ = key;
setParameter(std::string("Key"), key);
}
std::string SetRedisValueRequest::getUserCallerType() const {
return userCallerType_;
}
void SetRedisValueRequest::setUserCallerType(const std::string &userCallerType) {
userCallerType_ = userCallerType;
setParameter(std::string("UserCallerType"), userCallerType);
}
std::string SetRedisValueRequest::getUserSecurityToken() const {
return userSecurityToken_;
}
void SetRedisValueRequest::setUserSecurityToken(const std::string &userSecurityToken) {
userSecurityToken_ = userSecurityToken;
setParameter(std::string("UserSecurityToken"), userSecurityToken);
}
std::string SetRedisValueRequest::getUserAccessKeyId() const {
return userAccessKeyId_;
}
void SetRedisValueRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
userAccessKeyId_ = userAccessKeyId;
setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
}
std::string SetRedisValueRequest::getAliyunKp() const {
return aliyunKp_;
}
void SetRedisValueRequest::setAliyunKp(const std::string &aliyunKp) {
aliyunKp_ = aliyunKp;
setParameter(std::string("AliyunKp"), aliyunKp);
}
std::string SetRedisValueRequest::getUserBid() const {
return userBid_;
}
void SetRedisValueRequest::setUserBid(const std::string &userBid) {
userBid_ = userBid;
setParameter(std::string("UserBid"), userBid);
}
std::string SetRedisValueRequest::getOriginalRequest() const {
return originalRequest_;
}
void SetRedisValueRequest::setOriginalRequest(const std::string &originalRequest) {
originalRequest_ = originalRequest;
setParameter(std::string("OriginalRequest"), originalRequest);
}
std::string SetRedisValueRequest::getRequestId() const {
return requestId_;
}
void SetRedisValueRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
std::string SetRedisValueRequest::getUserClientIp() const {
return userClientIp_;
}
void SetRedisValueRequest::setUserClientIp(const std::string &userClientIp) {
userClientIp_ = userClientIp;
setParameter(std::string("UserClientIp"), userClientIp);
}
std::string SetRedisValueRequest::getBid() const {
return bid_;
}
void SetRedisValueRequest::setBid(const std::string &bid) {
bid_ = bid;
setParameter(std::string("Bid"), bid);
}

107
mseap/src/model/SetRedisValueResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/mseap/model/SetRedisValueResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Mseap;
using namespace AlibabaCloud::Mseap::Model;
SetRedisValueResult::SetRedisValueResult() :
ServiceResult()
{}
SetRedisValueResult::SetRedisValueResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SetRedisValueResult::~SetRedisValueResult()
{}
void SetRedisValueResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["AllowRetry"].isNull())
allowRetry_ = value["AllowRetry"].asString() == "true";
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["DynamicCode"].isNull())
dynamicCode_ = value["DynamicCode"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["DynamicMessage"].isNull())
dynamicMessage_ = value["DynamicMessage"].asString();
if(!value["Module"].isNull())
module_ = value["Module"].asString() == "true";
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["AppName"].isNull())
appName_ = value["AppName"].asString();
}
bool SetRedisValueResult::getAllowRetry()const
{
return allowRetry_;
}
std::string SetRedisValueResult::getErrorMsg()const
{
return errorMsg_;
}
int SetRedisValueResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string SetRedisValueResult::getDynamicCode()const
{
return dynamicCode_;
}
std::string SetRedisValueResult::getErrorCode()const
{
return errorCode_;
}
std::string SetRedisValueResult::getDynamicMessage()const
{
return dynamicMessage_;
}
bool SetRedisValueResult::getModule()const
{
return module_;
}
bool SetRedisValueResult::getSuccess()const
{
return success_;
}
std::string SetRedisValueResult::getAppName()const
{
return appName_;
}

36
mseap/src/model/UpdateAgreementStatusRequest.cc Normal file
View File

@@ -0,0 +1,36 @@
/*
* 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/mseap/model/UpdateAgreementStatusRequest.h>
using AlibabaCloud::Mseap::Model::UpdateAgreementStatusRequest;
UpdateAgreementStatusRequest::UpdateAgreementStatusRequest()
: RpcServiceRequest("mseap", "2021-01-18", "UpdateAgreementStatus") {
setMethod(HttpRequest::Method::Post);
}
UpdateAgreementStatusRequest::~UpdateAgreementStatusRequest() {}
std::string UpdateAgreementStatusRequest::getAgreementCode() const {
return agreementCode_;
}
void UpdateAgreementStatusRequest::setAgreementCode(const std::string &agreementCode) {
agreementCode_ = agreementCode;
setParameter(std::string("AgreementCode"), agreementCode);
}

44
mseap/src/model/UpdateAgreementStatusResult.cc Normal file
View File

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