918 lines
32 KiB
C++
918 lines
32 KiB
C++
/*
|
|
* 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/cas/CasClient.h>
|
|
#include <alibabacloud/core/SimpleCredentialsProvider.h>
|
|
|
|
using namespace AlibabaCloud;
|
|
using namespace AlibabaCloud::Location;
|
|
using namespace AlibabaCloud::Cas;
|
|
using namespace AlibabaCloud::Cas::Model;
|
|
|
|
namespace
|
|
{
|
|
const std::string SERVICE_NAME = "cas";
|
|
}
|
|
|
|
CasClient::CasClient(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, "");
|
|
}
|
|
|
|
CasClient::CasClient(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, "");
|
|
}
|
|
|
|
CasClient::CasClient(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, "");
|
|
}
|
|
|
|
CasClient::~CasClient()
|
|
{}
|
|
|
|
CasClient::CancelCertificateForPackageRequestOutcome CasClient::cancelCertificateForPackageRequest(const CancelCertificateForPackageRequestRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CancelCertificateForPackageRequestOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CancelCertificateForPackageRequestOutcome(CancelCertificateForPackageRequestResult(outcome.result()));
|
|
else
|
|
return CancelCertificateForPackageRequestOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::cancelCertificateForPackageRequestAsync(const CancelCertificateForPackageRequestRequest& request, const CancelCertificateForPackageRequestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, cancelCertificateForPackageRequest(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CancelCertificateForPackageRequestOutcomeCallable CasClient::cancelCertificateForPackageRequestCallable(const CancelCertificateForPackageRequestRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CancelCertificateForPackageRequestOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->cancelCertificateForPackageRequest(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CancelOrderRequestOutcome CasClient::cancelOrderRequest(const CancelOrderRequestRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CancelOrderRequestOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CancelOrderRequestOutcome(CancelOrderRequestResult(outcome.result()));
|
|
else
|
|
return CancelOrderRequestOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::cancelOrderRequestAsync(const CancelOrderRequestRequest& request, const CancelOrderRequestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, cancelOrderRequest(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CancelOrderRequestOutcomeCallable CasClient::cancelOrderRequestCallable(const CancelOrderRequestRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CancelOrderRequestOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->cancelOrderRequest(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateCertificateForPackageRequestOutcome CasClient::createCertificateForPackageRequest(const CreateCertificateForPackageRequestRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateCertificateForPackageRequestOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateCertificateForPackageRequestOutcome(CreateCertificateForPackageRequestResult(outcome.result()));
|
|
else
|
|
return CreateCertificateForPackageRequestOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createCertificateForPackageRequestAsync(const CreateCertificateForPackageRequestRequest& request, const CreateCertificateForPackageRequestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createCertificateForPackageRequest(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateCertificateForPackageRequestOutcomeCallable CasClient::createCertificateForPackageRequestCallable(const CreateCertificateForPackageRequestRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateCertificateForPackageRequestOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createCertificateForPackageRequest(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateCertificateRequestOutcome CasClient::createCertificateRequest(const CreateCertificateRequestRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateCertificateRequestOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateCertificateRequestOutcome(CreateCertificateRequestResult(outcome.result()));
|
|
else
|
|
return CreateCertificateRequestOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createCertificateRequestAsync(const CreateCertificateRequestRequest& request, const CreateCertificateRequestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createCertificateRequest(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateCertificateRequestOutcomeCallable CasClient::createCertificateRequestCallable(const CreateCertificateRequestRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateCertificateRequestOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createCertificateRequest(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateCertificateWithCsrRequestOutcome CasClient::createCertificateWithCsrRequest(const CreateCertificateWithCsrRequestRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateCertificateWithCsrRequestOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateCertificateWithCsrRequestOutcome(CreateCertificateWithCsrRequestResult(outcome.result()));
|
|
else
|
|
return CreateCertificateWithCsrRequestOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createCertificateWithCsrRequestAsync(const CreateCertificateWithCsrRequestRequest& request, const CreateCertificateWithCsrRequestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createCertificateWithCsrRequest(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateCertificateWithCsrRequestOutcomeCallable CasClient::createCertificateWithCsrRequestCallable(const CreateCertificateWithCsrRequestRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateCertificateWithCsrRequestOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createCertificateWithCsrRequest(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateWHClientCertificateOutcome CasClient::createWHClientCertificate(const CreateWHClientCertificateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateWHClientCertificateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateWHClientCertificateOutcome(CreateWHClientCertificateResult(outcome.result()));
|
|
else
|
|
return CreateWHClientCertificateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createWHClientCertificateAsync(const CreateWHClientCertificateRequest& request, const CreateWHClientCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createWHClientCertificate(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateWHClientCertificateOutcomeCallable CasClient::createWHClientCertificateCallable(const CreateWHClientCertificateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateWHClientCertificateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createWHClientCertificate(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DecryptOutcome CasClient::decrypt(const DecryptRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DecryptOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DecryptOutcome(DecryptResult(outcome.result()));
|
|
else
|
|
return DecryptOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::decryptAsync(const DecryptRequest& request, const DecryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, decrypt(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DecryptOutcomeCallable CasClient::decryptCallable(const DecryptRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DecryptOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->decrypt(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DeleteCertificateRequestOutcome CasClient::deleteCertificateRequest(const DeleteCertificateRequestRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteCertificateRequestOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteCertificateRequestOutcome(DeleteCertificateRequestResult(outcome.result()));
|
|
else
|
|
return DeleteCertificateRequestOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::deleteCertificateRequestAsync(const DeleteCertificateRequestRequest& request, const DeleteCertificateRequestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteCertificateRequest(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DeleteCertificateRequestOutcomeCallable CasClient::deleteCertificateRequestCallable(const DeleteCertificateRequestRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteCertificateRequestOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteCertificateRequest(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DeletePCACertOutcome CasClient::deletePCACert(const DeletePCACertRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeletePCACertOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeletePCACertOutcome(DeletePCACertResult(outcome.result()));
|
|
else
|
|
return DeletePCACertOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::deletePCACertAsync(const DeletePCACertRequest& request, const DeletePCACertAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deletePCACert(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DeletePCACertOutcomeCallable CasClient::deletePCACertCallable(const DeletePCACertRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeletePCACertOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deletePCACert(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DeleteUserCertificateOutcome CasClient::deleteUserCertificate(const DeleteUserCertificateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteUserCertificateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteUserCertificateOutcome(DeleteUserCertificateResult(outcome.result()));
|
|
else
|
|
return DeleteUserCertificateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::deleteUserCertificateAsync(const DeleteUserCertificateRequest& request, const DeleteUserCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteUserCertificate(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DeleteUserCertificateOutcomeCallable CasClient::deleteUserCertificateCallable(const DeleteUserCertificateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteUserCertificateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteUserCertificate(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeCertificateStateOutcome CasClient::describeCertificateState(const DescribeCertificateStateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeCertificateStateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeCertificateStateOutcome(DescribeCertificateStateResult(outcome.result()));
|
|
else
|
|
return DescribeCertificateStateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeCertificateStateAsync(const DescribeCertificateStateRequest& request, const DescribeCertificateStateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeCertificateState(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeCertificateStateOutcomeCallable CasClient::describeCertificateStateCallable(const DescribeCertificateStateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeCertificateStateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeCertificateState(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribePackageStateOutcome CasClient::describePackageState(const DescribePackageStateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribePackageStateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribePackageStateOutcome(DescribePackageStateResult(outcome.result()));
|
|
else
|
|
return DescribePackageStateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describePackageStateAsync(const DescribePackageStateRequest& request, const DescribePackageStateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describePackageState(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribePackageStateOutcomeCallable CasClient::describePackageStateCallable(const DescribePackageStateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribePackageStateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describePackageState(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::EncryptOutcome CasClient::encrypt(const EncryptRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return EncryptOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return EncryptOutcome(EncryptResult(outcome.result()));
|
|
else
|
|
return EncryptOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::encryptAsync(const EncryptRequest& request, const EncryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, encrypt(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::EncryptOutcomeCallable CasClient::encryptCallable(const EncryptRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<EncryptOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->encrypt(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::GetCertWarehouseQuotaOutcome CasClient::getCertWarehouseQuota(const GetCertWarehouseQuotaRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetCertWarehouseQuotaOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetCertWarehouseQuotaOutcome(GetCertWarehouseQuotaResult(outcome.result()));
|
|
else
|
|
return GetCertWarehouseQuotaOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::getCertWarehouseQuotaAsync(const GetCertWarehouseQuotaRequest& request, const GetCertWarehouseQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getCertWarehouseQuota(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::GetCertWarehouseQuotaOutcomeCallable CasClient::getCertWarehouseQuotaCallable(const GetCertWarehouseQuotaRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetCertWarehouseQuotaOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getCertWarehouseQuota(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::GetUserCertificateDetailOutcome CasClient::getUserCertificateDetail(const GetUserCertificateDetailRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetUserCertificateDetailOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetUserCertificateDetailOutcome(GetUserCertificateDetailResult(outcome.result()));
|
|
else
|
|
return GetUserCertificateDetailOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::getUserCertificateDetailAsync(const GetUserCertificateDetailRequest& request, const GetUserCertificateDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getUserCertificateDetail(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::GetUserCertificateDetailOutcomeCallable CasClient::getUserCertificateDetailCallable(const GetUserCertificateDetailRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetUserCertificateDetailOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getUserCertificateDetail(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::ListCertOutcome CasClient::listCert(const ListCertRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListCertOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListCertOutcome(ListCertResult(outcome.result()));
|
|
else
|
|
return ListCertOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::listCertAsync(const ListCertRequest& request, const ListCertAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listCert(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::ListCertOutcomeCallable CasClient::listCertCallable(const ListCertRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListCertOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listCert(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::ListCertWarehouseOutcome CasClient::listCertWarehouse(const ListCertWarehouseRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListCertWarehouseOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListCertWarehouseOutcome(ListCertWarehouseResult(outcome.result()));
|
|
else
|
|
return ListCertWarehouseOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::listCertWarehouseAsync(const ListCertWarehouseRequest& request, const ListCertWarehouseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listCertWarehouse(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::ListCertWarehouseOutcomeCallable CasClient::listCertWarehouseCallable(const ListCertWarehouseRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListCertWarehouseOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listCertWarehouse(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::ListUserCertificateOrderOutcome CasClient::listUserCertificateOrder(const ListUserCertificateOrderRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListUserCertificateOrderOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListUserCertificateOrderOutcome(ListUserCertificateOrderResult(outcome.result()));
|
|
else
|
|
return ListUserCertificateOrderOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::listUserCertificateOrderAsync(const ListUserCertificateOrderRequest& request, const ListUserCertificateOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listUserCertificateOrder(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::ListUserCertificateOrderOutcomeCallable CasClient::listUserCertificateOrderCallable(const ListUserCertificateOrderRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListUserCertificateOrderOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listUserCertificateOrder(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::RenewCertificateOrderForPackageRequestOutcome CasClient::renewCertificateOrderForPackageRequest(const RenewCertificateOrderForPackageRequestRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RenewCertificateOrderForPackageRequestOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RenewCertificateOrderForPackageRequestOutcome(RenewCertificateOrderForPackageRequestResult(outcome.result()));
|
|
else
|
|
return RenewCertificateOrderForPackageRequestOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::renewCertificateOrderForPackageRequestAsync(const RenewCertificateOrderForPackageRequestRequest& request, const RenewCertificateOrderForPackageRequestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, renewCertificateOrderForPackageRequest(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::RenewCertificateOrderForPackageRequestOutcomeCallable CasClient::renewCertificateOrderForPackageRequestCallable(const RenewCertificateOrderForPackageRequestRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RenewCertificateOrderForPackageRequestOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->renewCertificateOrderForPackageRequest(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::RevokeWHClientCertificateOutcome CasClient::revokeWHClientCertificate(const RevokeWHClientCertificateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RevokeWHClientCertificateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RevokeWHClientCertificateOutcome(RevokeWHClientCertificateResult(outcome.result()));
|
|
else
|
|
return RevokeWHClientCertificateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::revokeWHClientCertificateAsync(const RevokeWHClientCertificateRequest& request, const RevokeWHClientCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, revokeWHClientCertificate(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::RevokeWHClientCertificateOutcomeCallable CasClient::revokeWHClientCertificateCallable(const RevokeWHClientCertificateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RevokeWHClientCertificateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->revokeWHClientCertificate(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::SignOutcome CasClient::sign(const SignRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SignOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SignOutcome(SignResult(outcome.result()));
|
|
else
|
|
return SignOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::signAsync(const SignRequest& request, const SignAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, sign(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::SignOutcomeCallable CasClient::signCallable(const SignRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SignOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->sign(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::UploadPCACertOutcome CasClient::uploadPCACert(const UploadPCACertRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UploadPCACertOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UploadPCACertOutcome(UploadPCACertResult(outcome.result()));
|
|
else
|
|
return UploadPCACertOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::uploadPCACertAsync(const UploadPCACertRequest& request, const UploadPCACertAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, uploadPCACert(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::UploadPCACertOutcomeCallable CasClient::uploadPCACertCallable(const UploadPCACertRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UploadPCACertOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->uploadPCACert(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::UploadUserCertificateOutcome CasClient::uploadUserCertificate(const UploadUserCertificateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UploadUserCertificateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UploadUserCertificateOutcome(UploadUserCertificateResult(outcome.result()));
|
|
else
|
|
return UploadUserCertificateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::uploadUserCertificateAsync(const UploadUserCertificateRequest& request, const UploadUserCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, uploadUserCertificate(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::UploadUserCertificateOutcomeCallable CasClient::uploadUserCertificateCallable(const UploadUserCertificateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UploadUserCertificateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->uploadUserCertificate(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::VerifyOutcome CasClient::verify(const VerifyRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return VerifyOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return VerifyOutcome(VerifyResult(outcome.result()));
|
|
else
|
|
return VerifyOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::verifyAsync(const VerifyRequest& request, const VerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, verify(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::VerifyOutcomeCallable CasClient::verifyCallable(const VerifyRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<VerifyOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->verify(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|