|
|
@@ -87,36 +87,36 @@ DomainClient::SaveSingleTaskForDomainNameProxyServiceOutcomeCallable DomainClien
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForModifyingDnsHostOutcome DomainClient::saveSingleTaskForModifyingDnsHost(const SaveSingleTaskForModifyingDnsHostRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForDisassociatingEnsOutcome DomainClient::saveSingleTaskForDisassociatingEns(const SaveSingleTaskForDisassociatingEnsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForModifyingDnsHostOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForDisassociatingEnsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForModifyingDnsHostOutcome(SaveSingleTaskForModifyingDnsHostResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForDisassociatingEnsOutcome(SaveSingleTaskForDisassociatingEnsResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForModifyingDnsHostOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForDisassociatingEnsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForModifyingDnsHostAsync(const SaveSingleTaskForModifyingDnsHostRequest& request, const SaveSingleTaskForModifyingDnsHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForDisassociatingEnsAsync(const SaveSingleTaskForDisassociatingEnsRequest& request, const SaveSingleTaskForDisassociatingEnsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForModifyingDnsHost(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForDisassociatingEns(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForModifyingDnsHostOutcomeCallable DomainClient::saveSingleTaskForModifyingDnsHostCallable(const SaveSingleTaskForModifyingDnsHostRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForDisassociatingEnsOutcomeCallable DomainClient::saveSingleTaskForDisassociatingEnsCallable(const SaveSingleTaskForDisassociatingEnsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForModifyingDnsHostOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForDisassociatingEnsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForModifyingDnsHost(request);
|
|
|
+ return this->saveSingleTaskForDisassociatingEns(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
@@ -159,42 +159,6 @@ DomainClient::SaveBatchTaskForUpdatingContactInfoByRegistrantProfileIdOutcomeCal
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryBookingDomainInfoOutcome DomainClient::queryBookingDomainInfo(const QueryBookingDomainInfoRequest &request) const
|
|
|
-{
|
|
|
- auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
- if (!endpointOutcome.isSuccess())
|
|
|
- return QueryBookingDomainInfoOutcome(endpointOutcome.error());
|
|
|
-
|
|
|
- auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
-
|
|
|
- if (outcome.isSuccess())
|
|
|
- return QueryBookingDomainInfoOutcome(QueryBookingDomainInfoResult(outcome.result()));
|
|
|
- else
|
|
|
- return QueryBookingDomainInfoOutcome(outcome.error());
|
|
|
-}
|
|
|
-
|
|
|
-void DomainClient::queryBookingDomainInfoAsync(const QueryBookingDomainInfoRequest& request, const QueryBookingDomainInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
-{
|
|
|
- auto fn = [this, request, handler, context]()
|
|
|
- {
|
|
|
- handler(this, request, queryBookingDomainInfo(request), context);
|
|
|
- };
|
|
|
-
|
|
|
- asyncExecute(new Runnable(fn));
|
|
|
-}
|
|
|
-
|
|
|
-DomainClient::QueryBookingDomainInfoOutcomeCallable DomainClient::queryBookingDomainInfoCallable(const QueryBookingDomainInfoRequest &request) const
|
|
|
-{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryBookingDomainInfoOutcome()>>(
|
|
|
- [this, request]()
|
|
|
- {
|
|
|
- return this->queryBookingDomainInfo(request);
|
|
|
- });
|
|
|
-
|
|
|
- asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
- return task->get_future();
|
|
|
-}
|
|
|
-
|
|
|
DomainClient::AcceptDemandOutcome DomainClient::acceptDemand(const AcceptDemandRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
@@ -267,2988 +231,3600 @@ DomainClient::SaveSingleTaskForSynchronizingDnsHostOutcomeCallable DomainClient:
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryAuctionsOutcome DomainClient::queryAuctions(const QueryAuctionsRequest &request) const
|
|
|
+DomainClient::SaveRegistrantProfileOutcome DomainClient::saveRegistrantProfile(const SaveRegistrantProfileRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryAuctionsOutcome(endpointOutcome.error());
|
|
|
+ return SaveRegistrantProfileOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryAuctionsOutcome(QueryAuctionsResult(outcome.result()));
|
|
|
+ return SaveRegistrantProfileOutcome(SaveRegistrantProfileResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryAuctionsOutcome(outcome.error());
|
|
|
+ return SaveRegistrantProfileOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryAuctionsAsync(const QueryAuctionsRequest& request, const QueryAuctionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveRegistrantProfileAsync(const SaveRegistrantProfileRequest& request, const SaveRegistrantProfileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryAuctions(request), context);
|
|
|
+ handler(this, request, saveRegistrantProfile(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryAuctionsOutcomeCallable DomainClient::queryAuctionsCallable(const QueryAuctionsRequest &request) const
|
|
|
+DomainClient::SaveRegistrantProfileOutcomeCallable DomainClient::saveRegistrantProfileCallable(const SaveRegistrantProfileRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryAuctionsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveRegistrantProfileOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryAuctions(request);
|
|
|
+ return this->saveRegistrantProfile(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForUpdatingContactInfoByNewContactOutcome DomainClient::saveBatchTaskForUpdatingContactInfoByNewContact(const SaveBatchTaskForUpdatingContactInfoByNewContactRequest &request) const
|
|
|
+DomainClient::CancelQualificationVerificationOutcome DomainClient::cancelQualificationVerification(const CancelQualificationVerificationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveBatchTaskForUpdatingContactInfoByNewContactOutcome(endpointOutcome.error());
|
|
|
+ return CancelQualificationVerificationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveBatchTaskForUpdatingContactInfoByNewContactOutcome(SaveBatchTaskForUpdatingContactInfoByNewContactResult(outcome.result()));
|
|
|
+ return CancelQualificationVerificationOutcome(CancelQualificationVerificationResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveBatchTaskForUpdatingContactInfoByNewContactOutcome(outcome.error());
|
|
|
+ return CancelQualificationVerificationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveBatchTaskForUpdatingContactInfoByNewContactAsync(const SaveBatchTaskForUpdatingContactInfoByNewContactRequest& request, const SaveBatchTaskForUpdatingContactInfoByNewContactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::cancelQualificationVerificationAsync(const CancelQualificationVerificationRequest& request, const CancelQualificationVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveBatchTaskForUpdatingContactInfoByNewContact(request), context);
|
|
|
+ handler(this, request, cancelQualificationVerification(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForUpdatingContactInfoByNewContactOutcomeCallable DomainClient::saveBatchTaskForUpdatingContactInfoByNewContactCallable(const SaveBatchTaskForUpdatingContactInfoByNewContactRequest &request) const
|
|
|
+DomainClient::CancelQualificationVerificationOutcomeCallable DomainClient::cancelQualificationVerificationCallable(const CancelQualificationVerificationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveBatchTaskForUpdatingContactInfoByNewContactOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CancelQualificationVerificationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveBatchTaskForUpdatingContactInfoByNewContact(request);
|
|
|
+ return this->cancelQualificationVerification(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveRegistrantProfileOutcome DomainClient::saveRegistrantProfile(const SaveRegistrantProfileRequest &request) const
|
|
|
+DomainClient::QueryDomainListOutcome DomainClient::queryDomainList(const QueryDomainListRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveRegistrantProfileOutcome(endpointOutcome.error());
|
|
|
+ return QueryDomainListOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveRegistrantProfileOutcome(SaveRegistrantProfileResult(outcome.result()));
|
|
|
+ return QueryDomainListOutcome(QueryDomainListResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveRegistrantProfileOutcome(outcome.error());
|
|
|
+ return QueryDomainListOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveRegistrantProfileAsync(const SaveRegistrantProfileRequest& request, const SaveRegistrantProfileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryDomainListAsync(const QueryDomainListRequest& request, const QueryDomainListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveRegistrantProfile(request), context);
|
|
|
+ handler(this, request, queryDomainList(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveRegistrantProfileOutcomeCallable DomainClient::saveRegistrantProfileCallable(const SaveRegistrantProfileRequest &request) const
|
|
|
+DomainClient::QueryDomainListOutcomeCallable DomainClient::queryDomainListCallable(const QueryDomainListRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveRegistrantProfileOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryDomainListOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveRegistrantProfile(request);
|
|
|
+ return this->queryDomainList(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDomainListOutcome DomainClient::queryDomainList(const QueryDomainListRequest &request) const
|
|
|
+DomainClient::QueryChangeLogListOutcome DomainClient::queryChangeLogList(const QueryChangeLogListRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryDomainListOutcome(endpointOutcome.error());
|
|
|
+ return QueryChangeLogListOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryDomainListOutcome(QueryDomainListResult(outcome.result()));
|
|
|
+ return QueryChangeLogListOutcome(QueryChangeLogListResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryDomainListOutcome(outcome.error());
|
|
|
+ return QueryChangeLogListOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryDomainListAsync(const QueryDomainListRequest& request, const QueryDomainListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryChangeLogListAsync(const QueryChangeLogListRequest& request, const QueryChangeLogListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryDomainList(request), context);
|
|
|
+ handler(this, request, queryChangeLogList(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDomainListOutcomeCallable DomainClient::queryDomainListCallable(const QueryDomainListRequest &request) const
|
|
|
+DomainClient::QueryChangeLogListOutcomeCallable DomainClient::queryChangeLogListCallable(const QueryChangeLogListRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryDomainListOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryChangeLogListOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryDomainList(request);
|
|
|
+ return this->queryChangeLogList(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::CheckDomainOutcome DomainClient::checkDomain(const CheckDomainRequest &request) const
|
|
|
+DomainClient::CheckTransferInFeasibilityOutcome DomainClient::checkTransferInFeasibility(const CheckTransferInFeasibilityRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return CheckDomainOutcome(endpointOutcome.error());
|
|
|
+ return CheckTransferInFeasibilityOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return CheckDomainOutcome(CheckDomainResult(outcome.result()));
|
|
|
+ return CheckTransferInFeasibilityOutcome(CheckTransferInFeasibilityResult(outcome.result()));
|
|
|
else
|
|
|
- return CheckDomainOutcome(outcome.error());
|
|
|
+ return CheckTransferInFeasibilityOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::checkDomainAsync(const CheckDomainRequest& request, const CheckDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::checkTransferInFeasibilityAsync(const CheckTransferInFeasibilityRequest& request, const CheckTransferInFeasibilityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, checkDomain(request), context);
|
|
|
+ handler(this, request, checkTransferInFeasibility(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::CheckDomainOutcomeCallable DomainClient::checkDomainCallable(const CheckDomainRequest &request) const
|
|
|
+DomainClient::CheckTransferInFeasibilityOutcomeCallable DomainClient::checkTransferInFeasibilityCallable(const CheckTransferInFeasibilityRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<CheckDomainOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CheckTransferInFeasibilityOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->checkDomain(request);
|
|
|
+ return this->checkTransferInFeasibility(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryChangeLogListOutcome DomainClient::queryChangeLogList(const QueryChangeLogListRequest &request) const
|
|
|
+DomainClient::QueryFailReasonForDomainRealNameVerificationOutcome DomainClient::queryFailReasonForDomainRealNameVerification(const QueryFailReasonForDomainRealNameVerificationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryChangeLogListOutcome(endpointOutcome.error());
|
|
|
+ return QueryFailReasonForDomainRealNameVerificationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryChangeLogListOutcome(QueryChangeLogListResult(outcome.result()));
|
|
|
+ return QueryFailReasonForDomainRealNameVerificationOutcome(QueryFailReasonForDomainRealNameVerificationResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryChangeLogListOutcome(outcome.error());
|
|
|
+ return QueryFailReasonForDomainRealNameVerificationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryChangeLogListAsync(const QueryChangeLogListRequest& request, const QueryChangeLogListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryFailReasonForDomainRealNameVerificationAsync(const QueryFailReasonForDomainRealNameVerificationRequest& request, const QueryFailReasonForDomainRealNameVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryChangeLogList(request), context);
|
|
|
+ handler(this, request, queryFailReasonForDomainRealNameVerification(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryChangeLogListOutcomeCallable DomainClient::queryChangeLogListCallable(const QueryChangeLogListRequest &request) const
|
|
|
+DomainClient::QueryFailReasonForDomainRealNameVerificationOutcomeCallable DomainClient::queryFailReasonForDomainRealNameVerificationCallable(const QueryFailReasonForDomainRealNameVerificationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryChangeLogListOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryFailReasonForDomainRealNameVerificationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryChangeLogList(request);
|
|
|
+ return this->queryFailReasonForDomainRealNameVerification(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::TransferInCheckMailTokenOutcome DomainClient::transferInCheckMailToken(const TransferInCheckMailTokenRequest &request) const
|
|
|
+DomainClient::RequestPayDemandOutcome DomainClient::requestPayDemand(const RequestPayDemandRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return TransferInCheckMailTokenOutcome(endpointOutcome.error());
|
|
|
+ return RequestPayDemandOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return TransferInCheckMailTokenOutcome(TransferInCheckMailTokenResult(outcome.result()));
|
|
|
+ return RequestPayDemandOutcome(RequestPayDemandResult(outcome.result()));
|
|
|
else
|
|
|
- return TransferInCheckMailTokenOutcome(outcome.error());
|
|
|
+ return RequestPayDemandOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::transferInCheckMailTokenAsync(const TransferInCheckMailTokenRequest& request, const TransferInCheckMailTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::requestPayDemandAsync(const RequestPayDemandRequest& request, const RequestPayDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, transferInCheckMailToken(request), context);
|
|
|
+ handler(this, request, requestPayDemand(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::TransferInCheckMailTokenOutcomeCallable DomainClient::transferInCheckMailTokenCallable(const TransferInCheckMailTokenRequest &request) const
|
|
|
+DomainClient::RequestPayDemandOutcomeCallable DomainClient::requestPayDemandCallable(const RequestPayDemandRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<TransferInCheckMailTokenOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<RequestPayDemandOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->transferInCheckMailToken(request);
|
|
|
+ return this->requestPayDemand(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::CheckTransferInFeasibilityOutcome DomainClient::checkTransferInFeasibility(const CheckTransferInFeasibilityRequest &request) const
|
|
|
+DomainClient::ResetQualificationVerificationOutcome DomainClient::resetQualificationVerification(const ResetQualificationVerificationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return CheckTransferInFeasibilityOutcome(endpointOutcome.error());
|
|
|
+ return ResetQualificationVerificationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return CheckTransferInFeasibilityOutcome(CheckTransferInFeasibilityResult(outcome.result()));
|
|
|
+ return ResetQualificationVerificationOutcome(ResetQualificationVerificationResult(outcome.result()));
|
|
|
else
|
|
|
- return CheckTransferInFeasibilityOutcome(outcome.error());
|
|
|
+ return ResetQualificationVerificationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::checkTransferInFeasibilityAsync(const CheckTransferInFeasibilityRequest& request, const CheckTransferInFeasibilityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::resetQualificationVerificationAsync(const ResetQualificationVerificationRequest& request, const ResetQualificationVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, checkTransferInFeasibility(request), context);
|
|
|
+ handler(this, request, resetQualificationVerification(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::CheckTransferInFeasibilityOutcomeCallable DomainClient::checkTransferInFeasibilityCallable(const CheckTransferInFeasibilityRequest &request) const
|
|
|
+DomainClient::ResetQualificationVerificationOutcomeCallable DomainClient::resetQualificationVerificationCallable(const ResetQualificationVerificationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<CheckTransferInFeasibilityOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ResetQualificationVerificationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->checkTransferInFeasibility(request);
|
|
|
+ return this->resetQualificationVerification(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryFailReasonForDomainRealNameVerificationOutcome DomainClient::queryFailReasonForDomainRealNameVerification(const QueryFailReasonForDomainRealNameVerificationRequest &request) const
|
|
|
+DomainClient::VerifyContactFieldOutcome DomainClient::verifyContactField(const VerifyContactFieldRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryFailReasonForDomainRealNameVerificationOutcome(endpointOutcome.error());
|
|
|
+ return VerifyContactFieldOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryFailReasonForDomainRealNameVerificationOutcome(QueryFailReasonForDomainRealNameVerificationResult(outcome.result()));
|
|
|
+ return VerifyContactFieldOutcome(VerifyContactFieldResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryFailReasonForDomainRealNameVerificationOutcome(outcome.error());
|
|
|
+ return VerifyContactFieldOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryFailReasonForDomainRealNameVerificationAsync(const QueryFailReasonForDomainRealNameVerificationRequest& request, const QueryFailReasonForDomainRealNameVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::verifyContactFieldAsync(const VerifyContactFieldRequest& request, const VerifyContactFieldAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryFailReasonForDomainRealNameVerification(request), context);
|
|
|
+ handler(this, request, verifyContactField(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryFailReasonForDomainRealNameVerificationOutcomeCallable DomainClient::queryFailReasonForDomainRealNameVerificationCallable(const QueryFailReasonForDomainRealNameVerificationRequest &request) const
|
|
|
+DomainClient::VerifyContactFieldOutcomeCallable DomainClient::verifyContactFieldCallable(const VerifyContactFieldRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryFailReasonForDomainRealNameVerificationOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<VerifyContactFieldOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryFailReasonForDomainRealNameVerification(request);
|
|
|
+ return this->verifyContactField(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryAdvancedDomainListOutcome DomainClient::queryAdvancedDomainList(const QueryAdvancedDomainListRequest &request) const
|
|
|
+DomainClient::RegistrantProfileRealNameVerificationOutcome DomainClient::registrantProfileRealNameVerification(const RegistrantProfileRealNameVerificationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryAdvancedDomainListOutcome(endpointOutcome.error());
|
|
|
+ return RegistrantProfileRealNameVerificationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryAdvancedDomainListOutcome(QueryAdvancedDomainListResult(outcome.result()));
|
|
|
+ return RegistrantProfileRealNameVerificationOutcome(RegistrantProfileRealNameVerificationResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryAdvancedDomainListOutcome(outcome.error());
|
|
|
+ return RegistrantProfileRealNameVerificationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryAdvancedDomainListAsync(const QueryAdvancedDomainListRequest& request, const QueryAdvancedDomainListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::registrantProfileRealNameVerificationAsync(const RegistrantProfileRealNameVerificationRequest& request, const RegistrantProfileRealNameVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryAdvancedDomainList(request), context);
|
|
|
+ handler(this, request, registrantProfileRealNameVerification(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryAdvancedDomainListOutcomeCallable DomainClient::queryAdvancedDomainListCallable(const QueryAdvancedDomainListRequest &request) const
|
|
|
+DomainClient::RegistrantProfileRealNameVerificationOutcomeCallable DomainClient::registrantProfileRealNameVerificationCallable(const RegistrantProfileRealNameVerificationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryAdvancedDomainListOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<RegistrantProfileRealNameVerificationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryAdvancedDomainList(request);
|
|
|
+ return this->registrantProfileRealNameVerification(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::RequestPayDemandOutcome DomainClient::requestPayDemand(const RequestPayDemandRequest &request) const
|
|
|
+DomainClient::QueryBidRecordsOutcome DomainClient::queryBidRecords(const QueryBidRecordsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return RequestPayDemandOutcome(endpointOutcome.error());
|
|
|
+ return QueryBidRecordsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return RequestPayDemandOutcome(RequestPayDemandResult(outcome.result()));
|
|
|
+ return QueryBidRecordsOutcome(QueryBidRecordsResult(outcome.result()));
|
|
|
else
|
|
|
- return RequestPayDemandOutcome(outcome.error());
|
|
|
+ return QueryBidRecordsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::requestPayDemandAsync(const RequestPayDemandRequest& request, const RequestPayDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryBidRecordsAsync(const QueryBidRecordsRequest& request, const QueryBidRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, requestPayDemand(request), context);
|
|
|
+ handler(this, request, queryBidRecords(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::RequestPayDemandOutcomeCallable DomainClient::requestPayDemandCallable(const RequestPayDemandRequest &request) const
|
|
|
+DomainClient::QueryBidRecordsOutcomeCallable DomainClient::queryBidRecordsCallable(const QueryBidRecordsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<RequestPayDemandOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryBidRecordsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->requestPayDemand(request);
|
|
|
+ return this->queryBidRecords(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTransferOutInfoOutcome DomainClient::queryTransferOutInfo(const QueryTransferOutInfoRequest &request) const
|
|
|
+DomainClient::RecordDemandOutcome DomainClient::recordDemand(const RecordDemandRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryTransferOutInfoOutcome(endpointOutcome.error());
|
|
|
+ return RecordDemandOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryTransferOutInfoOutcome(QueryTransferOutInfoResult(outcome.result()));
|
|
|
+ return RecordDemandOutcome(RecordDemandResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryTransferOutInfoOutcome(outcome.error());
|
|
|
+ return RecordDemandOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryTransferOutInfoAsync(const QueryTransferOutInfoRequest& request, const QueryTransferOutInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::recordDemandAsync(const RecordDemandRequest& request, const RecordDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryTransferOutInfo(request), context);
|
|
|
+ handler(this, request, recordDemand(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTransferOutInfoOutcomeCallable DomainClient::queryTransferOutInfoCallable(const QueryTransferOutInfoRequest &request) const
|
|
|
+DomainClient::RecordDemandOutcomeCallable DomainClient::recordDemandCallable(const RecordDemandRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryTransferOutInfoOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<RecordDemandOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryTransferOutInfo(request);
|
|
|
+ return this->recordDemand(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcome DomainClient::saveTaskForUpdatingRegistrantInfoByRegistrantProfileID(const SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDRequest &request) const
|
|
|
+DomainClient::UpdateDomainToDomainGroupOutcome DomainClient::updateDomainToDomainGroup(const UpdateDomainToDomainGroupRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcome(endpointOutcome.error());
|
|
|
+ return UpdateDomainToDomainGroupOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcome(SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDResult(outcome.result()));
|
|
|
+ return UpdateDomainToDomainGroupOutcome(UpdateDomainToDomainGroupResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcome(outcome.error());
|
|
|
+ return UpdateDomainToDomainGroupOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveTaskForUpdatingRegistrantInfoByRegistrantProfileIDAsync(const SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDRequest& request, const SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::updateDomainToDomainGroupAsync(const UpdateDomainToDomainGroupRequest& request, const UpdateDomainToDomainGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveTaskForUpdatingRegistrantInfoByRegistrantProfileID(request), context);
|
|
|
+ handler(this, request, updateDomainToDomainGroup(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcomeCallable DomainClient::saveTaskForUpdatingRegistrantInfoByRegistrantProfileIDCallable(const SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDRequest &request) const
|
|
|
+DomainClient::UpdateDomainToDomainGroupOutcomeCallable DomainClient::updateDomainToDomainGroupCallable(const UpdateDomainToDomainGroupRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<UpdateDomainToDomainGroupOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveTaskForUpdatingRegistrantInfoByRegistrantProfileID(request);
|
|
|
+ return this->updateDomainToDomainGroup(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCreatingOrderRedeemOutcome DomainClient::saveSingleTaskForCreatingOrderRedeem(const SaveSingleTaskForCreatingOrderRedeemRequest &request) const
|
|
|
+DomainClient::QueryContactInfoOutcome DomainClient::queryContactInfo(const QueryContactInfoRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForCreatingOrderRedeemOutcome(endpointOutcome.error());
|
|
|
+ return QueryContactInfoOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForCreatingOrderRedeemOutcome(SaveSingleTaskForCreatingOrderRedeemResult(outcome.result()));
|
|
|
+ return QueryContactInfoOutcome(QueryContactInfoResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForCreatingOrderRedeemOutcome(outcome.error());
|
|
|
+ return QueryContactInfoOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForCreatingOrderRedeemAsync(const SaveSingleTaskForCreatingOrderRedeemRequest& request, const SaveSingleTaskForCreatingOrderRedeemAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryContactInfoAsync(const QueryContactInfoRequest& request, const QueryContactInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForCreatingOrderRedeem(request), context);
|
|
|
+ handler(this, request, queryContactInfo(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCreatingOrderRedeemOutcomeCallable DomainClient::saveSingleTaskForCreatingOrderRedeemCallable(const SaveSingleTaskForCreatingOrderRedeemRequest &request) const
|
|
|
+DomainClient::QueryContactInfoOutcomeCallable DomainClient::queryContactInfoCallable(const QueryContactInfoRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCreatingOrderRedeemOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryContactInfoOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForCreatingOrderRedeem(request);
|
|
|
+ return this->queryContactInfo(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryBrokerDemandOutcome DomainClient::queryBrokerDemand(const QueryBrokerDemandRequest &request) const
|
|
|
+DomainClient::QueryDomainSuffixOutcome DomainClient::queryDomainSuffix(const QueryDomainSuffixRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryBrokerDemandOutcome(endpointOutcome.error());
|
|
|
+ return QueryDomainSuffixOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryBrokerDemandOutcome(QueryBrokerDemandResult(outcome.result()));
|
|
|
+ return QueryDomainSuffixOutcome(QueryDomainSuffixResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryBrokerDemandOutcome(outcome.error());
|
|
|
+ return QueryDomainSuffixOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryBrokerDemandAsync(const QueryBrokerDemandRequest& request, const QueryBrokerDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryDomainSuffixAsync(const QueryDomainSuffixRequest& request, const QueryDomainSuffixAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryBrokerDemand(request), context);
|
|
|
+ handler(this, request, queryDomainSuffix(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryBrokerDemandOutcomeCallable DomainClient::queryBrokerDemandCallable(const QueryBrokerDemandRequest &request) const
|
|
|
+DomainClient::QueryDomainSuffixOutcomeCallable DomainClient::queryDomainSuffixCallable(const QueryDomainSuffixRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryBrokerDemandOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryDomainSuffixOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryBrokerDemand(request);
|
|
|
+ return this->queryDomainSuffix(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTaskDetailListOutcome DomainClient::queryTaskDetailList(const QueryTaskDetailListRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForQueryingTransferAuthorizationCodeOutcome DomainClient::saveSingleTaskForQueryingTransferAuthorizationCode(const SaveSingleTaskForQueryingTransferAuthorizationCodeRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryTaskDetailListOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForQueryingTransferAuthorizationCodeOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryTaskDetailListOutcome(QueryTaskDetailListResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForQueryingTransferAuthorizationCodeOutcome(SaveSingleTaskForQueryingTransferAuthorizationCodeResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryTaskDetailListOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForQueryingTransferAuthorizationCodeOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryTaskDetailListAsync(const QueryTaskDetailListRequest& request, const QueryTaskDetailListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForQueryingTransferAuthorizationCodeAsync(const SaveSingleTaskForQueryingTransferAuthorizationCodeRequest& request, const SaveSingleTaskForQueryingTransferAuthorizationCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryTaskDetailList(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForQueryingTransferAuthorizationCode(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTaskDetailListOutcomeCallable DomainClient::queryTaskDetailListCallable(const QueryTaskDetailListRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForQueryingTransferAuthorizationCodeOutcomeCallable DomainClient::saveSingleTaskForQueryingTransferAuthorizationCodeCallable(const SaveSingleTaskForQueryingTransferAuthorizationCodeRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryTaskDetailListOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForQueryingTransferAuthorizationCodeOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryTaskDetailList(request);
|
|
|
+ return this->saveSingleTaskForQueryingTransferAuthorizationCode(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchDomainRemarkOutcome DomainClient::saveBatchDomainRemark(const SaveBatchDomainRemarkRequest &request) const
|
|
|
+DomainClient::GetReserveDomainUrlOutcome DomainClient::getReserveDomainUrl(const GetReserveDomainUrlRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveBatchDomainRemarkOutcome(endpointOutcome.error());
|
|
|
+ return GetReserveDomainUrlOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveBatchDomainRemarkOutcome(SaveBatchDomainRemarkResult(outcome.result()));
|
|
|
+ return GetReserveDomainUrlOutcome(GetReserveDomainUrlResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveBatchDomainRemarkOutcome(outcome.error());
|
|
|
+ return GetReserveDomainUrlOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveBatchDomainRemarkAsync(const SaveBatchDomainRemarkRequest& request, const SaveBatchDomainRemarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::getReserveDomainUrlAsync(const GetReserveDomainUrlRequest& request, const GetReserveDomainUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveBatchDomainRemark(request), context);
|
|
|
+ handler(this, request, getReserveDomainUrl(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchDomainRemarkOutcomeCallable DomainClient::saveBatchDomainRemarkCallable(const SaveBatchDomainRemarkRequest &request) const
|
|
|
+DomainClient::GetReserveDomainUrlOutcomeCallable DomainClient::getReserveDomainUrlCallable(const GetReserveDomainUrlRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveBatchDomainRemarkOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<GetReserveDomainUrlOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveBatchDomainRemark(request);
|
|
|
+ return this->getReserveDomainUrl(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::VerifyContactFieldOutcome DomainClient::verifyContactField(const VerifyContactFieldRequest &request) const
|
|
|
+DomainClient::QueryLocalEnsAssociationOutcome DomainClient::queryLocalEnsAssociation(const QueryLocalEnsAssociationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return VerifyContactFieldOutcome(endpointOutcome.error());
|
|
|
+ return QueryLocalEnsAssociationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return VerifyContactFieldOutcome(VerifyContactFieldResult(outcome.result()));
|
|
|
+ return QueryLocalEnsAssociationOutcome(QueryLocalEnsAssociationResult(outcome.result()));
|
|
|
else
|
|
|
- return VerifyContactFieldOutcome(outcome.error());
|
|
|
+ return QueryLocalEnsAssociationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::verifyContactFieldAsync(const VerifyContactFieldRequest& request, const VerifyContactFieldAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryLocalEnsAssociationAsync(const QueryLocalEnsAssociationRequest& request, const QueryLocalEnsAssociationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, verifyContactField(request), context);
|
|
|
+ handler(this, request, queryLocalEnsAssociation(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::VerifyContactFieldOutcomeCallable DomainClient::verifyContactFieldCallable(const VerifyContactFieldRequest &request) const
|
|
|
+DomainClient::QueryLocalEnsAssociationOutcomeCallable DomainClient::queryLocalEnsAssociationCallable(const QueryLocalEnsAssociationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<VerifyContactFieldOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryLocalEnsAssociationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->verifyContactField(request);
|
|
|
+ return this->queryLocalEnsAssociation(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::FinishDemandOutcome DomainClient::finishDemand(const FinishDemandRequest &request) const
|
|
|
+DomainClient::SubmitEmailVerificationOutcome DomainClient::submitEmailVerification(const SubmitEmailVerificationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return FinishDemandOutcome(endpointOutcome.error());
|
|
|
+ return SubmitEmailVerificationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return FinishDemandOutcome(FinishDemandResult(outcome.result()));
|
|
|
+ return SubmitEmailVerificationOutcome(SubmitEmailVerificationResult(outcome.result()));
|
|
|
else
|
|
|
- return FinishDemandOutcome(outcome.error());
|
|
|
+ return SubmitEmailVerificationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::finishDemandAsync(const FinishDemandRequest& request, const FinishDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::submitEmailVerificationAsync(const SubmitEmailVerificationRequest& request, const SubmitEmailVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, finishDemand(request), context);
|
|
|
+ handler(this, request, submitEmailVerification(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::FinishDemandOutcomeCallable DomainClient::finishDemandCallable(const FinishDemandRequest &request) const
|
|
|
+DomainClient::SubmitEmailVerificationOutcomeCallable DomainClient::submitEmailVerificationCallable(const SubmitEmailVerificationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<FinishDemandOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SubmitEmailVerificationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->finishDemand(request);
|
|
|
+ return this->submitEmailVerification(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::RegistrantProfileRealNameVerificationOutcome DomainClient::registrantProfileRealNameVerification(const RegistrantProfileRealNameVerificationRequest &request) const
|
|
|
+DomainClient::ResendEmailVerificationOutcome DomainClient::resendEmailVerification(const ResendEmailVerificationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return RegistrantProfileRealNameVerificationOutcome(endpointOutcome.error());
|
|
|
+ return ResendEmailVerificationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return RegistrantProfileRealNameVerificationOutcome(RegistrantProfileRealNameVerificationResult(outcome.result()));
|
|
|
+ return ResendEmailVerificationOutcome(ResendEmailVerificationResult(outcome.result()));
|
|
|
else
|
|
|
- return RegistrantProfileRealNameVerificationOutcome(outcome.error());
|
|
|
+ return ResendEmailVerificationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::registrantProfileRealNameVerificationAsync(const RegistrantProfileRealNameVerificationRequest& request, const RegistrantProfileRealNameVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::resendEmailVerificationAsync(const ResendEmailVerificationRequest& request, const ResendEmailVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, registrantProfileRealNameVerification(request), context);
|
|
|
+ handler(this, request, resendEmailVerification(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::RegistrantProfileRealNameVerificationOutcomeCallable DomainClient::registrantProfileRealNameVerificationCallable(const RegistrantProfileRealNameVerificationRequest &request) const
|
|
|
+DomainClient::ResendEmailVerificationOutcomeCallable DomainClient::resendEmailVerificationCallable(const ResendEmailVerificationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<RegistrantProfileRealNameVerificationOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ResendEmailVerificationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->registrantProfileRealNameVerification(request);
|
|
|
+ return this->resendEmailVerification(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryBidRecordsOutcome DomainClient::queryBidRecords(const QueryBidRecordsRequest &request) const
|
|
|
+DomainClient::BidDomainOutcome DomainClient::bidDomain(const BidDomainRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryBidRecordsOutcome(endpointOutcome.error());
|
|
|
+ return BidDomainOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryBidRecordsOutcome(QueryBidRecordsResult(outcome.result()));
|
|
|
+ return BidDomainOutcome(BidDomainResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryBidRecordsOutcome(outcome.error());
|
|
|
+ return BidDomainOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryBidRecordsAsync(const QueryBidRecordsRequest& request, const QueryBidRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::bidDomainAsync(const BidDomainRequest& request, const BidDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryBidRecords(request), context);
|
|
|
+ handler(this, request, bidDomain(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryBidRecordsOutcomeCallable DomainClient::queryBidRecordsCallable(const QueryBidRecordsRequest &request) const
|
|
|
+DomainClient::BidDomainOutcomeCallable DomainClient::bidDomainCallable(const BidDomainRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryBidRecordsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<BidDomainOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryBidRecords(request);
|
|
|
+ return this->bidDomain(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::RecordDemandOutcome DomainClient::recordDemand(const RecordDemandRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCancelingTransferOutOutcome DomainClient::saveSingleTaskForCancelingTransferOut(const SaveSingleTaskForCancelingTransferOutRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return RecordDemandOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForCancelingTransferOutOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return RecordDemandOutcome(RecordDemandResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForCancelingTransferOutOutcome(SaveSingleTaskForCancelingTransferOutResult(outcome.result()));
|
|
|
else
|
|
|
- return RecordDemandOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForCancelingTransferOutOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::recordDemandAsync(const RecordDemandRequest& request, const RecordDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForCancelingTransferOutAsync(const SaveSingleTaskForCancelingTransferOutRequest& request, const SaveSingleTaskForCancelingTransferOutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, recordDemand(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForCancelingTransferOut(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::RecordDemandOutcomeCallable DomainClient::recordDemandCallable(const RecordDemandRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCancelingTransferOutOutcomeCallable DomainClient::saveSingleTaskForCancelingTransferOutCallable(const SaveSingleTaskForCancelingTransferOutRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<RecordDemandOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCancelingTransferOutOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->recordDemand(request);
|
|
|
+ return this->saveSingleTaskForCancelingTransferOut(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForCreatingOrderActivateOutcome DomainClient::saveBatchTaskForCreatingOrderActivate(const SaveBatchTaskForCreatingOrderActivateRequest &request) const
|
|
|
+DomainClient::CheckMaxYearOfServerLockOutcome DomainClient::checkMaxYearOfServerLock(const CheckMaxYearOfServerLockRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveBatchTaskForCreatingOrderActivateOutcome(endpointOutcome.error());
|
|
|
+ return CheckMaxYearOfServerLockOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveBatchTaskForCreatingOrderActivateOutcome(SaveBatchTaskForCreatingOrderActivateResult(outcome.result()));
|
|
|
+ return CheckMaxYearOfServerLockOutcome(CheckMaxYearOfServerLockResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveBatchTaskForCreatingOrderActivateOutcome(outcome.error());
|
|
|
+ return CheckMaxYearOfServerLockOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveBatchTaskForCreatingOrderActivateAsync(const SaveBatchTaskForCreatingOrderActivateRequest& request, const SaveBatchTaskForCreatingOrderActivateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::checkMaxYearOfServerLockAsync(const CheckMaxYearOfServerLockRequest& request, const CheckMaxYearOfServerLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveBatchTaskForCreatingOrderActivate(request), context);
|
|
|
+ handler(this, request, checkMaxYearOfServerLock(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForCreatingOrderActivateOutcomeCallable DomainClient::saveBatchTaskForCreatingOrderActivateCallable(const SaveBatchTaskForCreatingOrderActivateRequest &request) const
|
|
|
+DomainClient::CheckMaxYearOfServerLockOutcomeCallable DomainClient::checkMaxYearOfServerLockCallable(const CheckMaxYearOfServerLockRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveBatchTaskForCreatingOrderActivateOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CheckMaxYearOfServerLockOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveBatchTaskForCreatingOrderActivate(request);
|
|
|
+ return this->checkMaxYearOfServerLock(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForTransferProhibitionLockOutcome DomainClient::saveSingleTaskForTransferProhibitionLock(const SaveSingleTaskForTransferProhibitionLockRequest &request) const
|
|
|
+DomainClient::AcknowledgeTaskResultOutcome DomainClient::acknowledgeTaskResult(const AcknowledgeTaskResultRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForTransferProhibitionLockOutcome(endpointOutcome.error());
|
|
|
+ return AcknowledgeTaskResultOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForTransferProhibitionLockOutcome(SaveSingleTaskForTransferProhibitionLockResult(outcome.result()));
|
|
|
+ return AcknowledgeTaskResultOutcome(AcknowledgeTaskResultResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForTransferProhibitionLockOutcome(outcome.error());
|
|
|
+ return AcknowledgeTaskResultOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForTransferProhibitionLockAsync(const SaveSingleTaskForTransferProhibitionLockRequest& request, const SaveSingleTaskForTransferProhibitionLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::acknowledgeTaskResultAsync(const AcknowledgeTaskResultRequest& request, const AcknowledgeTaskResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForTransferProhibitionLock(request), context);
|
|
|
+ handler(this, request, acknowledgeTaskResult(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForTransferProhibitionLockOutcomeCallable DomainClient::saveSingleTaskForTransferProhibitionLockCallable(const SaveSingleTaskForTransferProhibitionLockRequest &request) const
|
|
|
+DomainClient::AcknowledgeTaskResultOutcomeCallable DomainClient::acknowledgeTaskResultCallable(const AcknowledgeTaskResultRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForTransferProhibitionLockOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<AcknowledgeTaskResultOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForTransferProhibitionLock(request);
|
|
|
+ return this->acknowledgeTaskResult(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveTaskForSubmittingDomainDeleteOutcome DomainClient::saveTaskForSubmittingDomainDelete(const SaveTaskForSubmittingDomainDeleteRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForUpdatingContactInfoOutcome DomainClient::saveSingleTaskForUpdatingContactInfo(const SaveSingleTaskForUpdatingContactInfoRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveTaskForSubmittingDomainDeleteOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForUpdatingContactInfoOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveTaskForSubmittingDomainDeleteOutcome(SaveTaskForSubmittingDomainDeleteResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForUpdatingContactInfoOutcome(SaveSingleTaskForUpdatingContactInfoResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveTaskForSubmittingDomainDeleteOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForUpdatingContactInfoOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveTaskForSubmittingDomainDeleteAsync(const SaveTaskForSubmittingDomainDeleteRequest& request, const SaveTaskForSubmittingDomainDeleteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForUpdatingContactInfoAsync(const SaveSingleTaskForUpdatingContactInfoRequest& request, const SaveSingleTaskForUpdatingContactInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveTaskForSubmittingDomainDelete(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForUpdatingContactInfo(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveTaskForSubmittingDomainDeleteOutcomeCallable DomainClient::saveTaskForSubmittingDomainDeleteCallable(const SaveTaskForSubmittingDomainDeleteRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForUpdatingContactInfoOutcomeCallable DomainClient::saveSingleTaskForUpdatingContactInfoCallable(const SaveSingleTaskForUpdatingContactInfoRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveTaskForSubmittingDomainDeleteOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForUpdatingContactInfoOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveTaskForSubmittingDomainDelete(request);
|
|
|
+ return this->saveSingleTaskForUpdatingContactInfo(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTransferInListOutcome DomainClient::queryTransferInList(const QueryTransferInListRequest &request) const
|
|
|
+DomainClient::SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcome DomainClient::saveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileID(const SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryTransferInListOutcome(endpointOutcome.error());
|
|
|
+ return SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryTransferInListOutcome(QueryTransferInListResult(outcome.result()));
|
|
|
+ return SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcome(SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryTransferInListOutcome(outcome.error());
|
|
|
+ return SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryTransferInListAsync(const QueryTransferInListRequest& request, const QueryTransferInListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDAsync(const SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDRequest& request, const SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryTransferInList(request), context);
|
|
|
+ handler(this, request, saveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileID(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTransferInListOutcomeCallable DomainClient::queryTransferInListCallable(const QueryTransferInListRequest &request) const
|
|
|
+DomainClient::SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcomeCallable DomainClient::saveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDCallable(const SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryTransferInListOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryTransferInList(request);
|
|
|
+ return this->saveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileID(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::TransferInRefetchWhoisEmailOutcome DomainClient::transferInRefetchWhoisEmail(const TransferInRefetchWhoisEmailRequest &request) const
|
|
|
+DomainClient::GetQualificationUploadPolicyOutcome DomainClient::getQualificationUploadPolicy(const GetQualificationUploadPolicyRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return TransferInRefetchWhoisEmailOutcome(endpointOutcome.error());
|
|
|
+ return GetQualificationUploadPolicyOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return TransferInRefetchWhoisEmailOutcome(TransferInRefetchWhoisEmailResult(outcome.result()));
|
|
|
+ return GetQualificationUploadPolicyOutcome(GetQualificationUploadPolicyResult(outcome.result()));
|
|
|
else
|
|
|
- return TransferInRefetchWhoisEmailOutcome(outcome.error());
|
|
|
+ return GetQualificationUploadPolicyOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::transferInRefetchWhoisEmailAsync(const TransferInRefetchWhoisEmailRequest& request, const TransferInRefetchWhoisEmailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::getQualificationUploadPolicyAsync(const GetQualificationUploadPolicyRequest& request, const GetQualificationUploadPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, transferInRefetchWhoisEmail(request), context);
|
|
|
+ handler(this, request, getQualificationUploadPolicy(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::TransferInRefetchWhoisEmailOutcomeCallable DomainClient::transferInRefetchWhoisEmailCallable(const TransferInRefetchWhoisEmailRequest &request) const
|
|
|
+DomainClient::GetQualificationUploadPolicyOutcomeCallable DomainClient::getQualificationUploadPolicyCallable(const GetQualificationUploadPolicyRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<TransferInRefetchWhoisEmailOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<GetQualificationUploadPolicyOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->transferInRefetchWhoisEmail(request);
|
|
|
+ return this->getQualificationUploadPolicy(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTransferInByInstanceIdOutcome DomainClient::queryTransferInByInstanceId(const QueryTransferInByInstanceIdRequest &request) const
|
|
|
+DomainClient::QueryDomainRealNameVerificationInfoOutcome DomainClient::queryDomainRealNameVerificationInfo(const QueryDomainRealNameVerificationInfoRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryTransferInByInstanceIdOutcome(endpointOutcome.error());
|
|
|
+ return QueryDomainRealNameVerificationInfoOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryTransferInByInstanceIdOutcome(QueryTransferInByInstanceIdResult(outcome.result()));
|
|
|
+ return QueryDomainRealNameVerificationInfoOutcome(QueryDomainRealNameVerificationInfoResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryTransferInByInstanceIdOutcome(outcome.error());
|
|
|
+ return QueryDomainRealNameVerificationInfoOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryTransferInByInstanceIdAsync(const QueryTransferInByInstanceIdRequest& request, const QueryTransferInByInstanceIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryDomainRealNameVerificationInfoAsync(const QueryDomainRealNameVerificationInfoRequest& request, const QueryDomainRealNameVerificationInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryTransferInByInstanceId(request), context);
|
|
|
+ handler(this, request, queryDomainRealNameVerificationInfo(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTransferInByInstanceIdOutcomeCallable DomainClient::queryTransferInByInstanceIdCallable(const QueryTransferInByInstanceIdRequest &request) const
|
|
|
+DomainClient::QueryDomainRealNameVerificationInfoOutcomeCallable DomainClient::queryDomainRealNameVerificationInfoCallable(const QueryDomainRealNameVerificationInfoRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryTransferInByInstanceIdOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryDomainRealNameVerificationInfoOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryTransferInByInstanceId(request);
|
|
|
+ return this->queryDomainRealNameVerificationInfo(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForUpdateProhibitionLockOutcome DomainClient::saveSingleTaskForUpdateProhibitionLock(const SaveSingleTaskForUpdateProhibitionLockRequest &request) const
|
|
|
+DomainClient::VerifyEmailOutcome DomainClient::verifyEmail(const VerifyEmailRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForUpdateProhibitionLockOutcome(endpointOutcome.error());
|
|
|
+ return VerifyEmailOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForUpdateProhibitionLockOutcome(SaveSingleTaskForUpdateProhibitionLockResult(outcome.result()));
|
|
|
+ return VerifyEmailOutcome(VerifyEmailResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForUpdateProhibitionLockOutcome(outcome.error());
|
|
|
+ return VerifyEmailOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForUpdateProhibitionLockAsync(const SaveSingleTaskForUpdateProhibitionLockRequest& request, const SaveSingleTaskForUpdateProhibitionLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::verifyEmailAsync(const VerifyEmailRequest& request, const VerifyEmailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, verifyEmail(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::VerifyEmailOutcomeCallable DomainClient::verifyEmailCallable(const VerifyEmailRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<VerifyEmailOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->verifyEmail(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveBatchTaskForDomainNameProxyServiceOutcome DomainClient::saveBatchTaskForDomainNameProxyService(const SaveBatchTaskForDomainNameProxyServiceRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return SaveBatchTaskForDomainNameProxyServiceOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return SaveBatchTaskForDomainNameProxyServiceOutcome(SaveBatchTaskForDomainNameProxyServiceResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return SaveBatchTaskForDomainNameProxyServiceOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::saveBatchTaskForDomainNameProxyServiceAsync(const SaveBatchTaskForDomainNameProxyServiceRequest& request, const SaveBatchTaskForDomainNameProxyServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, saveBatchTaskForDomainNameProxyService(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveBatchTaskForDomainNameProxyServiceOutcomeCallable DomainClient::saveBatchTaskForDomainNameProxyServiceCallable(const SaveBatchTaskForDomainNameProxyServiceRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveBatchTaskForDomainNameProxyServiceOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->saveBatchTaskForDomainNameProxyService(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveBatchTaskForModifyingDomainDnsOutcome DomainClient::saveBatchTaskForModifyingDomainDns(const SaveBatchTaskForModifyingDomainDnsRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return SaveBatchTaskForModifyingDomainDnsOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return SaveBatchTaskForModifyingDomainDnsOutcome(SaveBatchTaskForModifyingDomainDnsResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return SaveBatchTaskForModifyingDomainDnsOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::saveBatchTaskForModifyingDomainDnsAsync(const SaveBatchTaskForModifyingDomainDnsRequest& request, const SaveBatchTaskForModifyingDomainDnsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, saveBatchTaskForModifyingDomainDns(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveBatchTaskForModifyingDomainDnsOutcomeCallable DomainClient::saveBatchTaskForModifyingDomainDnsCallable(const SaveBatchTaskForModifyingDomainDnsRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveBatchTaskForModifyingDomainDnsOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->saveBatchTaskForModifyingDomainDns(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryDnsHostOutcome DomainClient::queryDnsHost(const QueryDnsHostRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return QueryDnsHostOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return QueryDnsHostOutcome(QueryDnsHostResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return QueryDnsHostOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::queryDnsHostAsync(const QueryDnsHostRequest& request, const QueryDnsHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, queryDnsHost(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryDnsHostOutcomeCallable DomainClient::queryDnsHostCallable(const QueryDnsHostRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryDnsHostOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->queryDnsHost(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryRegistrantProfileRealNameVerificationInfoOutcome DomainClient::queryRegistrantProfileRealNameVerificationInfo(const QueryRegistrantProfileRealNameVerificationInfoRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return QueryRegistrantProfileRealNameVerificationInfoOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return QueryRegistrantProfileRealNameVerificationInfoOutcome(QueryRegistrantProfileRealNameVerificationInfoResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return QueryRegistrantProfileRealNameVerificationInfoOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::queryRegistrantProfileRealNameVerificationInfoAsync(const QueryRegistrantProfileRealNameVerificationInfoRequest& request, const QueryRegistrantProfileRealNameVerificationInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, queryRegistrantProfileRealNameVerificationInfo(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryRegistrantProfileRealNameVerificationInfoOutcomeCallable DomainClient::queryRegistrantProfileRealNameVerificationInfoCallable(const QueryRegistrantProfileRealNameVerificationInfoRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryRegistrantProfileRealNameVerificationInfoOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->queryRegistrantProfileRealNameVerificationInfo(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::FailDemandOutcome DomainClient::failDemand(const FailDemandRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return FailDemandOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return FailDemandOutcome(FailDemandResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return FailDemandOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::failDemandAsync(const FailDemandRequest& request, const FailDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, failDemand(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::FailDemandOutcomeCallable DomainClient::failDemandCallable(const FailDemandRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<FailDemandOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->failDemand(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveSingleTaskForCancelingTransferInOutcome DomainClient::saveSingleTaskForCancelingTransferIn(const SaveSingleTaskForCancelingTransferInRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return SaveSingleTaskForCancelingTransferInOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return SaveSingleTaskForCancelingTransferInOutcome(SaveSingleTaskForCancelingTransferInResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return SaveSingleTaskForCancelingTransferInOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::saveSingleTaskForCancelingTransferInAsync(const SaveSingleTaskForCancelingTransferInRequest& request, const SaveSingleTaskForCancelingTransferInAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, saveSingleTaskForCancelingTransferIn(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveSingleTaskForCancelingTransferInOutcomeCallable DomainClient::saveSingleTaskForCancelingTransferInCallable(const SaveSingleTaskForCancelingTransferInRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCancelingTransferInOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->saveSingleTaskForCancelingTransferIn(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryQualificationDetailOutcome DomainClient::queryQualificationDetail(const QueryQualificationDetailRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return QueryQualificationDetailOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return QueryQualificationDetailOutcome(QueryQualificationDetailResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return QueryQualificationDetailOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::queryQualificationDetailAsync(const QueryQualificationDetailRequest& request, const QueryQualificationDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, queryQualificationDetail(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryQualificationDetailOutcomeCallable DomainClient::queryQualificationDetailCallable(const QueryQualificationDetailRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryQualificationDetailOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->queryQualificationDetail(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveBatchTaskForTransferProhibitionLockOutcome DomainClient::saveBatchTaskForTransferProhibitionLock(const SaveBatchTaskForTransferProhibitionLockRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return SaveBatchTaskForTransferProhibitionLockOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return SaveBatchTaskForTransferProhibitionLockOutcome(SaveBatchTaskForTransferProhibitionLockResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return SaveBatchTaskForTransferProhibitionLockOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::saveBatchTaskForTransferProhibitionLockAsync(const SaveBatchTaskForTransferProhibitionLockRequest& request, const SaveBatchTaskForTransferProhibitionLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, saveBatchTaskForTransferProhibitionLock(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveBatchTaskForTransferProhibitionLockOutcomeCallable DomainClient::saveBatchTaskForTransferProhibitionLockCallable(const SaveBatchTaskForTransferProhibitionLockRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveBatchTaskForTransferProhibitionLockOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->saveBatchTaskForTransferProhibitionLock(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveBatchTaskForUpdateProhibitionLockOutcome DomainClient::saveBatchTaskForUpdateProhibitionLock(const SaveBatchTaskForUpdateProhibitionLockRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return SaveBatchTaskForUpdateProhibitionLockOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return SaveBatchTaskForUpdateProhibitionLockOutcome(SaveBatchTaskForUpdateProhibitionLockResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return SaveBatchTaskForUpdateProhibitionLockOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::saveBatchTaskForUpdateProhibitionLockAsync(const SaveBatchTaskForUpdateProhibitionLockRequest& request, const SaveBatchTaskForUpdateProhibitionLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, saveBatchTaskForUpdateProhibitionLock(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveBatchTaskForUpdateProhibitionLockOutcomeCallable DomainClient::saveBatchTaskForUpdateProhibitionLockCallable(const SaveBatchTaskForUpdateProhibitionLockRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveBatchTaskForUpdateProhibitionLockOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->saveBatchTaskForUpdateProhibitionLock(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryEmailVerificationOutcome DomainClient::queryEmailVerification(const QueryEmailVerificationRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return QueryEmailVerificationOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return QueryEmailVerificationOutcome(QueryEmailVerificationResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return QueryEmailVerificationOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::queryEmailVerificationAsync(const QueryEmailVerificationRequest& request, const QueryEmailVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, queryEmailVerification(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryEmailVerificationOutcomeCallable DomainClient::queryEmailVerificationCallable(const QueryEmailVerificationRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryEmailVerificationOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->queryEmailVerification(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::DeleteRegistrantProfileOutcome DomainClient::deleteRegistrantProfile(const DeleteRegistrantProfileRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return DeleteRegistrantProfileOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return DeleteRegistrantProfileOutcome(DeleteRegistrantProfileResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return DeleteRegistrantProfileOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::deleteRegistrantProfileAsync(const DeleteRegistrantProfileRequest& request, const DeleteRegistrantProfileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, deleteRegistrantProfile(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::DeleteRegistrantProfileOutcomeCallable DomainClient::deleteRegistrantProfileCallable(const DeleteRegistrantProfileRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<DeleteRegistrantProfileOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->deleteRegistrantProfile(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryBrokerDemandRecordOutcome DomainClient::queryBrokerDemandRecord(const QueryBrokerDemandRecordRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return QueryBrokerDemandRecordOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return QueryBrokerDemandRecordOutcome(QueryBrokerDemandRecordResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return QueryBrokerDemandRecordOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::queryBrokerDemandRecordAsync(const QueryBrokerDemandRecordRequest& request, const QueryBrokerDemandRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, queryBrokerDemandRecord(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryBrokerDemandRecordOutcomeCallable DomainClient::queryBrokerDemandRecordCallable(const QueryBrokerDemandRecordRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryBrokerDemandRecordOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->queryBrokerDemandRecord(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcome DomainClient::saveTaskForSubmittingDomainRealNameVerificationByIdentityCredential(const SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcome(SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::saveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialAsync(const SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialRequest& request, const SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, saveTaskForSubmittingDomainRealNameVerificationByIdentityCredential(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcomeCallable DomainClient::saveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialCallable(const SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->saveTaskForSubmittingDomainRealNameVerificationByIdentityCredential(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryFailReasonForRegistrantProfileRealNameVerificationOutcome DomainClient::queryFailReasonForRegistrantProfileRealNameVerification(const QueryFailReasonForRegistrantProfileRealNameVerificationRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return QueryFailReasonForRegistrantProfileRealNameVerificationOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return QueryFailReasonForRegistrantProfileRealNameVerificationOutcome(QueryFailReasonForRegistrantProfileRealNameVerificationResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return QueryFailReasonForRegistrantProfileRealNameVerificationOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::queryFailReasonForRegistrantProfileRealNameVerificationAsync(const QueryFailReasonForRegistrantProfileRealNameVerificationRequest& request, const QueryFailReasonForRegistrantProfileRealNameVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForUpdateProhibitionLock(request), context);
|
|
|
+ handler(this, request, queryFailReasonForRegistrantProfileRealNameVerification(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForUpdateProhibitionLockOutcomeCallable DomainClient::saveSingleTaskForUpdateProhibitionLockCallable(const SaveSingleTaskForUpdateProhibitionLockRequest &request) const
|
|
|
+DomainClient::QueryFailReasonForRegistrantProfileRealNameVerificationOutcomeCallable DomainClient::queryFailReasonForRegistrantProfileRealNameVerificationCallable(const QueryFailReasonForRegistrantProfileRealNameVerificationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForUpdateProhibitionLockOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryFailReasonForRegistrantProfileRealNameVerificationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForUpdateProhibitionLock(request);
|
|
|
+ return this->queryFailReasonForRegistrantProfileRealNameVerification(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::UpdateDomainToDomainGroupOutcome DomainClient::updateDomainToDomainGroup(const UpdateDomainToDomainGroupRequest &request) const
|
|
|
+DomainClient::SaveBatchTaskForCreatingOrderRenewOutcome DomainClient::saveBatchTaskForCreatingOrderRenew(const SaveBatchTaskForCreatingOrderRenewRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return UpdateDomainToDomainGroupOutcome(endpointOutcome.error());
|
|
|
+ return SaveBatchTaskForCreatingOrderRenewOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return UpdateDomainToDomainGroupOutcome(UpdateDomainToDomainGroupResult(outcome.result()));
|
|
|
+ return SaveBatchTaskForCreatingOrderRenewOutcome(SaveBatchTaskForCreatingOrderRenewResult(outcome.result()));
|
|
|
else
|
|
|
- return UpdateDomainToDomainGroupOutcome(outcome.error());
|
|
|
+ return SaveBatchTaskForCreatingOrderRenewOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::updateDomainToDomainGroupAsync(const UpdateDomainToDomainGroupRequest& request, const UpdateDomainToDomainGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveBatchTaskForCreatingOrderRenewAsync(const SaveBatchTaskForCreatingOrderRenewRequest& request, const SaveBatchTaskForCreatingOrderRenewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, updateDomainToDomainGroup(request), context);
|
|
|
+ handler(this, request, saveBatchTaskForCreatingOrderRenew(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::UpdateDomainToDomainGroupOutcomeCallable DomainClient::updateDomainToDomainGroupCallable(const UpdateDomainToDomainGroupRequest &request) const
|
|
|
+DomainClient::SaveBatchTaskForCreatingOrderRenewOutcomeCallable DomainClient::saveBatchTaskForCreatingOrderRenewCallable(const SaveBatchTaskForCreatingOrderRenewRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<UpdateDomainToDomainGroupOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveBatchTaskForCreatingOrderRenewOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->updateDomainToDomainGroup(request);
|
|
|
+ return this->saveBatchTaskForCreatingOrderRenew(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryContactInfoOutcome DomainClient::queryContactInfo(const QueryContactInfoRequest &request) const
|
|
|
+DomainClient::QueryServerLockOutcome DomainClient::queryServerLock(const QueryServerLockRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryContactInfoOutcome(endpointOutcome.error());
|
|
|
+ return QueryServerLockOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryContactInfoOutcome(QueryContactInfoResult(outcome.result()));
|
|
|
+ return QueryServerLockOutcome(QueryServerLockResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryContactInfoOutcome(outcome.error());
|
|
|
+ return QueryServerLockOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryContactInfoAsync(const QueryContactInfoRequest& request, const QueryContactInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryServerLockAsync(const QueryServerLockRequest& request, const QueryServerLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryContactInfo(request), context);
|
|
|
+ handler(this, request, queryServerLock(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryContactInfoOutcomeCallable DomainClient::queryContactInfoCallable(const QueryContactInfoRequest &request) const
|
|
|
+DomainClient::QueryServerLockOutcomeCallable DomainClient::queryServerLockCallable(const QueryServerLockRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryContactInfoOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryServerLockOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryContactInfo(request);
|
|
|
+ return this->queryServerLock(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::ReserveDomainOutcome DomainClient::reserveDomain(const ReserveDomainRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForModifyingDnsHostOutcome DomainClient::saveSingleTaskForModifyingDnsHost(const SaveSingleTaskForModifyingDnsHostRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ReserveDomainOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForModifyingDnsHostOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ReserveDomainOutcome(ReserveDomainResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForModifyingDnsHostOutcome(SaveSingleTaskForModifyingDnsHostResult(outcome.result()));
|
|
|
else
|
|
|
- return ReserveDomainOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForModifyingDnsHostOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::reserveDomainAsync(const ReserveDomainRequest& request, const ReserveDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForModifyingDnsHostAsync(const SaveSingleTaskForModifyingDnsHostRequest& request, const SaveSingleTaskForModifyingDnsHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, reserveDomain(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForModifyingDnsHost(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::ReserveDomainOutcomeCallable DomainClient::reserveDomainCallable(const ReserveDomainRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForModifyingDnsHostOutcomeCallable DomainClient::saveSingleTaskForModifyingDnsHostCallable(const SaveSingleTaskForModifyingDnsHostRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ReserveDomainOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForModifyingDnsHostOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->reserveDomain(request);
|
|
|
+ return this->saveSingleTaskForModifyingDnsHost(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::TransferInResendMailTokenOutcome DomainClient::transferInResendMailToken(const TransferInResendMailTokenRequest &request) const
|
|
|
+DomainClient::QueryBookingDomainInfoOutcome DomainClient::queryBookingDomainInfo(const QueryBookingDomainInfoRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return TransferInResendMailTokenOutcome(endpointOutcome.error());
|
|
|
+ return QueryBookingDomainInfoOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return TransferInResendMailTokenOutcome(TransferInResendMailTokenResult(outcome.result()));
|
|
|
+ return QueryBookingDomainInfoOutcome(QueryBookingDomainInfoResult(outcome.result()));
|
|
|
else
|
|
|
- return TransferInResendMailTokenOutcome(outcome.error());
|
|
|
+ return QueryBookingDomainInfoOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::transferInResendMailTokenAsync(const TransferInResendMailTokenRequest& request, const TransferInResendMailTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryBookingDomainInfoAsync(const QueryBookingDomainInfoRequest& request, const QueryBookingDomainInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, transferInResendMailToken(request), context);
|
|
|
+ handler(this, request, queryBookingDomainInfo(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::TransferInResendMailTokenOutcomeCallable DomainClient::transferInResendMailTokenCallable(const TransferInResendMailTokenRequest &request) const
|
|
|
+DomainClient::QueryBookingDomainInfoOutcomeCallable DomainClient::queryBookingDomainInfoCallable(const QueryBookingDomainInfoRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<TransferInResendMailTokenOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryBookingDomainInfoOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->transferInResendMailToken(request);
|
|
|
+ return this->queryBookingDomainInfo(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDomainSuffixOutcome DomainClient::queryDomainSuffix(const QueryDomainSuffixRequest &request) const
|
|
|
+DomainClient::QueryAuctionsOutcome DomainClient::queryAuctions(const QueryAuctionsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryDomainSuffixOutcome(endpointOutcome.error());
|
|
|
+ return QueryAuctionsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryDomainSuffixOutcome(QueryDomainSuffixResult(outcome.result()));
|
|
|
+ return QueryAuctionsOutcome(QueryAuctionsResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryDomainSuffixOutcome(outcome.error());
|
|
|
+ return QueryAuctionsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryDomainSuffixAsync(const QueryDomainSuffixRequest& request, const QueryDomainSuffixAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryAuctionsAsync(const QueryAuctionsRequest& request, const QueryAuctionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryDomainSuffix(request), context);
|
|
|
+ handler(this, request, queryAuctions(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDomainSuffixOutcomeCallable DomainClient::queryDomainSuffixCallable(const QueryDomainSuffixRequest &request) const
|
|
|
+DomainClient::QueryAuctionsOutcomeCallable DomainClient::queryAuctionsCallable(const QueryAuctionsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryDomainSuffixOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryAuctionsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryDomainSuffix(request);
|
|
|
+ return this->queryAuctions(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForQueryingTransferAuthorizationCodeOutcome DomainClient::saveSingleTaskForQueryingTransferAuthorizationCode(const SaveSingleTaskForQueryingTransferAuthorizationCodeRequest &request) const
|
|
|
+DomainClient::SaveBatchTaskForUpdatingContactInfoByNewContactOutcome DomainClient::saveBatchTaskForUpdatingContactInfoByNewContact(const SaveBatchTaskForUpdatingContactInfoByNewContactRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForQueryingTransferAuthorizationCodeOutcome(endpointOutcome.error());
|
|
|
+ return SaveBatchTaskForUpdatingContactInfoByNewContactOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForQueryingTransferAuthorizationCodeOutcome(SaveSingleTaskForQueryingTransferAuthorizationCodeResult(outcome.result()));
|
|
|
+ return SaveBatchTaskForUpdatingContactInfoByNewContactOutcome(SaveBatchTaskForUpdatingContactInfoByNewContactResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForQueryingTransferAuthorizationCodeOutcome(outcome.error());
|
|
|
+ return SaveBatchTaskForUpdatingContactInfoByNewContactOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForQueryingTransferAuthorizationCodeAsync(const SaveSingleTaskForQueryingTransferAuthorizationCodeRequest& request, const SaveSingleTaskForQueryingTransferAuthorizationCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveBatchTaskForUpdatingContactInfoByNewContactAsync(const SaveBatchTaskForUpdatingContactInfoByNewContactRequest& request, const SaveBatchTaskForUpdatingContactInfoByNewContactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForQueryingTransferAuthorizationCode(request), context);
|
|
|
+ handler(this, request, saveBatchTaskForUpdatingContactInfoByNewContact(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForQueryingTransferAuthorizationCodeOutcomeCallable DomainClient::saveSingleTaskForQueryingTransferAuthorizationCodeCallable(const SaveSingleTaskForQueryingTransferAuthorizationCodeRequest &request) const
|
|
|
+DomainClient::SaveBatchTaskForUpdatingContactInfoByNewContactOutcomeCallable DomainClient::saveBatchTaskForUpdatingContactInfoByNewContactCallable(const SaveBatchTaskForUpdatingContactInfoByNewContactRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForQueryingTransferAuthorizationCodeOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveBatchTaskForUpdatingContactInfoByNewContactOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForQueryingTransferAuthorizationCode(request);
|
|
|
+ return this->saveBatchTaskForUpdatingContactInfoByNewContact(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::GetReserveDomainUrlOutcome DomainClient::getReserveDomainUrl(const GetReserveDomainUrlRequest &request) const
|
|
|
+DomainClient::ListServerLockOutcome DomainClient::listServerLock(const ListServerLockRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return GetReserveDomainUrlOutcome(endpointOutcome.error());
|
|
|
+ return ListServerLockOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return GetReserveDomainUrlOutcome(GetReserveDomainUrlResult(outcome.result()));
|
|
|
+ return ListServerLockOutcome(ListServerLockResult(outcome.result()));
|
|
|
else
|
|
|
- return GetReserveDomainUrlOutcome(outcome.error());
|
|
|
+ return ListServerLockOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::getReserveDomainUrlAsync(const GetReserveDomainUrlRequest& request, const GetReserveDomainUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::listServerLockAsync(const ListServerLockRequest& request, const ListServerLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, getReserveDomainUrl(request), context);
|
|
|
+ handler(this, request, listServerLock(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::GetReserveDomainUrlOutcomeCallable DomainClient::getReserveDomainUrlCallable(const GetReserveDomainUrlRequest &request) const
|
|
|
+DomainClient::ListServerLockOutcomeCallable DomainClient::listServerLockCallable(const ListServerLockRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<GetReserveDomainUrlOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListServerLockOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->getReserveDomainUrl(request);
|
|
|
+ return this->listServerLock(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTaskDetailHistoryOutcome DomainClient::queryTaskDetailHistory(const QueryTaskDetailHistoryRequest &request) const
|
|
|
+DomainClient::CheckDomainOutcome DomainClient::checkDomain(const CheckDomainRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryTaskDetailHistoryOutcome(endpointOutcome.error());
|
|
|
+ return CheckDomainOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryTaskDetailHistoryOutcome(QueryTaskDetailHistoryResult(outcome.result()));
|
|
|
+ return CheckDomainOutcome(CheckDomainResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryTaskDetailHistoryOutcome(outcome.error());
|
|
|
+ return CheckDomainOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryTaskDetailHistoryAsync(const QueryTaskDetailHistoryRequest& request, const QueryTaskDetailHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::checkDomainAsync(const CheckDomainRequest& request, const CheckDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryTaskDetailHistory(request), context);
|
|
|
+ handler(this, request, checkDomain(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTaskDetailHistoryOutcomeCallable DomainClient::queryTaskDetailHistoryCallable(const QueryTaskDetailHistoryRequest &request) const
|
|
|
+DomainClient::CheckDomainOutcomeCallable DomainClient::checkDomainCallable(const CheckDomainRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryTaskDetailHistoryOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CheckDomainOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->checkDomain(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::TransferInCheckMailTokenOutcome DomainClient::transferInCheckMailToken(const TransferInCheckMailTokenRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return TransferInCheckMailTokenOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return TransferInCheckMailTokenOutcome(TransferInCheckMailTokenResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return TransferInCheckMailTokenOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::transferInCheckMailTokenAsync(const TransferInCheckMailTokenRequest& request, const TransferInCheckMailTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, transferInCheckMailToken(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::TransferInCheckMailTokenOutcomeCallable DomainClient::transferInCheckMailTokenCallable(const TransferInCheckMailTokenRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<TransferInCheckMailTokenOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->transferInCheckMailToken(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryAdvancedDomainListOutcome DomainClient::queryAdvancedDomainList(const QueryAdvancedDomainListRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return QueryAdvancedDomainListOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return QueryAdvancedDomainListOutcome(QueryAdvancedDomainListResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return QueryAdvancedDomainListOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::queryAdvancedDomainListAsync(const QueryAdvancedDomainListRequest& request, const QueryAdvancedDomainListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, queryAdvancedDomainList(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryAdvancedDomainListOutcomeCallable DomainClient::queryAdvancedDomainListCallable(const QueryAdvancedDomainListRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryAdvancedDomainListOutcome()>>(
|
|
|
+ [this, request]()
|
|
|
+ {
|
|
|
+ return this->queryAdvancedDomainList(request);
|
|
|
+ });
|
|
|
+
|
|
|
+ asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
+ return task->get_future();
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryTransferOutInfoOutcome DomainClient::queryTransferOutInfo(const QueryTransferOutInfoRequest &request) const
|
|
|
+{
|
|
|
+ auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
+ if (!endpointOutcome.isSuccess())
|
|
|
+ return QueryTransferOutInfoOutcome(endpointOutcome.error());
|
|
|
+
|
|
|
+ auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
+
|
|
|
+ if (outcome.isSuccess())
|
|
|
+ return QueryTransferOutInfoOutcome(QueryTransferOutInfoResult(outcome.result()));
|
|
|
+ else
|
|
|
+ return QueryTransferOutInfoOutcome(outcome.error());
|
|
|
+}
|
|
|
+
|
|
|
+void DomainClient::queryTransferOutInfoAsync(const QueryTransferOutInfoRequest& request, const QueryTransferOutInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+{
|
|
|
+ auto fn = [this, request, handler, context]()
|
|
|
+ {
|
|
|
+ handler(this, request, queryTransferOutInfo(request), context);
|
|
|
+ };
|
|
|
+
|
|
|
+ asyncExecute(new Runnable(fn));
|
|
|
+}
|
|
|
+
|
|
|
+DomainClient::QueryTransferOutInfoOutcomeCallable DomainClient::queryTransferOutInfoCallable(const QueryTransferOutInfoRequest &request) const
|
|
|
+{
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryTransferOutInfoOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryTaskDetailHistory(request);
|
|
|
+ return this->queryTransferOutInfo(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDomainGroupListOutcome DomainClient::queryDomainGroupList(const QueryDomainGroupListRequest &request) const
|
|
|
+DomainClient::CheckDomainSunriseClaimOutcome DomainClient::checkDomainSunriseClaim(const CheckDomainSunriseClaimRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryDomainGroupListOutcome(endpointOutcome.error());
|
|
|
+ return CheckDomainSunriseClaimOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryDomainGroupListOutcome(QueryDomainGroupListResult(outcome.result()));
|
|
|
+ return CheckDomainSunriseClaimOutcome(CheckDomainSunriseClaimResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryDomainGroupListOutcome(outcome.error());
|
|
|
+ return CheckDomainSunriseClaimOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryDomainGroupListAsync(const QueryDomainGroupListRequest& request, const QueryDomainGroupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::checkDomainSunriseClaimAsync(const CheckDomainSunriseClaimRequest& request, const CheckDomainSunriseClaimAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryDomainGroupList(request), context);
|
|
|
+ handler(this, request, checkDomainSunriseClaim(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDomainGroupListOutcomeCallable DomainClient::queryDomainGroupListCallable(const QueryDomainGroupListRequest &request) const
|
|
|
+DomainClient::CheckDomainSunriseClaimOutcomeCallable DomainClient::checkDomainSunriseClaimCallable(const CheckDomainSunriseClaimRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryDomainGroupListOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CheckDomainSunriseClaimOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryDomainGroupList(request);
|
|
|
+ return this->checkDomainSunriseClaim(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::ListEmailVerificationOutcome DomainClient::listEmailVerification(const ListEmailVerificationRequest &request) const
|
|
|
+DomainClient::SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcome DomainClient::saveTaskForUpdatingRegistrantInfoByRegistrantProfileID(const SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ListEmailVerificationOutcome(endpointOutcome.error());
|
|
|
+ return SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ListEmailVerificationOutcome(ListEmailVerificationResult(outcome.result()));
|
|
|
+ return SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcome(SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDResult(outcome.result()));
|
|
|
else
|
|
|
- return ListEmailVerificationOutcome(outcome.error());
|
|
|
+ return SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::listEmailVerificationAsync(const ListEmailVerificationRequest& request, const ListEmailVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveTaskForUpdatingRegistrantInfoByRegistrantProfileIDAsync(const SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDRequest& request, const SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, listEmailVerification(request), context);
|
|
|
+ handler(this, request, saveTaskForUpdatingRegistrantInfoByRegistrantProfileID(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::ListEmailVerificationOutcomeCallable DomainClient::listEmailVerificationCallable(const ListEmailVerificationRequest &request) const
|
|
|
+DomainClient::SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcomeCallable DomainClient::saveTaskForUpdatingRegistrantInfoByRegistrantProfileIDCallable(const SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ListEmailVerificationOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveTaskForUpdatingRegistrantInfoByRegistrantProfileIDOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->listEmailVerification(request);
|
|
|
+ return this->saveTaskForUpdatingRegistrantInfoByRegistrantProfileID(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SubmitEmailVerificationOutcome DomainClient::submitEmailVerification(const SubmitEmailVerificationRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCreatingOrderRedeemOutcome DomainClient::saveSingleTaskForCreatingOrderRedeem(const SaveSingleTaskForCreatingOrderRedeemRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SubmitEmailVerificationOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForCreatingOrderRedeemOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SubmitEmailVerificationOutcome(SubmitEmailVerificationResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForCreatingOrderRedeemOutcome(SaveSingleTaskForCreatingOrderRedeemResult(outcome.result()));
|
|
|
else
|
|
|
- return SubmitEmailVerificationOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForCreatingOrderRedeemOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::submitEmailVerificationAsync(const SubmitEmailVerificationRequest& request, const SubmitEmailVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForCreatingOrderRedeemAsync(const SaveSingleTaskForCreatingOrderRedeemRequest& request, const SaveSingleTaskForCreatingOrderRedeemAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, submitEmailVerification(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForCreatingOrderRedeem(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SubmitEmailVerificationOutcomeCallable DomainClient::submitEmailVerificationCallable(const SubmitEmailVerificationRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCreatingOrderRedeemOutcomeCallable DomainClient::saveSingleTaskForCreatingOrderRedeemCallable(const SaveSingleTaskForCreatingOrderRedeemRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SubmitEmailVerificationOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCreatingOrderRedeemOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->submitEmailVerification(request);
|
|
|
+ return this->saveSingleTaskForCreatingOrderRedeem(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::ResendEmailVerificationOutcome DomainClient::resendEmailVerification(const ResendEmailVerificationRequest &request) const
|
|
|
+DomainClient::QueryBrokerDemandOutcome DomainClient::queryBrokerDemand(const QueryBrokerDemandRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return ResendEmailVerificationOutcome(endpointOutcome.error());
|
|
|
+ return QueryBrokerDemandOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return ResendEmailVerificationOutcome(ResendEmailVerificationResult(outcome.result()));
|
|
|
+ return QueryBrokerDemandOutcome(QueryBrokerDemandResult(outcome.result()));
|
|
|
else
|
|
|
- return ResendEmailVerificationOutcome(outcome.error());
|
|
|
+ return QueryBrokerDemandOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::resendEmailVerificationAsync(const ResendEmailVerificationRequest& request, const ResendEmailVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryBrokerDemandAsync(const QueryBrokerDemandRequest& request, const QueryBrokerDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, resendEmailVerification(request), context);
|
|
|
+ handler(this, request, queryBrokerDemand(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::ResendEmailVerificationOutcomeCallable DomainClient::resendEmailVerificationCallable(const ResendEmailVerificationRequest &request) const
|
|
|
+DomainClient::QueryBrokerDemandOutcomeCallable DomainClient::queryBrokerDemandCallable(const QueryBrokerDemandRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<ResendEmailVerificationOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryBrokerDemandOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->resendEmailVerification(request);
|
|
|
+ return this->queryBrokerDemand(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::BidDomainOutcome DomainClient::bidDomain(const BidDomainRequest &request) const
|
|
|
+DomainClient::QueryTaskDetailListOutcome DomainClient::queryTaskDetailList(const QueryTaskDetailListRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return BidDomainOutcome(endpointOutcome.error());
|
|
|
+ return QueryTaskDetailListOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return BidDomainOutcome(BidDomainResult(outcome.result()));
|
|
|
+ return QueryTaskDetailListOutcome(QueryTaskDetailListResult(outcome.result()));
|
|
|
else
|
|
|
- return BidDomainOutcome(outcome.error());
|
|
|
+ return QueryTaskDetailListOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::bidDomainAsync(const BidDomainRequest& request, const BidDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryTaskDetailListAsync(const QueryTaskDetailListRequest& request, const QueryTaskDetailListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, bidDomain(request), context);
|
|
|
+ handler(this, request, queryTaskDetailList(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::BidDomainOutcomeCallable DomainClient::bidDomainCallable(const BidDomainRequest &request) const
|
|
|
+DomainClient::QueryTaskDetailListOutcomeCallable DomainClient::queryTaskDetailListCallable(const QueryTaskDetailListRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<BidDomainOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryTaskDetailListOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->bidDomain(request);
|
|
|
+ return this->queryTaskDetailList(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCancelingTransferOutOutcome DomainClient::saveSingleTaskForCancelingTransferOut(const SaveSingleTaskForCancelingTransferOutRequest &request) const
|
|
|
+DomainClient::SaveBatchDomainRemarkOutcome DomainClient::saveBatchDomainRemark(const SaveBatchDomainRemarkRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForCancelingTransferOutOutcome(endpointOutcome.error());
|
|
|
+ return SaveBatchDomainRemarkOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForCancelingTransferOutOutcome(SaveSingleTaskForCancelingTransferOutResult(outcome.result()));
|
|
|
+ return SaveBatchDomainRemarkOutcome(SaveBatchDomainRemarkResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForCancelingTransferOutOutcome(outcome.error());
|
|
|
+ return SaveBatchDomainRemarkOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForCancelingTransferOutAsync(const SaveSingleTaskForCancelingTransferOutRequest& request, const SaveSingleTaskForCancelingTransferOutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveBatchDomainRemarkAsync(const SaveBatchDomainRemarkRequest& request, const SaveBatchDomainRemarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForCancelingTransferOut(request), context);
|
|
|
+ handler(this, request, saveBatchDomainRemark(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCancelingTransferOutOutcomeCallable DomainClient::saveSingleTaskForCancelingTransferOutCallable(const SaveSingleTaskForCancelingTransferOutRequest &request) const
|
|
|
+DomainClient::SaveBatchDomainRemarkOutcomeCallable DomainClient::saveBatchDomainRemarkCallable(const SaveBatchDomainRemarkRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCancelingTransferOutOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveBatchDomainRemarkOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForCancelingTransferOut(request);
|
|
|
+ return this->saveBatchDomainRemark(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveDomainGroupOutcome DomainClient::saveDomainGroup(const SaveDomainGroupRequest &request) const
|
|
|
+DomainClient::FinishDemandOutcome DomainClient::finishDemand(const FinishDemandRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveDomainGroupOutcome(endpointOutcome.error());
|
|
|
+ return FinishDemandOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveDomainGroupOutcome(SaveDomainGroupResult(outcome.result()));
|
|
|
+ return FinishDemandOutcome(FinishDemandResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveDomainGroupOutcome(outcome.error());
|
|
|
+ return FinishDemandOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveDomainGroupAsync(const SaveDomainGroupRequest& request, const SaveDomainGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::finishDemandAsync(const FinishDemandRequest& request, const FinishDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveDomainGroup(request), context);
|
|
|
+ handler(this, request, finishDemand(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveDomainGroupOutcomeCallable DomainClient::saveDomainGroupCallable(const SaveDomainGroupRequest &request) const
|
|
|
+DomainClient::FinishDemandOutcomeCallable DomainClient::finishDemandCallable(const FinishDemandRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveDomainGroupOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<FinishDemandOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveDomainGroup(request);
|
|
|
+ return this->finishDemand(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::AcknowledgeTaskResultOutcome DomainClient::acknowledgeTaskResult(const AcknowledgeTaskResultRequest &request) const
|
|
|
+DomainClient::QueryEnsAssociationOutcome DomainClient::queryEnsAssociation(const QueryEnsAssociationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return AcknowledgeTaskResultOutcome(endpointOutcome.error());
|
|
|
+ return QueryEnsAssociationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return AcknowledgeTaskResultOutcome(AcknowledgeTaskResultResult(outcome.result()));
|
|
|
+ return QueryEnsAssociationOutcome(QueryEnsAssociationResult(outcome.result()));
|
|
|
else
|
|
|
- return AcknowledgeTaskResultOutcome(outcome.error());
|
|
|
+ return QueryEnsAssociationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::acknowledgeTaskResultAsync(const AcknowledgeTaskResultRequest& request, const AcknowledgeTaskResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryEnsAssociationAsync(const QueryEnsAssociationRequest& request, const QueryEnsAssociationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, acknowledgeTaskResult(request), context);
|
|
|
+ handler(this, request, queryEnsAssociation(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::AcknowledgeTaskResultOutcomeCallable DomainClient::acknowledgeTaskResultCallable(const AcknowledgeTaskResultRequest &request) const
|
|
|
+DomainClient::QueryEnsAssociationOutcomeCallable DomainClient::queryEnsAssociationCallable(const QueryEnsAssociationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<AcknowledgeTaskResultOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryEnsAssociationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->acknowledgeTaskResult(request);
|
|
|
+ return this->queryEnsAssociation(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForApprovingTransferOutOutcome DomainClient::saveSingleTaskForApprovingTransferOut(const SaveSingleTaskForApprovingTransferOutRequest &request) const
|
|
|
+DomainClient::SaveBatchTaskForCreatingOrderActivateOutcome DomainClient::saveBatchTaskForCreatingOrderActivate(const SaveBatchTaskForCreatingOrderActivateRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForApprovingTransferOutOutcome(endpointOutcome.error());
|
|
|
+ return SaveBatchTaskForCreatingOrderActivateOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForApprovingTransferOutOutcome(SaveSingleTaskForApprovingTransferOutResult(outcome.result()));
|
|
|
+ return SaveBatchTaskForCreatingOrderActivateOutcome(SaveBatchTaskForCreatingOrderActivateResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForApprovingTransferOutOutcome(outcome.error());
|
|
|
+ return SaveBatchTaskForCreatingOrderActivateOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForApprovingTransferOutAsync(const SaveSingleTaskForApprovingTransferOutRequest& request, const SaveSingleTaskForApprovingTransferOutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveBatchTaskForCreatingOrderActivateAsync(const SaveBatchTaskForCreatingOrderActivateRequest& request, const SaveBatchTaskForCreatingOrderActivateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForApprovingTransferOut(request), context);
|
|
|
+ handler(this, request, saveBatchTaskForCreatingOrderActivate(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForApprovingTransferOutOutcomeCallable DomainClient::saveSingleTaskForApprovingTransferOutCallable(const SaveSingleTaskForApprovingTransferOutRequest &request) const
|
|
|
+DomainClient::SaveBatchTaskForCreatingOrderActivateOutcomeCallable DomainClient::saveBatchTaskForCreatingOrderActivateCallable(const SaveBatchTaskForCreatingOrderActivateRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForApprovingTransferOutOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveBatchTaskForCreatingOrderActivateOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForApprovingTransferOut(request);
|
|
|
+ return this->saveBatchTaskForCreatingOrderActivate(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForUpdatingContactInfoOutcome DomainClient::saveSingleTaskForUpdatingContactInfo(const SaveSingleTaskForUpdatingContactInfoRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForTransferProhibitionLockOutcome DomainClient::saveSingleTaskForTransferProhibitionLock(const SaveSingleTaskForTransferProhibitionLockRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForUpdatingContactInfoOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForTransferProhibitionLockOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForUpdatingContactInfoOutcome(SaveSingleTaskForUpdatingContactInfoResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForTransferProhibitionLockOutcome(SaveSingleTaskForTransferProhibitionLockResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForUpdatingContactInfoOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForTransferProhibitionLockOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForUpdatingContactInfoAsync(const SaveSingleTaskForUpdatingContactInfoRequest& request, const SaveSingleTaskForUpdatingContactInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForTransferProhibitionLockAsync(const SaveSingleTaskForTransferProhibitionLockRequest& request, const SaveSingleTaskForTransferProhibitionLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForUpdatingContactInfo(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForTransferProhibitionLock(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForUpdatingContactInfoOutcomeCallable DomainClient::saveSingleTaskForUpdatingContactInfoCallable(const SaveSingleTaskForUpdatingContactInfoRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForTransferProhibitionLockOutcomeCallable DomainClient::saveSingleTaskForTransferProhibitionLockCallable(const SaveSingleTaskForTransferProhibitionLockRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForUpdatingContactInfoOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForTransferProhibitionLockOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForUpdatingContactInfo(request);
|
|
|
+ return this->saveSingleTaskForTransferProhibitionLock(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForCreatingOrderTransferOutcome DomainClient::saveBatchTaskForCreatingOrderTransfer(const SaveBatchTaskForCreatingOrderTransferRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForAssociatingEnsOutcome DomainClient::saveSingleTaskForAssociatingEns(const SaveSingleTaskForAssociatingEnsRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveBatchTaskForCreatingOrderTransferOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForAssociatingEnsOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveBatchTaskForCreatingOrderTransferOutcome(SaveBatchTaskForCreatingOrderTransferResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForAssociatingEnsOutcome(SaveSingleTaskForAssociatingEnsResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveBatchTaskForCreatingOrderTransferOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForAssociatingEnsOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveBatchTaskForCreatingOrderTransferAsync(const SaveBatchTaskForCreatingOrderTransferRequest& request, const SaveBatchTaskForCreatingOrderTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForAssociatingEnsAsync(const SaveSingleTaskForAssociatingEnsRequest& request, const SaveSingleTaskForAssociatingEnsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveBatchTaskForCreatingOrderTransfer(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForAssociatingEns(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForCreatingOrderTransferOutcomeCallable DomainClient::saveBatchTaskForCreatingOrderTransferCallable(const SaveBatchTaskForCreatingOrderTransferRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForAssociatingEnsOutcomeCallable DomainClient::saveSingleTaskForAssociatingEnsCallable(const SaveSingleTaskForAssociatingEnsRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveBatchTaskForCreatingOrderTransferOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForAssociatingEnsOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveBatchTaskForCreatingOrderTransfer(request);
|
|
|
+ return this->saveSingleTaskForAssociatingEns(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcome DomainClient::saveTaskForUpdatingRegistrantInfoByIdentityCredential(const SaveTaskForUpdatingRegistrantInfoByIdentityCredentialRequest &request) const
|
|
|
+DomainClient::SaveTaskForSubmittingDomainDeleteOutcome DomainClient::saveTaskForSubmittingDomainDelete(const SaveTaskForSubmittingDomainDeleteRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcome(endpointOutcome.error());
|
|
|
+ return SaveTaskForSubmittingDomainDeleteOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcome(SaveTaskForUpdatingRegistrantInfoByIdentityCredentialResult(outcome.result()));
|
|
|
+ return SaveTaskForSubmittingDomainDeleteOutcome(SaveTaskForSubmittingDomainDeleteResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcome(outcome.error());
|
|
|
+ return SaveTaskForSubmittingDomainDeleteOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveTaskForUpdatingRegistrantInfoByIdentityCredentialAsync(const SaveTaskForUpdatingRegistrantInfoByIdentityCredentialRequest& request, const SaveTaskForUpdatingRegistrantInfoByIdentityCredentialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveTaskForSubmittingDomainDeleteAsync(const SaveTaskForSubmittingDomainDeleteRequest& request, const SaveTaskForSubmittingDomainDeleteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveTaskForUpdatingRegistrantInfoByIdentityCredential(request), context);
|
|
|
+ handler(this, request, saveTaskForSubmittingDomainDelete(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcomeCallable DomainClient::saveTaskForUpdatingRegistrantInfoByIdentityCredentialCallable(const SaveTaskForUpdatingRegistrantInfoByIdentityCredentialRequest &request) const
|
|
|
+DomainClient::SaveTaskForSubmittingDomainDeleteOutcomeCallable DomainClient::saveTaskForSubmittingDomainDeleteCallable(const SaveTaskForSubmittingDomainDeleteRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveTaskForSubmittingDomainDeleteOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveTaskForUpdatingRegistrantInfoByIdentityCredential(request);
|
|
|
+ return this->saveTaskForSubmittingDomainDelete(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::DeleteDomainGroupOutcome DomainClient::deleteDomainGroup(const DeleteDomainGroupRequest &request) const
|
|
|
+DomainClient::QueryTransferInListOutcome DomainClient::queryTransferInList(const QueryTransferInListRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return DeleteDomainGroupOutcome(endpointOutcome.error());
|
|
|
+ return QueryTransferInListOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return DeleteDomainGroupOutcome(DeleteDomainGroupResult(outcome.result()));
|
|
|
+ return QueryTransferInListOutcome(QueryTransferInListResult(outcome.result()));
|
|
|
else
|
|
|
- return DeleteDomainGroupOutcome(outcome.error());
|
|
|
+ return QueryTransferInListOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::deleteDomainGroupAsync(const DeleteDomainGroupRequest& request, const DeleteDomainGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryTransferInListAsync(const QueryTransferInListRequest& request, const QueryTransferInListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, deleteDomainGroup(request), context);
|
|
|
+ handler(this, request, queryTransferInList(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::DeleteDomainGroupOutcomeCallable DomainClient::deleteDomainGroupCallable(const DeleteDomainGroupRequest &request) const
|
|
|
+DomainClient::QueryTransferInListOutcomeCallable DomainClient::queryTransferInListCallable(const QueryTransferInListRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<DeleteDomainGroupOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryTransferInListOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->deleteDomainGroup(request);
|
|
|
+ return this->queryTransferInList(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcome DomainClient::saveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileID(const SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDRequest &request) const
|
|
|
+DomainClient::TransferInRefetchWhoisEmailOutcome DomainClient::transferInRefetchWhoisEmail(const TransferInRefetchWhoisEmailRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcome(endpointOutcome.error());
|
|
|
+ return TransferInRefetchWhoisEmailOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcome(SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDResult(outcome.result()));
|
|
|
+ return TransferInRefetchWhoisEmailOutcome(TransferInRefetchWhoisEmailResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcome(outcome.error());
|
|
|
+ return TransferInRefetchWhoisEmailOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDAsync(const SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDRequest& request, const SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::transferInRefetchWhoisEmailAsync(const TransferInRefetchWhoisEmailRequest& request, const TransferInRefetchWhoisEmailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileID(request), context);
|
|
|
+ handler(this, request, transferInRefetchWhoisEmail(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcomeCallable DomainClient::saveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDCallable(const SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDRequest &request) const
|
|
|
+DomainClient::TransferInRefetchWhoisEmailOutcomeCallable DomainClient::transferInRefetchWhoisEmailCallable(const TransferInRefetchWhoisEmailRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileIDOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<TransferInRefetchWhoisEmailOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveTaskForSubmittingDomainRealNameVerificationByRegistrantProfileID(request);
|
|
|
+ return this->transferInRefetchWhoisEmail(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryAuctionDetailOutcome DomainClient::queryAuctionDetail(const QueryAuctionDetailRequest &request) const
|
|
|
+DomainClient::QueryTransferInByInstanceIdOutcome DomainClient::queryTransferInByInstanceId(const QueryTransferInByInstanceIdRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryAuctionDetailOutcome(endpointOutcome.error());
|
|
|
+ return QueryTransferInByInstanceIdOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryAuctionDetailOutcome(QueryAuctionDetailResult(outcome.result()));
|
|
|
+ return QueryTransferInByInstanceIdOutcome(QueryTransferInByInstanceIdResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryAuctionDetailOutcome(outcome.error());
|
|
|
+ return QueryTransferInByInstanceIdOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryAuctionDetailAsync(const QueryAuctionDetailRequest& request, const QueryAuctionDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryTransferInByInstanceIdAsync(const QueryTransferInByInstanceIdRequest& request, const QueryTransferInByInstanceIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryAuctionDetail(request), context);
|
|
|
+ handler(this, request, queryTransferInByInstanceId(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryAuctionDetailOutcomeCallable DomainClient::queryAuctionDetailCallable(const QueryAuctionDetailRequest &request) const
|
|
|
+DomainClient::QueryTransferInByInstanceIdOutcomeCallable DomainClient::queryTransferInByInstanceIdCallable(const QueryTransferInByInstanceIdRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryAuctionDetailOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryTransferInByInstanceIdOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryAuctionDetail(request);
|
|
|
+ return this->queryTransferInByInstanceId(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDomainByInstanceIdOutcome DomainClient::queryDomainByInstanceId(const QueryDomainByInstanceIdRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForUpdateProhibitionLockOutcome DomainClient::saveSingleTaskForUpdateProhibitionLock(const SaveSingleTaskForUpdateProhibitionLockRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryDomainByInstanceIdOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForUpdateProhibitionLockOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryDomainByInstanceIdOutcome(QueryDomainByInstanceIdResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForUpdateProhibitionLockOutcome(SaveSingleTaskForUpdateProhibitionLockResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryDomainByInstanceIdOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForUpdateProhibitionLockOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryDomainByInstanceIdAsync(const QueryDomainByInstanceIdRequest& request, const QueryDomainByInstanceIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForUpdateProhibitionLockAsync(const SaveSingleTaskForUpdateProhibitionLockRequest& request, const SaveSingleTaskForUpdateProhibitionLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryDomainByInstanceId(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForUpdateProhibitionLock(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDomainByInstanceIdOutcomeCallable DomainClient::queryDomainByInstanceIdCallable(const QueryDomainByInstanceIdRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForUpdateProhibitionLockOutcomeCallable DomainClient::saveSingleTaskForUpdateProhibitionLockCallable(const SaveSingleTaskForUpdateProhibitionLockRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryDomainByInstanceIdOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForUpdateProhibitionLockOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryDomainByInstanceId(request);
|
|
|
+ return this->saveSingleTaskForUpdateProhibitionLock(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDomainRealNameVerificationInfoOutcome DomainClient::queryDomainRealNameVerificationInfo(const QueryDomainRealNameVerificationInfoRequest &request) const
|
|
|
+DomainClient::LookupTmchNoticeOutcome DomainClient::lookupTmchNotice(const LookupTmchNoticeRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryDomainRealNameVerificationInfoOutcome(endpointOutcome.error());
|
|
|
+ return LookupTmchNoticeOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryDomainRealNameVerificationInfoOutcome(QueryDomainRealNameVerificationInfoResult(outcome.result()));
|
|
|
+ return LookupTmchNoticeOutcome(LookupTmchNoticeResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryDomainRealNameVerificationInfoOutcome(outcome.error());
|
|
|
+ return LookupTmchNoticeOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryDomainRealNameVerificationInfoAsync(const QueryDomainRealNameVerificationInfoRequest& request, const QueryDomainRealNameVerificationInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::lookupTmchNoticeAsync(const LookupTmchNoticeRequest& request, const LookupTmchNoticeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryDomainRealNameVerificationInfo(request), context);
|
|
|
+ handler(this, request, lookupTmchNotice(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDomainRealNameVerificationInfoOutcomeCallable DomainClient::queryDomainRealNameVerificationInfoCallable(const QueryDomainRealNameVerificationInfoRequest &request) const
|
|
|
+DomainClient::LookupTmchNoticeOutcomeCallable DomainClient::lookupTmchNoticeCallable(const LookupTmchNoticeRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryDomainRealNameVerificationInfoOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<LookupTmchNoticeOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryDomainRealNameVerificationInfo(request);
|
|
|
+ return this->lookupTmchNotice(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::VerifyEmailOutcome DomainClient::verifyEmail(const VerifyEmailRequest &request) const
|
|
|
+DomainClient::ReserveDomainOutcome DomainClient::reserveDomain(const ReserveDomainRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return VerifyEmailOutcome(endpointOutcome.error());
|
|
|
+ return ReserveDomainOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return VerifyEmailOutcome(VerifyEmailResult(outcome.result()));
|
|
|
+ return ReserveDomainOutcome(ReserveDomainResult(outcome.result()));
|
|
|
else
|
|
|
- return VerifyEmailOutcome(outcome.error());
|
|
|
+ return ReserveDomainOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::verifyEmailAsync(const VerifyEmailRequest& request, const VerifyEmailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::reserveDomainAsync(const ReserveDomainRequest& request, const ReserveDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, verifyEmail(request), context);
|
|
|
+ handler(this, request, reserveDomain(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::VerifyEmailOutcomeCallable DomainClient::verifyEmailCallable(const VerifyEmailRequest &request) const
|
|
|
+DomainClient::ReserveDomainOutcomeCallable DomainClient::reserveDomainCallable(const ReserveDomainRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<VerifyEmailOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ReserveDomainOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->verifyEmail(request);
|
|
|
+ return this->reserveDomain(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForDeletingDnsHostOutcome DomainClient::saveSingleTaskForDeletingDnsHost(const SaveSingleTaskForDeletingDnsHostRequest &request) const
|
|
|
+DomainClient::QueryFailingReasonListForQualificationOutcome DomainClient::queryFailingReasonListForQualification(const QueryFailingReasonListForQualificationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForDeletingDnsHostOutcome(endpointOutcome.error());
|
|
|
+ return QueryFailingReasonListForQualificationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForDeletingDnsHostOutcome(SaveSingleTaskForDeletingDnsHostResult(outcome.result()));
|
|
|
+ return QueryFailingReasonListForQualificationOutcome(QueryFailingReasonListForQualificationResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForDeletingDnsHostOutcome(outcome.error());
|
|
|
+ return QueryFailingReasonListForQualificationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForDeletingDnsHostAsync(const SaveSingleTaskForDeletingDnsHostRequest& request, const SaveSingleTaskForDeletingDnsHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryFailingReasonListForQualificationAsync(const QueryFailingReasonListForQualificationRequest& request, const QueryFailingReasonListForQualificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForDeletingDnsHost(request), context);
|
|
|
+ handler(this, request, queryFailingReasonListForQualification(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForDeletingDnsHostOutcomeCallable DomainClient::saveSingleTaskForDeletingDnsHostCallable(const SaveSingleTaskForDeletingDnsHostRequest &request) const
|
|
|
+DomainClient::QueryFailingReasonListForQualificationOutcomeCallable DomainClient::queryFailingReasonListForQualificationCallable(const QueryFailingReasonListForQualificationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForDeletingDnsHostOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryFailingReasonListForQualificationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForDeletingDnsHost(request);
|
|
|
+ return this->queryFailingReasonListForQualification(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForCreatingOrderRedeemOutcome DomainClient::saveBatchTaskForCreatingOrderRedeem(const SaveBatchTaskForCreatingOrderRedeemRequest &request) const
|
|
|
+DomainClient::TransferInResendMailTokenOutcome DomainClient::transferInResendMailToken(const TransferInResendMailTokenRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveBatchTaskForCreatingOrderRedeemOutcome(endpointOutcome.error());
|
|
|
+ return TransferInResendMailTokenOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveBatchTaskForCreatingOrderRedeemOutcome(SaveBatchTaskForCreatingOrderRedeemResult(outcome.result()));
|
|
|
+ return TransferInResendMailTokenOutcome(TransferInResendMailTokenResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveBatchTaskForCreatingOrderRedeemOutcome(outcome.error());
|
|
|
+ return TransferInResendMailTokenOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveBatchTaskForCreatingOrderRedeemAsync(const SaveBatchTaskForCreatingOrderRedeemRequest& request, const SaveBatchTaskForCreatingOrderRedeemAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::transferInResendMailTokenAsync(const TransferInResendMailTokenRequest& request, const TransferInResendMailTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveBatchTaskForCreatingOrderRedeem(request), context);
|
|
|
+ handler(this, request, transferInResendMailToken(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForCreatingOrderRedeemOutcomeCallable DomainClient::saveBatchTaskForCreatingOrderRedeemCallable(const SaveBatchTaskForCreatingOrderRedeemRequest &request) const
|
|
|
+DomainClient::TransferInResendMailTokenOutcomeCallable DomainClient::transferInResendMailTokenCallable(const TransferInResendMailTokenRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveBatchTaskForCreatingOrderRedeemOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<TransferInResendMailTokenOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveBatchTaskForCreatingOrderRedeem(request);
|
|
|
+ return this->transferInResendMailToken(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForDomainNameProxyServiceOutcome DomainClient::saveBatchTaskForDomainNameProxyService(const SaveBatchTaskForDomainNameProxyServiceRequest &request) const
|
|
|
+DomainClient::QueryTaskDetailHistoryOutcome DomainClient::queryTaskDetailHistory(const QueryTaskDetailHistoryRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveBatchTaskForDomainNameProxyServiceOutcome(endpointOutcome.error());
|
|
|
+ return QueryTaskDetailHistoryOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveBatchTaskForDomainNameProxyServiceOutcome(SaveBatchTaskForDomainNameProxyServiceResult(outcome.result()));
|
|
|
+ return QueryTaskDetailHistoryOutcome(QueryTaskDetailHistoryResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveBatchTaskForDomainNameProxyServiceOutcome(outcome.error());
|
|
|
+ return QueryTaskDetailHistoryOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveBatchTaskForDomainNameProxyServiceAsync(const SaveBatchTaskForDomainNameProxyServiceRequest& request, const SaveBatchTaskForDomainNameProxyServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryTaskDetailHistoryAsync(const QueryTaskDetailHistoryRequest& request, const QueryTaskDetailHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveBatchTaskForDomainNameProxyService(request), context);
|
|
|
+ handler(this, request, queryTaskDetailHistory(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForDomainNameProxyServiceOutcomeCallable DomainClient::saveBatchTaskForDomainNameProxyServiceCallable(const SaveBatchTaskForDomainNameProxyServiceRequest &request) const
|
|
|
+DomainClient::QueryTaskDetailHistoryOutcomeCallable DomainClient::queryTaskDetailHistoryCallable(const QueryTaskDetailHistoryRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveBatchTaskForDomainNameProxyServiceOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryTaskDetailHistoryOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveBatchTaskForDomainNameProxyService(request);
|
|
|
+ return this->queryTaskDetailHistory(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForModifyingDomainDnsOutcome DomainClient::saveBatchTaskForModifyingDomainDns(const SaveBatchTaskForModifyingDomainDnsRequest &request) const
|
|
|
+DomainClient::QueryDomainGroupListOutcome DomainClient::queryDomainGroupList(const QueryDomainGroupListRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveBatchTaskForModifyingDomainDnsOutcome(endpointOutcome.error());
|
|
|
+ return QueryDomainGroupListOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveBatchTaskForModifyingDomainDnsOutcome(SaveBatchTaskForModifyingDomainDnsResult(outcome.result()));
|
|
|
+ return QueryDomainGroupListOutcome(QueryDomainGroupListResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveBatchTaskForModifyingDomainDnsOutcome(outcome.error());
|
|
|
+ return QueryDomainGroupListOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveBatchTaskForModifyingDomainDnsAsync(const SaveBatchTaskForModifyingDomainDnsRequest& request, const SaveBatchTaskForModifyingDomainDnsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryDomainGroupListAsync(const QueryDomainGroupListRequest& request, const QueryDomainGroupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveBatchTaskForModifyingDomainDns(request), context);
|
|
|
+ handler(this, request, queryDomainGroupList(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForModifyingDomainDnsOutcomeCallable DomainClient::saveBatchTaskForModifyingDomainDnsCallable(const SaveBatchTaskForModifyingDomainDnsRequest &request) const
|
|
|
+DomainClient::QueryDomainGroupListOutcomeCallable DomainClient::queryDomainGroupListCallable(const QueryDomainGroupListRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveBatchTaskForModifyingDomainDnsOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryDomainGroupListOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveBatchTaskForModifyingDomainDns(request);
|
|
|
+ return this->queryDomainGroupList(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDnsHostOutcome DomainClient::queryDnsHost(const QueryDnsHostRequest &request) const
|
|
|
+DomainClient::ListEmailVerificationOutcome DomainClient::listEmailVerification(const ListEmailVerificationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryDnsHostOutcome(endpointOutcome.error());
|
|
|
+ return ListEmailVerificationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryDnsHostOutcome(QueryDnsHostResult(outcome.result()));
|
|
|
+ return ListEmailVerificationOutcome(ListEmailVerificationResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryDnsHostOutcome(outcome.error());
|
|
|
+ return ListEmailVerificationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryDnsHostAsync(const QueryDnsHostRequest& request, const QueryDnsHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::listEmailVerificationAsync(const ListEmailVerificationRequest& request, const ListEmailVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryDnsHost(request), context);
|
|
|
+ handler(this, request, listEmailVerification(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryDnsHostOutcomeCallable DomainClient::queryDnsHostCallable(const QueryDnsHostRequest &request) const
|
|
|
+DomainClient::ListEmailVerificationOutcomeCallable DomainClient::listEmailVerificationCallable(const ListEmailVerificationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryDnsHostOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<ListEmailVerificationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryDnsHost(request);
|
|
|
+ return this->listEmailVerification(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTaskListOutcome DomainClient::queryTaskList(const QueryTaskListRequest &request) const
|
|
|
+DomainClient::SaveDomainGroupOutcome DomainClient::saveDomainGroup(const SaveDomainGroupRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryTaskListOutcome(endpointOutcome.error());
|
|
|
+ return SaveDomainGroupOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryTaskListOutcome(QueryTaskListResult(outcome.result()));
|
|
|
+ return SaveDomainGroupOutcome(SaveDomainGroupResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryTaskListOutcome(outcome.error());
|
|
|
+ return SaveDomainGroupOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryTaskListAsync(const QueryTaskListRequest& request, const QueryTaskListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveDomainGroupAsync(const SaveDomainGroupRequest& request, const SaveDomainGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryTaskList(request), context);
|
|
|
+ handler(this, request, saveDomainGroup(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTaskListOutcomeCallable DomainClient::queryTaskListCallable(const QueryTaskListRequest &request) const
|
|
|
+DomainClient::SaveDomainGroupOutcomeCallable DomainClient::saveDomainGroupCallable(const SaveDomainGroupRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryTaskListOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveDomainGroupOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryTaskList(request);
|
|
|
+ return this->saveDomainGroup(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryRegistrantProfileRealNameVerificationInfoOutcome DomainClient::queryRegistrantProfileRealNameVerificationInfo(const QueryRegistrantProfileRealNameVerificationInfoRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForApprovingTransferOutOutcome DomainClient::saveSingleTaskForApprovingTransferOut(const SaveSingleTaskForApprovingTransferOutRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryRegistrantProfileRealNameVerificationInfoOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForApprovingTransferOutOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryRegistrantProfileRealNameVerificationInfoOutcome(QueryRegistrantProfileRealNameVerificationInfoResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForApprovingTransferOutOutcome(SaveSingleTaskForApprovingTransferOutResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryRegistrantProfileRealNameVerificationInfoOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForApprovingTransferOutOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryRegistrantProfileRealNameVerificationInfoAsync(const QueryRegistrantProfileRealNameVerificationInfoRequest& request, const QueryRegistrantProfileRealNameVerificationInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForApprovingTransferOutAsync(const SaveSingleTaskForApprovingTransferOutRequest& request, const SaveSingleTaskForApprovingTransferOutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryRegistrantProfileRealNameVerificationInfo(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForApprovingTransferOut(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryRegistrantProfileRealNameVerificationInfoOutcomeCallable DomainClient::queryRegistrantProfileRealNameVerificationInfoCallable(const QueryRegistrantProfileRealNameVerificationInfoRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForApprovingTransferOutOutcomeCallable DomainClient::saveSingleTaskForApprovingTransferOutCallable(const SaveSingleTaskForApprovingTransferOutRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryRegistrantProfileRealNameVerificationInfoOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForApprovingTransferOutOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryRegistrantProfileRealNameVerificationInfo(request);
|
|
|
+ return this->saveSingleTaskForApprovingTransferOut(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryRegistrantProfilesOutcome DomainClient::queryRegistrantProfiles(const QueryRegistrantProfilesRequest &request) const
|
|
|
+DomainClient::SaveBatchTaskForCreatingOrderTransferOutcome DomainClient::saveBatchTaskForCreatingOrderTransfer(const SaveBatchTaskForCreatingOrderTransferRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryRegistrantProfilesOutcome(endpointOutcome.error());
|
|
|
+ return SaveBatchTaskForCreatingOrderTransferOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryRegistrantProfilesOutcome(QueryRegistrantProfilesResult(outcome.result()));
|
|
|
+ return SaveBatchTaskForCreatingOrderTransferOutcome(SaveBatchTaskForCreatingOrderTransferResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryRegistrantProfilesOutcome(outcome.error());
|
|
|
+ return SaveBatchTaskForCreatingOrderTransferOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryRegistrantProfilesAsync(const QueryRegistrantProfilesRequest& request, const QueryRegistrantProfilesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveBatchTaskForCreatingOrderTransferAsync(const SaveBatchTaskForCreatingOrderTransferRequest& request, const SaveBatchTaskForCreatingOrderTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryRegistrantProfiles(request), context);
|
|
|
+ handler(this, request, saveBatchTaskForCreatingOrderTransfer(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryRegistrantProfilesOutcomeCallable DomainClient::queryRegistrantProfilesCallable(const QueryRegistrantProfilesRequest &request) const
|
|
|
+DomainClient::SaveBatchTaskForCreatingOrderTransferOutcomeCallable DomainClient::saveBatchTaskForCreatingOrderTransferCallable(const SaveBatchTaskForCreatingOrderTransferRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryRegistrantProfilesOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveBatchTaskForCreatingOrderTransferOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryRegistrantProfiles(request);
|
|
|
+ return this->saveBatchTaskForCreatingOrderTransfer(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::FailDemandOutcome DomainClient::failDemand(const FailDemandRequest &request) const
|
|
|
+DomainClient::SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcome DomainClient::saveTaskForUpdatingRegistrantInfoByIdentityCredential(const SaveTaskForUpdatingRegistrantInfoByIdentityCredentialRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return FailDemandOutcome(endpointOutcome.error());
|
|
|
+ return SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return FailDemandOutcome(FailDemandResult(outcome.result()));
|
|
|
+ return SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcome(SaveTaskForUpdatingRegistrantInfoByIdentityCredentialResult(outcome.result()));
|
|
|
else
|
|
|
- return FailDemandOutcome(outcome.error());
|
|
|
+ return SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::failDemandAsync(const FailDemandRequest& request, const FailDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveTaskForUpdatingRegistrantInfoByIdentityCredentialAsync(const SaveTaskForUpdatingRegistrantInfoByIdentityCredentialRequest& request, const SaveTaskForUpdatingRegistrantInfoByIdentityCredentialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, failDemand(request), context);
|
|
|
+ handler(this, request, saveTaskForUpdatingRegistrantInfoByIdentityCredential(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::FailDemandOutcomeCallable DomainClient::failDemandCallable(const FailDemandRequest &request) const
|
|
|
+DomainClient::SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcomeCallable DomainClient::saveTaskForUpdatingRegistrantInfoByIdentityCredentialCallable(const SaveTaskForUpdatingRegistrantInfoByIdentityCredentialRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<FailDemandOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveTaskForUpdatingRegistrantInfoByIdentityCredentialOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->failDemand(request);
|
|
|
+ return this->saveTaskForUpdatingRegistrantInfoByIdentityCredential(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCancelingTransferInOutcome DomainClient::saveSingleTaskForCancelingTransferIn(const SaveSingleTaskForCancelingTransferInRequest &request) const
|
|
|
+DomainClient::DeleteDomainGroupOutcome DomainClient::deleteDomainGroup(const DeleteDomainGroupRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForCancelingTransferInOutcome(endpointOutcome.error());
|
|
|
+ return DeleteDomainGroupOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForCancelingTransferInOutcome(SaveSingleTaskForCancelingTransferInResult(outcome.result()));
|
|
|
+ return DeleteDomainGroupOutcome(DeleteDomainGroupResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForCancelingTransferInOutcome(outcome.error());
|
|
|
+ return DeleteDomainGroupOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForCancelingTransferInAsync(const SaveSingleTaskForCancelingTransferInRequest& request, const SaveSingleTaskForCancelingTransferInAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::deleteDomainGroupAsync(const DeleteDomainGroupRequest& request, const DeleteDomainGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForCancelingTransferIn(request), context);
|
|
|
+ handler(this, request, deleteDomainGroup(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCancelingTransferInOutcomeCallable DomainClient::saveSingleTaskForCancelingTransferInCallable(const SaveSingleTaskForCancelingTransferInRequest &request) const
|
|
|
+DomainClient::DeleteDomainGroupOutcomeCallable DomainClient::deleteDomainGroupCallable(const DeleteDomainGroupRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCancelingTransferInOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<DeleteDomainGroupOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForCancelingTransferIn(request);
|
|
|
+ return this->deleteDomainGroup(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCreatingOrderRenewOutcome DomainClient::saveSingleTaskForCreatingOrderRenew(const SaveSingleTaskForCreatingOrderRenewRequest &request) const
|
|
|
+DomainClient::QueryAuctionDetailOutcome DomainClient::queryAuctionDetail(const QueryAuctionDetailRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForCreatingOrderRenewOutcome(endpointOutcome.error());
|
|
|
+ return QueryAuctionDetailOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForCreatingOrderRenewOutcome(SaveSingleTaskForCreatingOrderRenewResult(outcome.result()));
|
|
|
+ return QueryAuctionDetailOutcome(QueryAuctionDetailResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForCreatingOrderRenewOutcome(outcome.error());
|
|
|
+ return QueryAuctionDetailOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForCreatingOrderRenewAsync(const SaveSingleTaskForCreatingOrderRenewRequest& request, const SaveSingleTaskForCreatingOrderRenewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryAuctionDetailAsync(const QueryAuctionDetailRequest& request, const QueryAuctionDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForCreatingOrderRenew(request), context);
|
|
|
+ handler(this, request, queryAuctionDetail(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCreatingOrderRenewOutcomeCallable DomainClient::saveSingleTaskForCreatingOrderRenewCallable(const SaveSingleTaskForCreatingOrderRenewRequest &request) const
|
|
|
+DomainClient::QueryAuctionDetailOutcomeCallable DomainClient::queryAuctionDetailCallable(const QueryAuctionDetailRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCreatingOrderRenewOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryAuctionDetailOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForCreatingOrderRenew(request);
|
|
|
+ return this->queryAuctionDetail(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::PollTaskResultOutcome DomainClient::pollTaskResult(const PollTaskResultRequest &request) const
|
|
|
+DomainClient::QueryDomainByInstanceIdOutcome DomainClient::queryDomainByInstanceId(const QueryDomainByInstanceIdRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return PollTaskResultOutcome(endpointOutcome.error());
|
|
|
+ return QueryDomainByInstanceIdOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return PollTaskResultOutcome(PollTaskResultResult(outcome.result()));
|
|
|
+ return QueryDomainByInstanceIdOutcome(QueryDomainByInstanceIdResult(outcome.result()));
|
|
|
else
|
|
|
- return PollTaskResultOutcome(outcome.error());
|
|
|
+ return QueryDomainByInstanceIdOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::pollTaskResultAsync(const PollTaskResultRequest& request, const PollTaskResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryDomainByInstanceIdAsync(const QueryDomainByInstanceIdRequest& request, const QueryDomainByInstanceIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, pollTaskResult(request), context);
|
|
|
+ handler(this, request, queryDomainByInstanceId(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::PollTaskResultOutcomeCallable DomainClient::pollTaskResultCallable(const PollTaskResultRequest &request) const
|
|
|
+DomainClient::QueryDomainByInstanceIdOutcomeCallable DomainClient::queryDomainByInstanceIdCallable(const QueryDomainByInstanceIdRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<PollTaskResultOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryDomainByInstanceIdOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->pollTaskResult(request);
|
|
|
+ return this->queryDomainByInstanceId(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::DeleteEmailVerificationOutcome DomainClient::deleteEmailVerification(const DeleteEmailVerificationRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForDeletingDnsHostOutcome DomainClient::saveSingleTaskForDeletingDnsHost(const SaveSingleTaskForDeletingDnsHostRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return DeleteEmailVerificationOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForDeletingDnsHostOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return DeleteEmailVerificationOutcome(DeleteEmailVerificationResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForDeletingDnsHostOutcome(SaveSingleTaskForDeletingDnsHostResult(outcome.result()));
|
|
|
else
|
|
|
- return DeleteEmailVerificationOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForDeletingDnsHostOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::deleteEmailVerificationAsync(const DeleteEmailVerificationRequest& request, const DeleteEmailVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForDeletingDnsHostAsync(const SaveSingleTaskForDeletingDnsHostRequest& request, const SaveSingleTaskForDeletingDnsHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, deleteEmailVerification(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForDeletingDnsHost(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::DeleteEmailVerificationOutcomeCallable DomainClient::deleteEmailVerificationCallable(const DeleteEmailVerificationRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForDeletingDnsHostOutcomeCallable DomainClient::saveSingleTaskForDeletingDnsHostCallable(const SaveSingleTaskForDeletingDnsHostRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<DeleteEmailVerificationOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForDeletingDnsHostOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->deleteEmailVerification(request);
|
|
|
+ return this->saveSingleTaskForDeletingDnsHost(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCreatingOrderActivateOutcome DomainClient::saveSingleTaskForCreatingOrderActivate(const SaveSingleTaskForCreatingOrderActivateRequest &request) const
|
|
|
+DomainClient::SaveBatchTaskForCreatingOrderRedeemOutcome DomainClient::saveBatchTaskForCreatingOrderRedeem(const SaveBatchTaskForCreatingOrderRedeemRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForCreatingOrderActivateOutcome(endpointOutcome.error());
|
|
|
+ return SaveBatchTaskForCreatingOrderRedeemOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForCreatingOrderActivateOutcome(SaveSingleTaskForCreatingOrderActivateResult(outcome.result()));
|
|
|
+ return SaveBatchTaskForCreatingOrderRedeemOutcome(SaveBatchTaskForCreatingOrderRedeemResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForCreatingOrderActivateOutcome(outcome.error());
|
|
|
+ return SaveBatchTaskForCreatingOrderRedeemOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForCreatingOrderActivateAsync(const SaveSingleTaskForCreatingOrderActivateRequest& request, const SaveSingleTaskForCreatingOrderActivateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveBatchTaskForCreatingOrderRedeemAsync(const SaveBatchTaskForCreatingOrderRedeemRequest& request, const SaveBatchTaskForCreatingOrderRedeemAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForCreatingOrderActivate(request), context);
|
|
|
+ handler(this, request, saveBatchTaskForCreatingOrderRedeem(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCreatingOrderActivateOutcomeCallable DomainClient::saveSingleTaskForCreatingOrderActivateCallable(const SaveSingleTaskForCreatingOrderActivateRequest &request) const
|
|
|
+DomainClient::SaveBatchTaskForCreatingOrderRedeemOutcomeCallable DomainClient::saveBatchTaskForCreatingOrderRedeemCallable(const SaveBatchTaskForCreatingOrderRedeemRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCreatingOrderActivateOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveBatchTaskForCreatingOrderRedeemOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForCreatingOrderActivate(request);
|
|
|
+ return this->saveBatchTaskForCreatingOrderRedeem(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForTransferProhibitionLockOutcome DomainClient::saveBatchTaskForTransferProhibitionLock(const SaveBatchTaskForTransferProhibitionLockRequest &request) const
|
|
|
+DomainClient::QueryTaskListOutcome DomainClient::queryTaskList(const QueryTaskListRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveBatchTaskForTransferProhibitionLockOutcome(endpointOutcome.error());
|
|
|
+ return QueryTaskListOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveBatchTaskForTransferProhibitionLockOutcome(SaveBatchTaskForTransferProhibitionLockResult(outcome.result()));
|
|
|
+ return QueryTaskListOutcome(QueryTaskListResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveBatchTaskForTransferProhibitionLockOutcome(outcome.error());
|
|
|
+ return QueryTaskListOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveBatchTaskForTransferProhibitionLockAsync(const SaveBatchTaskForTransferProhibitionLockRequest& request, const SaveBatchTaskForTransferProhibitionLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryTaskListAsync(const QueryTaskListRequest& request, const QueryTaskListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveBatchTaskForTransferProhibitionLock(request), context);
|
|
|
+ handler(this, request, queryTaskList(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForTransferProhibitionLockOutcomeCallable DomainClient::saveBatchTaskForTransferProhibitionLockCallable(const SaveBatchTaskForTransferProhibitionLockRequest &request) const
|
|
|
+DomainClient::QueryTaskListOutcomeCallable DomainClient::queryTaskListCallable(const QueryTaskListRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveBatchTaskForTransferProhibitionLockOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryTaskListOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveBatchTaskForTransferProhibitionLock(request);
|
|
|
+ return this->queryTaskList(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::RefuseDemandOutcome DomainClient::refuseDemand(const RefuseDemandRequest &request) const
|
|
|
+DomainClient::QueryRegistrantProfilesOutcome DomainClient::queryRegistrantProfiles(const QueryRegistrantProfilesRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return RefuseDemandOutcome(endpointOutcome.error());
|
|
|
+ return QueryRegistrantProfilesOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return RefuseDemandOutcome(RefuseDemandResult(outcome.result()));
|
|
|
+ return QueryRegistrantProfilesOutcome(QueryRegistrantProfilesResult(outcome.result()));
|
|
|
else
|
|
|
- return RefuseDemandOutcome(outcome.error());
|
|
|
+ return QueryRegistrantProfilesOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::refuseDemandAsync(const RefuseDemandRequest& request, const RefuseDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryRegistrantProfilesAsync(const QueryRegistrantProfilesRequest& request, const QueryRegistrantProfilesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, refuseDemand(request), context);
|
|
|
+ handler(this, request, queryRegistrantProfiles(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::RefuseDemandOutcomeCallable DomainClient::refuseDemandCallable(const RefuseDemandRequest &request) const
|
|
|
+DomainClient::QueryRegistrantProfilesOutcomeCallable DomainClient::queryRegistrantProfilesCallable(const QueryRegistrantProfilesRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<RefuseDemandOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryRegistrantProfilesOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->refuseDemand(request);
|
|
|
+ return this->queryRegistrantProfiles(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::TransferInReenterTransferAuthorizationCodeOutcome DomainClient::transferInReenterTransferAuthorizationCode(const TransferInReenterTransferAuthorizationCodeRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCreatingOrderRenewOutcome DomainClient::saveSingleTaskForCreatingOrderRenew(const SaveSingleTaskForCreatingOrderRenewRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return TransferInReenterTransferAuthorizationCodeOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForCreatingOrderRenewOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return TransferInReenterTransferAuthorizationCodeOutcome(TransferInReenterTransferAuthorizationCodeResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForCreatingOrderRenewOutcome(SaveSingleTaskForCreatingOrderRenewResult(outcome.result()));
|
|
|
else
|
|
|
- return TransferInReenterTransferAuthorizationCodeOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForCreatingOrderRenewOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::transferInReenterTransferAuthorizationCodeAsync(const TransferInReenterTransferAuthorizationCodeRequest& request, const TransferInReenterTransferAuthorizationCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForCreatingOrderRenewAsync(const SaveSingleTaskForCreatingOrderRenewRequest& request, const SaveSingleTaskForCreatingOrderRenewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, transferInReenterTransferAuthorizationCode(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForCreatingOrderRenew(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::TransferInReenterTransferAuthorizationCodeOutcomeCallable DomainClient::transferInReenterTransferAuthorizationCodeCallable(const TransferInReenterTransferAuthorizationCodeRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCreatingOrderRenewOutcomeCallable DomainClient::saveSingleTaskForCreatingOrderRenewCallable(const SaveSingleTaskForCreatingOrderRenewRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<TransferInReenterTransferAuthorizationCodeOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCreatingOrderRenewOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->transferInReenterTransferAuthorizationCode(request);
|
|
|
+ return this->saveSingleTaskForCreatingOrderRenew(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::EmailVerifiedOutcome DomainClient::emailVerified(const EmailVerifiedRequest &request) const
|
|
|
+DomainClient::PollTaskResultOutcome DomainClient::pollTaskResult(const PollTaskResultRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return EmailVerifiedOutcome(endpointOutcome.error());
|
|
|
+ return PollTaskResultOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return EmailVerifiedOutcome(EmailVerifiedResult(outcome.result()));
|
|
|
+ return PollTaskResultOutcome(PollTaskResultResult(outcome.result()));
|
|
|
else
|
|
|
- return EmailVerifiedOutcome(outcome.error());
|
|
|
+ return PollTaskResultOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::emailVerifiedAsync(const EmailVerifiedRequest& request, const EmailVerifiedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::pollTaskResultAsync(const PollTaskResultRequest& request, const PollTaskResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, emailVerified(request), context);
|
|
|
+ handler(this, request, pollTaskResult(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::EmailVerifiedOutcomeCallable DomainClient::emailVerifiedCallable(const EmailVerifiedRequest &request) const
|
|
|
+DomainClient::PollTaskResultOutcomeCallable DomainClient::pollTaskResultCallable(const PollTaskResultRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<EmailVerifiedOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<PollTaskResultOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->emailVerified(request);
|
|
|
+ return this->pollTaskResult(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForUpdateProhibitionLockOutcome DomainClient::saveBatchTaskForUpdateProhibitionLock(const SaveBatchTaskForUpdateProhibitionLockRequest &request) const
|
|
|
+DomainClient::DeleteEmailVerificationOutcome DomainClient::deleteEmailVerification(const DeleteEmailVerificationRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveBatchTaskForUpdateProhibitionLockOutcome(endpointOutcome.error());
|
|
|
+ return DeleteEmailVerificationOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveBatchTaskForUpdateProhibitionLockOutcome(SaveBatchTaskForUpdateProhibitionLockResult(outcome.result()));
|
|
|
+ return DeleteEmailVerificationOutcome(DeleteEmailVerificationResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveBatchTaskForUpdateProhibitionLockOutcome(outcome.error());
|
|
|
+ return DeleteEmailVerificationOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveBatchTaskForUpdateProhibitionLockAsync(const SaveBatchTaskForUpdateProhibitionLockRequest& request, const SaveBatchTaskForUpdateProhibitionLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::deleteEmailVerificationAsync(const DeleteEmailVerificationRequest& request, const DeleteEmailVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveBatchTaskForUpdateProhibitionLock(request), context);
|
|
|
+ handler(this, request, deleteEmailVerification(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForUpdateProhibitionLockOutcomeCallable DomainClient::saveBatchTaskForUpdateProhibitionLockCallable(const SaveBatchTaskForUpdateProhibitionLockRequest &request) const
|
|
|
+DomainClient::DeleteEmailVerificationOutcomeCallable DomainClient::deleteEmailVerificationCallable(const DeleteEmailVerificationRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveBatchTaskForUpdateProhibitionLockOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<DeleteEmailVerificationOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveBatchTaskForUpdateProhibitionLock(request);
|
|
|
+ return this->deleteEmailVerification(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCreatingDnsHostOutcome DomainClient::saveSingleTaskForCreatingDnsHost(const SaveSingleTaskForCreatingDnsHostRequest &request) const
|
|
|
+DomainClient::QueryDomainAdminDivisionOutcome DomainClient::queryDomainAdminDivision(const QueryDomainAdminDivisionRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForCreatingDnsHostOutcome(endpointOutcome.error());
|
|
|
+ return QueryDomainAdminDivisionOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForCreatingDnsHostOutcome(SaveSingleTaskForCreatingDnsHostResult(outcome.result()));
|
|
|
+ return QueryDomainAdminDivisionOutcome(QueryDomainAdminDivisionResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForCreatingDnsHostOutcome(outcome.error());
|
|
|
+ return QueryDomainAdminDivisionOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForCreatingDnsHostAsync(const SaveSingleTaskForCreatingDnsHostRequest& request, const SaveSingleTaskForCreatingDnsHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryDomainAdminDivisionAsync(const QueryDomainAdminDivisionRequest& request, const QueryDomainAdminDivisionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForCreatingDnsHost(request), context);
|
|
|
+ handler(this, request, queryDomainAdminDivision(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCreatingDnsHostOutcomeCallable DomainClient::saveSingleTaskForCreatingDnsHostCallable(const SaveSingleTaskForCreatingDnsHostRequest &request) const
|
|
|
+DomainClient::QueryDomainAdminDivisionOutcomeCallable DomainClient::queryDomainAdminDivisionCallable(const QueryDomainAdminDivisionRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCreatingDnsHostOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryDomainAdminDivisionOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForCreatingDnsHost(request);
|
|
|
+ return this->queryDomainAdminDivision(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryEmailVerificationOutcome DomainClient::queryEmailVerification(const QueryEmailVerificationRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCreatingOrderActivateOutcome DomainClient::saveSingleTaskForCreatingOrderActivate(const SaveSingleTaskForCreatingOrderActivateRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryEmailVerificationOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForCreatingOrderActivateOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryEmailVerificationOutcome(QueryEmailVerificationResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForCreatingOrderActivateOutcome(SaveSingleTaskForCreatingOrderActivateResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryEmailVerificationOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForCreatingOrderActivateOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryEmailVerificationAsync(const QueryEmailVerificationRequest& request, const QueryEmailVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForCreatingOrderActivateAsync(const SaveSingleTaskForCreatingOrderActivateRequest& request, const SaveSingleTaskForCreatingOrderActivateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryEmailVerification(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForCreatingOrderActivate(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryEmailVerificationOutcomeCallable DomainClient::queryEmailVerificationCallable(const QueryEmailVerificationRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCreatingOrderActivateOutcomeCallable DomainClient::saveSingleTaskForCreatingOrderActivateCallable(const SaveSingleTaskForCreatingOrderActivateRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryEmailVerificationOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCreatingOrderActivateOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryEmailVerification(request);
|
|
|
+ return this->saveSingleTaskForCreatingOrderActivate(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::DeleteRegistrantProfileOutcome DomainClient::deleteRegistrantProfile(const DeleteRegistrantProfileRequest &request) const
|
|
|
+DomainClient::RefuseDemandOutcome DomainClient::refuseDemand(const RefuseDemandRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return DeleteRegistrantProfileOutcome(endpointOutcome.error());
|
|
|
+ return RefuseDemandOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return DeleteRegistrantProfileOutcome(DeleteRegistrantProfileResult(outcome.result()));
|
|
|
+ return RefuseDemandOutcome(RefuseDemandResult(outcome.result()));
|
|
|
else
|
|
|
- return DeleteRegistrantProfileOutcome(outcome.error());
|
|
|
+ return RefuseDemandOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::deleteRegistrantProfileAsync(const DeleteRegistrantProfileRequest& request, const DeleteRegistrantProfileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::refuseDemandAsync(const RefuseDemandRequest& request, const RefuseDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, deleteRegistrantProfile(request), context);
|
|
|
+ handler(this, request, refuseDemand(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::DeleteRegistrantProfileOutcomeCallable DomainClient::deleteRegistrantProfileCallable(const DeleteRegistrantProfileRequest &request) const
|
|
|
+DomainClient::RefuseDemandOutcomeCallable DomainClient::refuseDemandCallable(const RefuseDemandRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<DeleteRegistrantProfileOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<RefuseDemandOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->deleteRegistrantProfile(request);
|
|
|
+ return this->refuseDemand(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryBrokerDemandRecordOutcome DomainClient::queryBrokerDemandRecord(const QueryBrokerDemandRecordRequest &request) const
|
|
|
+DomainClient::TransferInReenterTransferAuthorizationCodeOutcome DomainClient::transferInReenterTransferAuthorizationCode(const TransferInReenterTransferAuthorizationCodeRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryBrokerDemandRecordOutcome(endpointOutcome.error());
|
|
|
+ return TransferInReenterTransferAuthorizationCodeOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryBrokerDemandRecordOutcome(QueryBrokerDemandRecordResult(outcome.result()));
|
|
|
+ return TransferInReenterTransferAuthorizationCodeOutcome(TransferInReenterTransferAuthorizationCodeResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryBrokerDemandRecordOutcome(outcome.error());
|
|
|
+ return TransferInReenterTransferAuthorizationCodeOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryBrokerDemandRecordAsync(const QueryBrokerDemandRecordRequest& request, const QueryBrokerDemandRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::transferInReenterTransferAuthorizationCodeAsync(const TransferInReenterTransferAuthorizationCodeRequest& request, const TransferInReenterTransferAuthorizationCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryBrokerDemandRecord(request), context);
|
|
|
+ handler(this, request, transferInReenterTransferAuthorizationCode(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryBrokerDemandRecordOutcomeCallable DomainClient::queryBrokerDemandRecordCallable(const QueryBrokerDemandRecordRequest &request) const
|
|
|
+DomainClient::TransferInReenterTransferAuthorizationCodeOutcomeCallable DomainClient::transferInReenterTransferAuthorizationCodeCallable(const TransferInReenterTransferAuthorizationCodeRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryBrokerDemandRecordOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<TransferInReenterTransferAuthorizationCodeOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryBrokerDemandRecord(request);
|
|
|
+ return this->transferInReenterTransferAuthorizationCode(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTaskInfoHistoryOutcome DomainClient::queryTaskInfoHistory(const QueryTaskInfoHistoryRequest &request) const
|
|
|
+DomainClient::EmailVerifiedOutcome DomainClient::emailVerified(const EmailVerifiedRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryTaskInfoHistoryOutcome(endpointOutcome.error());
|
|
|
+ return EmailVerifiedOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryTaskInfoHistoryOutcome(QueryTaskInfoHistoryResult(outcome.result()));
|
|
|
+ return EmailVerifiedOutcome(EmailVerifiedResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryTaskInfoHistoryOutcome(outcome.error());
|
|
|
+ return EmailVerifiedOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryTaskInfoHistoryAsync(const QueryTaskInfoHistoryRequest& request, const QueryTaskInfoHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::emailVerifiedAsync(const EmailVerifiedRequest& request, const EmailVerifiedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryTaskInfoHistory(request), context);
|
|
|
+ handler(this, request, emailVerified(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryTaskInfoHistoryOutcomeCallable DomainClient::queryTaskInfoHistoryCallable(const QueryTaskInfoHistoryRequest &request) const
|
|
|
+DomainClient::EmailVerifiedOutcomeCallable DomainClient::emailVerifiedCallable(const EmailVerifiedRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryTaskInfoHistoryOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<EmailVerifiedOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryTaskInfoHistory(request);
|
|
|
+ return this->emailVerified(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCreatingOrderTransferOutcome DomainClient::saveSingleTaskForCreatingOrderTransfer(const SaveSingleTaskForCreatingOrderTransferRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCreatingDnsHostOutcome DomainClient::saveSingleTaskForCreatingDnsHost(const SaveSingleTaskForCreatingDnsHostRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveSingleTaskForCreatingOrderTransferOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForCreatingDnsHostOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveSingleTaskForCreatingOrderTransferOutcome(SaveSingleTaskForCreatingOrderTransferResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForCreatingDnsHostOutcome(SaveSingleTaskForCreatingDnsHostResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveSingleTaskForCreatingOrderTransferOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForCreatingDnsHostOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveSingleTaskForCreatingOrderTransferAsync(const SaveSingleTaskForCreatingOrderTransferRequest& request, const SaveSingleTaskForCreatingOrderTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForCreatingDnsHostAsync(const SaveSingleTaskForCreatingDnsHostRequest& request, const SaveSingleTaskForCreatingDnsHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveSingleTaskForCreatingOrderTransfer(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForCreatingDnsHost(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveSingleTaskForCreatingOrderTransferOutcomeCallable DomainClient::saveSingleTaskForCreatingOrderTransferCallable(const SaveSingleTaskForCreatingOrderTransferRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCreatingDnsHostOutcomeCallable DomainClient::saveSingleTaskForCreatingDnsHostCallable(const SaveSingleTaskForCreatingDnsHostRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCreatingOrderTransferOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCreatingDnsHostOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveSingleTaskForCreatingOrderTransfer(request);
|
|
|
+ return this->saveSingleTaskForCreatingDnsHost(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcome DomainClient::saveTaskForSubmittingDomainRealNameVerificationByIdentityCredential(const SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialRequest &request) const
|
|
|
+DomainClient::CheckProcessingServerLockApplyOutcome DomainClient::checkProcessingServerLockApply(const CheckProcessingServerLockApplyRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcome(endpointOutcome.error());
|
|
|
+ return CheckProcessingServerLockApplyOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcome(SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialResult(outcome.result()));
|
|
|
+ return CheckProcessingServerLockApplyOutcome(CheckProcessingServerLockApplyResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcome(outcome.error());
|
|
|
+ return CheckProcessingServerLockApplyOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialAsync(const SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialRequest& request, const SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::checkProcessingServerLockApplyAsync(const CheckProcessingServerLockApplyRequest& request, const CheckProcessingServerLockApplyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveTaskForSubmittingDomainRealNameVerificationByIdentityCredential(request), context);
|
|
|
+ handler(this, request, checkProcessingServerLockApply(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcomeCallable DomainClient::saveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialCallable(const SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialRequest &request) const
|
|
|
+DomainClient::CheckProcessingServerLockApplyOutcomeCallable DomainClient::checkProcessingServerLockApplyCallable(const CheckProcessingServerLockApplyRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveTaskForSubmittingDomainRealNameVerificationByIdentityCredentialOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<CheckProcessingServerLockApplyOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveTaskForSubmittingDomainRealNameVerificationByIdentityCredential(request);
|
|
|
+ return this->checkProcessingServerLockApply(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryFailReasonForRegistrantProfileRealNameVerificationOutcome DomainClient::queryFailReasonForRegistrantProfileRealNameVerification(const QueryFailReasonForRegistrantProfileRealNameVerificationRequest &request) const
|
|
|
+DomainClient::QueryTaskInfoHistoryOutcome DomainClient::queryTaskInfoHistory(const QueryTaskInfoHistoryRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return QueryFailReasonForRegistrantProfileRealNameVerificationOutcome(endpointOutcome.error());
|
|
|
+ return QueryTaskInfoHistoryOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return QueryFailReasonForRegistrantProfileRealNameVerificationOutcome(QueryFailReasonForRegistrantProfileRealNameVerificationResult(outcome.result()));
|
|
|
+ return QueryTaskInfoHistoryOutcome(QueryTaskInfoHistoryResult(outcome.result()));
|
|
|
else
|
|
|
- return QueryFailReasonForRegistrantProfileRealNameVerificationOutcome(outcome.error());
|
|
|
+ return QueryTaskInfoHistoryOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::queryFailReasonForRegistrantProfileRealNameVerificationAsync(const QueryFailReasonForRegistrantProfileRealNameVerificationRequest& request, const QueryFailReasonForRegistrantProfileRealNameVerificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::queryTaskInfoHistoryAsync(const QueryTaskInfoHistoryRequest& request, const QueryTaskInfoHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, queryFailReasonForRegistrantProfileRealNameVerification(request), context);
|
|
|
+ handler(this, request, queryTaskInfoHistory(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::QueryFailReasonForRegistrantProfileRealNameVerificationOutcomeCallable DomainClient::queryFailReasonForRegistrantProfileRealNameVerificationCallable(const QueryFailReasonForRegistrantProfileRealNameVerificationRequest &request) const
|
|
|
+DomainClient::QueryTaskInfoHistoryOutcomeCallable DomainClient::queryTaskInfoHistoryCallable(const QueryTaskInfoHistoryRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<QueryFailReasonForRegistrantProfileRealNameVerificationOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<QueryTaskInfoHistoryOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->queryFailReasonForRegistrantProfileRealNameVerification(request);
|
|
|
+ return this->queryTaskInfoHistory(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
|
return task->get_future();
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForCreatingOrderRenewOutcome DomainClient::saveBatchTaskForCreatingOrderRenew(const SaveBatchTaskForCreatingOrderRenewRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCreatingOrderTransferOutcome DomainClient::saveSingleTaskForCreatingOrderTransfer(const SaveSingleTaskForCreatingOrderTransferRequest &request) const
|
|
|
{
|
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
|
if (!endpointOutcome.isSuccess())
|
|
|
- return SaveBatchTaskForCreatingOrderRenewOutcome(endpointOutcome.error());
|
|
|
+ return SaveSingleTaskForCreatingOrderTransferOutcome(endpointOutcome.error());
|
|
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
|
|
if (outcome.isSuccess())
|
|
|
- return SaveBatchTaskForCreatingOrderRenewOutcome(SaveBatchTaskForCreatingOrderRenewResult(outcome.result()));
|
|
|
+ return SaveSingleTaskForCreatingOrderTransferOutcome(SaveSingleTaskForCreatingOrderTransferResult(outcome.result()));
|
|
|
else
|
|
|
- return SaveBatchTaskForCreatingOrderRenewOutcome(outcome.error());
|
|
|
+ return SaveSingleTaskForCreatingOrderTransferOutcome(outcome.error());
|
|
|
}
|
|
|
|
|
|
-void DomainClient::saveBatchTaskForCreatingOrderRenewAsync(const SaveBatchTaskForCreatingOrderRenewRequest& request, const SaveBatchTaskForCreatingOrderRenewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
+void DomainClient::saveSingleTaskForCreatingOrderTransferAsync(const SaveSingleTaskForCreatingOrderTransferRequest& request, const SaveSingleTaskForCreatingOrderTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
|
{
|
|
|
auto fn = [this, request, handler, context]()
|
|
|
{
|
|
|
- handler(this, request, saveBatchTaskForCreatingOrderRenew(request), context);
|
|
|
+ handler(this, request, saveSingleTaskForCreatingOrderTransfer(request), context);
|
|
|
};
|
|
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
|
}
|
|
|
|
|
|
-DomainClient::SaveBatchTaskForCreatingOrderRenewOutcomeCallable DomainClient::saveBatchTaskForCreatingOrderRenewCallable(const SaveBatchTaskForCreatingOrderRenewRequest &request) const
|
|
|
+DomainClient::SaveSingleTaskForCreatingOrderTransferOutcomeCallable DomainClient::saveSingleTaskForCreatingOrderTransferCallable(const SaveSingleTaskForCreatingOrderTransferRequest &request) const
|
|
|
{
|
|
|
- auto task = std::make_shared<std::packaged_task<SaveBatchTaskForCreatingOrderRenewOutcome()>>(
|
|
|
+ auto task = std::make_shared<std::packaged_task<SaveSingleTaskForCreatingOrderTransferOutcome()>>(
|
|
|
[this, request]()
|
|
|
{
|
|
|
- return this->saveBatchTaskForCreatingOrderRenew(request);
|
|
|
+ return this->saveSingleTaskForCreatingOrderTransfer(request);
|
|
|
});
|
|
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
yixiong.jxy