1242 lines
41 KiB
C++
1242 lines
41 KiB
C++
/*
|
|
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <alibabacloud/eds-user/Eds_userClient.h>
|
|
#include <alibabacloud/core/SimpleCredentialsProvider.h>
|
|
|
|
using namespace AlibabaCloud;
|
|
using namespace AlibabaCloud::Location;
|
|
using namespace AlibabaCloud::Eds_user;
|
|
using namespace AlibabaCloud::Eds_user::Model;
|
|
|
|
namespace
|
|
{
|
|
const std::string SERVICE_NAME = "eds-user";
|
|
}
|
|
|
|
Eds_userClient::Eds_userClient(const Credentials &credentials, const ClientConfiguration &configuration) :
|
|
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
|
|
{
|
|
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
|
|
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "eds-user");
|
|
}
|
|
|
|
Eds_userClient::Eds_userClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
|
|
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
|
|
{
|
|
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
|
|
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "eds-user");
|
|
}
|
|
|
|
Eds_userClient::Eds_userClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
|
|
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
|
|
{
|
|
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
|
|
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "eds-user");
|
|
}
|
|
|
|
Eds_userClient::~Eds_userClient()
|
|
{}
|
|
|
|
Eds_userClient::BatchSetDesktopManagerOutcome Eds_userClient::batchSetDesktopManager(const BatchSetDesktopManagerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return BatchSetDesktopManagerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return BatchSetDesktopManagerOutcome(BatchSetDesktopManagerResult(outcome.result()));
|
|
else
|
|
return BatchSetDesktopManagerOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::batchSetDesktopManagerAsync(const BatchSetDesktopManagerRequest& request, const BatchSetDesktopManagerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, batchSetDesktopManager(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::BatchSetDesktopManagerOutcomeCallable Eds_userClient::batchSetDesktopManagerCallable(const BatchSetDesktopManagerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<BatchSetDesktopManagerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->batchSetDesktopManager(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::ChangeUserPasswordOutcome Eds_userClient::changeUserPassword(const ChangeUserPasswordRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ChangeUserPasswordOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ChangeUserPasswordOutcome(ChangeUserPasswordResult(outcome.result()));
|
|
else
|
|
return ChangeUserPasswordOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::changeUserPasswordAsync(const ChangeUserPasswordRequest& request, const ChangeUserPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, changeUserPassword(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::ChangeUserPasswordOutcomeCallable Eds_userClient::changeUserPasswordCallable(const ChangeUserPasswordRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ChangeUserPasswordOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->changeUserPassword(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::CheckUsedPropertyOutcome Eds_userClient::checkUsedProperty(const CheckUsedPropertyRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CheckUsedPropertyOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CheckUsedPropertyOutcome(CheckUsedPropertyResult(outcome.result()));
|
|
else
|
|
return CheckUsedPropertyOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::checkUsedPropertyAsync(const CheckUsedPropertyRequest& request, const CheckUsedPropertyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, checkUsedProperty(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::CheckUsedPropertyOutcomeCallable Eds_userClient::checkUsedPropertyCallable(const CheckUsedPropertyRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CheckUsedPropertyOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->checkUsedProperty(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::CheckUsedPropertyValueOutcome Eds_userClient::checkUsedPropertyValue(const CheckUsedPropertyValueRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CheckUsedPropertyValueOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CheckUsedPropertyValueOutcome(CheckUsedPropertyValueResult(outcome.result()));
|
|
else
|
|
return CheckUsedPropertyValueOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::checkUsedPropertyValueAsync(const CheckUsedPropertyValueRequest& request, const CheckUsedPropertyValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, checkUsedPropertyValue(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::CheckUsedPropertyValueOutcomeCallable Eds_userClient::checkUsedPropertyValueCallable(const CheckUsedPropertyValueRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CheckUsedPropertyValueOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->checkUsedPropertyValue(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::CreateOrgOutcome Eds_userClient::createOrg(const CreateOrgRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateOrgOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateOrgOutcome(CreateOrgResult(outcome.result()));
|
|
else
|
|
return CreateOrgOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::createOrgAsync(const CreateOrgRequest& request, const CreateOrgAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createOrg(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::CreateOrgOutcomeCallable Eds_userClient::createOrgCallable(const CreateOrgRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateOrgOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createOrg(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::CreatePropertyOutcome Eds_userClient::createProperty(const CreatePropertyRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreatePropertyOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreatePropertyOutcome(CreatePropertyResult(outcome.result()));
|
|
else
|
|
return CreatePropertyOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::createPropertyAsync(const CreatePropertyRequest& request, const CreatePropertyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createProperty(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::CreatePropertyOutcomeCallable Eds_userClient::createPropertyCallable(const CreatePropertyRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreatePropertyOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createProperty(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::CreateUsersOutcome Eds_userClient::createUsers(const CreateUsersRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateUsersOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateUsersOutcome(CreateUsersResult(outcome.result()));
|
|
else
|
|
return CreateUsersOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::createUsersAsync(const CreateUsersRequest& request, const CreateUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createUsers(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::CreateUsersOutcomeCallable Eds_userClient::createUsersCallable(const CreateUsersRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateUsersOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createUsers(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::DeleteUserPropertyValueOutcome Eds_userClient::deleteUserPropertyValue(const DeleteUserPropertyValueRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteUserPropertyValueOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteUserPropertyValueOutcome(DeleteUserPropertyValueResult(outcome.result()));
|
|
else
|
|
return DeleteUserPropertyValueOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::deleteUserPropertyValueAsync(const DeleteUserPropertyValueRequest& request, const DeleteUserPropertyValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteUserPropertyValue(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::DeleteUserPropertyValueOutcomeCallable Eds_userClient::deleteUserPropertyValueCallable(const DeleteUserPropertyValueRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteUserPropertyValueOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteUserPropertyValue(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::DescribeMfaDevicesOutcome Eds_userClient::describeMfaDevices(const DescribeMfaDevicesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeMfaDevicesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeMfaDevicesOutcome(DescribeMfaDevicesResult(outcome.result()));
|
|
else
|
|
return DescribeMfaDevicesOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::describeMfaDevicesAsync(const DescribeMfaDevicesRequest& request, const DescribeMfaDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeMfaDevices(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::DescribeMfaDevicesOutcomeCallable Eds_userClient::describeMfaDevicesCallable(const DescribeMfaDevicesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeMfaDevicesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeMfaDevices(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::DescribeOrgByLayerOutcome Eds_userClient::describeOrgByLayer(const DescribeOrgByLayerRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOrgByLayerOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOrgByLayerOutcome(DescribeOrgByLayerResult(outcome.result()));
|
|
else
|
|
return DescribeOrgByLayerOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::describeOrgByLayerAsync(const DescribeOrgByLayerRequest& request, const DescribeOrgByLayerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOrgByLayer(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::DescribeOrgByLayerOutcomeCallable Eds_userClient::describeOrgByLayerCallable(const DescribeOrgByLayerRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOrgByLayerOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOrgByLayer(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::DescribeOrgsOutcome Eds_userClient::describeOrgs(const DescribeOrgsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOrgsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOrgsOutcome(DescribeOrgsResult(outcome.result()));
|
|
else
|
|
return DescribeOrgsOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::describeOrgsAsync(const DescribeOrgsRequest& request, const DescribeOrgsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOrgs(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::DescribeOrgsOutcomeCallable Eds_userClient::describeOrgsCallable(const DescribeOrgsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOrgsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOrgs(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::DescribeUsersOutcome Eds_userClient::describeUsers(const DescribeUsersRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeUsersOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeUsersOutcome(DescribeUsersResult(outcome.result()));
|
|
else
|
|
return DescribeUsersOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::describeUsersAsync(const DescribeUsersRequest& request, const DescribeUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeUsers(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::DescribeUsersOutcomeCallable Eds_userClient::describeUsersCallable(const DescribeUsersRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeUsersOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeUsers(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::FilterUsersOutcome Eds_userClient::filterUsers(const FilterUsersRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return FilterUsersOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return FilterUsersOutcome(FilterUsersResult(outcome.result()));
|
|
else
|
|
return FilterUsersOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::filterUsersAsync(const FilterUsersRequest& request, const FilterUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, filterUsers(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::FilterUsersOutcomeCallable Eds_userClient::filterUsersCallable(const FilterUsersRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<FilterUsersOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->filterUsers(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::GetManagerInfoByAuthCodeOutcome Eds_userClient::getManagerInfoByAuthCode(const GetManagerInfoByAuthCodeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetManagerInfoByAuthCodeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetManagerInfoByAuthCodeOutcome(GetManagerInfoByAuthCodeResult(outcome.result()));
|
|
else
|
|
return GetManagerInfoByAuthCodeOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::getManagerInfoByAuthCodeAsync(const GetManagerInfoByAuthCodeRequest& request, const GetManagerInfoByAuthCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getManagerInfoByAuthCode(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::GetManagerInfoByAuthCodeOutcomeCallable Eds_userClient::getManagerInfoByAuthCodeCallable(const GetManagerInfoByAuthCodeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetManagerInfoByAuthCodeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getManagerInfoByAuthCode(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::InitTenantAliasOutcome Eds_userClient::initTenantAlias(const InitTenantAliasRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return InitTenantAliasOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return InitTenantAliasOutcome(InitTenantAliasResult(outcome.result()));
|
|
else
|
|
return InitTenantAliasOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::initTenantAliasAsync(const InitTenantAliasRequest& request, const InitTenantAliasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, initTenantAlias(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::InitTenantAliasOutcomeCallable Eds_userClient::initTenantAliasCallable(const InitTenantAliasRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<InitTenantAliasOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->initTenantAlias(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::ListPropertyOutcome Eds_userClient::listProperty(const ListPropertyRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListPropertyOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListPropertyOutcome(ListPropertyResult(outcome.result()));
|
|
else
|
|
return ListPropertyOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::listPropertyAsync(const ListPropertyRequest& request, const ListPropertyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listProperty(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::ListPropertyOutcomeCallable Eds_userClient::listPropertyCallable(const ListPropertyRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListPropertyOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listProperty(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::ListPropertyValueOutcome Eds_userClient::listPropertyValue(const ListPropertyValueRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListPropertyValueOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListPropertyValueOutcome(ListPropertyValueResult(outcome.result()));
|
|
else
|
|
return ListPropertyValueOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::listPropertyValueAsync(const ListPropertyValueRequest& request, const ListPropertyValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listPropertyValue(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::ListPropertyValueOutcomeCallable Eds_userClient::listPropertyValueCallable(const ListPropertyValueRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListPropertyValueOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listPropertyValue(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::LockMfaDeviceOutcome Eds_userClient::lockMfaDevice(const LockMfaDeviceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return LockMfaDeviceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return LockMfaDeviceOutcome(LockMfaDeviceResult(outcome.result()));
|
|
else
|
|
return LockMfaDeviceOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::lockMfaDeviceAsync(const LockMfaDeviceRequest& request, const LockMfaDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, lockMfaDevice(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::LockMfaDeviceOutcomeCallable Eds_userClient::lockMfaDeviceCallable(const LockMfaDeviceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<LockMfaDeviceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->lockMfaDevice(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::LockUsersOutcome Eds_userClient::lockUsers(const LockUsersRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return LockUsersOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return LockUsersOutcome(LockUsersResult(outcome.result()));
|
|
else
|
|
return LockUsersOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::lockUsersAsync(const LockUsersRequest& request, const LockUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, lockUsers(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::LockUsersOutcomeCallable Eds_userClient::lockUsersCallable(const LockUsersRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<LockUsersOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->lockUsers(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::ModifyOrgOutcome Eds_userClient::modifyOrg(const ModifyOrgRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyOrgOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyOrgOutcome(ModifyOrgResult(outcome.result()));
|
|
else
|
|
return ModifyOrgOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::modifyOrgAsync(const ModifyOrgRequest& request, const ModifyOrgAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyOrg(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::ModifyOrgOutcomeCallable Eds_userClient::modifyOrgCallable(const ModifyOrgRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyOrgOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyOrg(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::ModifyUserOutcome Eds_userClient::modifyUser(const ModifyUserRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyUserOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyUserOutcome(ModifyUserResult(outcome.result()));
|
|
else
|
|
return ModifyUserOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::modifyUserAsync(const ModifyUserRequest& request, const ModifyUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyUser(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::ModifyUserOutcomeCallable Eds_userClient::modifyUserCallable(const ModifyUserRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyUserOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyUser(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::MoveOrgOutcome Eds_userClient::moveOrg(const MoveOrgRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return MoveOrgOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return MoveOrgOutcome(MoveOrgResult(outcome.result()));
|
|
else
|
|
return MoveOrgOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::moveOrgAsync(const MoveOrgRequest& request, const MoveOrgAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, moveOrg(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::MoveOrgOutcomeCallable Eds_userClient::moveOrgCallable(const MoveOrgRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<MoveOrgOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->moveOrg(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::QuerySyncStatusByAliUidOutcome Eds_userClient::querySyncStatusByAliUid(const QuerySyncStatusByAliUidRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return QuerySyncStatusByAliUidOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return QuerySyncStatusByAliUidOutcome(QuerySyncStatusByAliUidResult(outcome.result()));
|
|
else
|
|
return QuerySyncStatusByAliUidOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::querySyncStatusByAliUidAsync(const QuerySyncStatusByAliUidRequest& request, const QuerySyncStatusByAliUidAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, querySyncStatusByAliUid(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::QuerySyncStatusByAliUidOutcomeCallable Eds_userClient::querySyncStatusByAliUidCallable(const QuerySyncStatusByAliUidRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<QuerySyncStatusByAliUidOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->querySyncStatusByAliUid(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::RemoveMfaDeviceOutcome Eds_userClient::removeMfaDevice(const RemoveMfaDeviceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RemoveMfaDeviceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RemoveMfaDeviceOutcome(RemoveMfaDeviceResult(outcome.result()));
|
|
else
|
|
return RemoveMfaDeviceOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::removeMfaDeviceAsync(const RemoveMfaDeviceRequest& request, const RemoveMfaDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, removeMfaDevice(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::RemoveMfaDeviceOutcomeCallable Eds_userClient::removeMfaDeviceCallable(const RemoveMfaDeviceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RemoveMfaDeviceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->removeMfaDevice(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::RemoveOrgOutcome Eds_userClient::removeOrg(const RemoveOrgRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RemoveOrgOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RemoveOrgOutcome(RemoveOrgResult(outcome.result()));
|
|
else
|
|
return RemoveOrgOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::removeOrgAsync(const RemoveOrgRequest& request, const RemoveOrgAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, removeOrg(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::RemoveOrgOutcomeCallable Eds_userClient::removeOrgCallable(const RemoveOrgRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RemoveOrgOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->removeOrg(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::RemovePropertyOutcome Eds_userClient::removeProperty(const RemovePropertyRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RemovePropertyOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RemovePropertyOutcome(RemovePropertyResult(outcome.result()));
|
|
else
|
|
return RemovePropertyOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::removePropertyAsync(const RemovePropertyRequest& request, const RemovePropertyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, removeProperty(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::RemovePropertyOutcomeCallable Eds_userClient::removePropertyCallable(const RemovePropertyRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RemovePropertyOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->removeProperty(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::RemoveUsersOutcome Eds_userClient::removeUsers(const RemoveUsersRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RemoveUsersOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RemoveUsersOutcome(RemoveUsersResult(outcome.result()));
|
|
else
|
|
return RemoveUsersOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::removeUsersAsync(const RemoveUsersRequest& request, const RemoveUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, removeUsers(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::RemoveUsersOutcomeCallable Eds_userClient::removeUsersCallable(const RemoveUsersRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RemoveUsersOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->removeUsers(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::ResetUserPasswordOutcome Eds_userClient::resetUserPassword(const ResetUserPasswordRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ResetUserPasswordOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ResetUserPasswordOutcome(ResetUserPasswordResult(outcome.result()));
|
|
else
|
|
return ResetUserPasswordOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::resetUserPasswordAsync(const ResetUserPasswordRequest& request, const ResetUserPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, resetUserPassword(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::ResetUserPasswordOutcomeCallable Eds_userClient::resetUserPasswordCallable(const ResetUserPasswordRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ResetUserPasswordOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->resetUserPassword(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::SetUserPropertyValueOutcome Eds_userClient::setUserPropertyValue(const SetUserPropertyValueRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SetUserPropertyValueOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SetUserPropertyValueOutcome(SetUserPropertyValueResult(outcome.result()));
|
|
else
|
|
return SetUserPropertyValueOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::setUserPropertyValueAsync(const SetUserPropertyValueRequest& request, const SetUserPropertyValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, setUserPropertyValue(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::SetUserPropertyValueOutcomeCallable Eds_userClient::setUserPropertyValueCallable(const SetUserPropertyValueRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SetUserPropertyValueOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->setUserPropertyValue(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::SyncAllEduInfoOutcome Eds_userClient::syncAllEduInfo(const SyncAllEduInfoRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SyncAllEduInfoOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SyncAllEduInfoOutcome(SyncAllEduInfoResult(outcome.result()));
|
|
else
|
|
return SyncAllEduInfoOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::syncAllEduInfoAsync(const SyncAllEduInfoRequest& request, const SyncAllEduInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, syncAllEduInfo(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::SyncAllEduInfoOutcomeCallable Eds_userClient::syncAllEduInfoCallable(const SyncAllEduInfoRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SyncAllEduInfoOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->syncAllEduInfo(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::UnlockMfaDeviceOutcome Eds_userClient::unlockMfaDevice(const UnlockMfaDeviceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UnlockMfaDeviceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UnlockMfaDeviceOutcome(UnlockMfaDeviceResult(outcome.result()));
|
|
else
|
|
return UnlockMfaDeviceOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::unlockMfaDeviceAsync(const UnlockMfaDeviceRequest& request, const UnlockMfaDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, unlockMfaDevice(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::UnlockMfaDeviceOutcomeCallable Eds_userClient::unlockMfaDeviceCallable(const UnlockMfaDeviceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UnlockMfaDeviceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->unlockMfaDevice(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::UnlockUsersOutcome Eds_userClient::unlockUsers(const UnlockUsersRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UnlockUsersOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UnlockUsersOutcome(UnlockUsersResult(outcome.result()));
|
|
else
|
|
return UnlockUsersOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::unlockUsersAsync(const UnlockUsersRequest& request, const UnlockUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, unlockUsers(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::UnlockUsersOutcomeCallable Eds_userClient::unlockUsersCallable(const UnlockUsersRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UnlockUsersOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->unlockUsers(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
Eds_userClient::UpdatePropertyOutcome Eds_userClient::updateProperty(const UpdatePropertyRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdatePropertyOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdatePropertyOutcome(UpdatePropertyResult(outcome.result()));
|
|
else
|
|
return UpdatePropertyOutcome(outcome.error());
|
|
}
|
|
|
|
void Eds_userClient::updatePropertyAsync(const UpdatePropertyRequest& request, const UpdatePropertyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updateProperty(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
Eds_userClient::UpdatePropertyOutcomeCallable Eds_userClient::updatePropertyCallable(const UpdatePropertyRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdatePropertyOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updateProperty(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|