diff --git a/CHANGELOG b/CHANGELOG index 22dbf2e79..07706f204 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2022-05-19 Version: 1.36.1129 +- Support all language. + 2022-05-16 Version: 1.36.1128 - Add Api ListQualityCheckScheme. diff --git a/VERSION b/VERSION index fc28286ea..e5d389037 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1128 \ No newline at end of file +1.36.1129 \ No newline at end of file diff --git a/idaas-doraemon/CMakeLists.txt b/idaas-doraemon/CMakeLists.txt new file mode 100644 index 000000000..212b050e4 --- /dev/null +++ b/idaas-doraemon/CMakeLists.txt @@ -0,0 +1,142 @@ +# +# Copyright 2009-2017 Alibaba Cloud All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include) + +set(idaas-doraemon_public_header + include/alibabacloud/idaas-doraemon/Idaas_doraemonClient.h + include/alibabacloud/idaas-doraemon/Idaas_doraemonExport.h ) + +set(idaas-doraemon_public_header_model + include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationRequest.h + include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationResult.h + include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsRequest.h + include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsResult.h + include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorRequest.h + include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorResult.h + include/alibabacloud/idaas-doraemon/model/FetchAccessTokenRequest.h + include/alibabacloud/idaas-doraemon/model/FetchAccessTokenResult.h + include/alibabacloud/idaas-doraemon/model/GetAuthenticatorRequest.h + include/alibabacloud/idaas-doraemon/model/GetAuthenticatorResult.h + include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsRequest.h + include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsResult.h + include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsRequest.h + include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsResult.h + include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsRequest.h + include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsResult.h + include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsRequest.h + include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsResult.h + include/alibabacloud/idaas-doraemon/model/ListUsersRequest.h + include/alibabacloud/idaas-doraemon/model/ListUsersResult.h + include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorRequest.h + include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorResult.h + include/alibabacloud/idaas-doraemon/model/ServiceInvokeRequest.h + include/alibabacloud/idaas-doraemon/model/ServiceInvokeResult.h + include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeRequest.h + include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeResult.h + include/alibabacloud/idaas-doraemon/model/VerifyIdTokenRequest.h + include/alibabacloud/idaas-doraemon/model/VerifyIdTokenResult.h + include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationRequest.h + include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationResult.h ) + +set(idaas-doraemon_src + src/Idaas-doraemonClient.cc + src/model/CreateAuthenticatorRegistrationRequest.cc + src/model/CreateAuthenticatorRegistrationResult.cc + src/model/CreateUserAuthenticateOptionsRequest.cc + src/model/CreateUserAuthenticateOptionsResult.cc + src/model/DeregisterAuthenticatorRequest.cc + src/model/DeregisterAuthenticatorResult.cc + src/model/FetchAccessTokenRequest.cc + src/model/FetchAccessTokenResult.cc + src/model/GetAuthenticatorRequest.cc + src/model/GetAuthenticatorResult.cc + src/model/ListAuthenticationLogsRequest.cc + src/model/ListAuthenticationLogsResult.cc + src/model/ListAuthenticatorOpsLogsRequest.cc + src/model/ListAuthenticatorOpsLogsResult.cc + src/model/ListAuthenticatorsRequest.cc + src/model/ListAuthenticatorsResult.cc + src/model/ListPwnedPasswordsRequest.cc + src/model/ListPwnedPasswordsResult.cc + src/model/ListUsersRequest.cc + src/model/ListUsersResult.cc + src/model/RegisterAuthenticatorRequest.cc + src/model/RegisterAuthenticatorResult.cc + src/model/ServiceInvokeRequest.cc + src/model/ServiceInvokeResult.cc + src/model/UpdateAuthenticatorAttributeRequest.cc + src/model/UpdateAuthenticatorAttributeResult.cc + src/model/VerifyIdTokenRequest.cc + src/model/VerifyIdTokenResult.cc + src/model/VerifyUserAuthenticationRequest.cc + src/model/VerifyUserAuthenticationResult.cc ) + +add_library(idaas-doraemon ${LIB_TYPE} + ${idaas-doraemon_public_header} + ${idaas-doraemon_public_header_model} + ${idaas-doraemon_src}) + +set_target_properties(idaas-doraemon + PROPERTIES + LINKER_LANGUAGE CXX + ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin + OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}idaas-doraemon + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(idaas-doraemon + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_IDAAS_DORAEMON_LIBRARY) +endif() + +target_include_directories(idaas-doraemon + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(idaas-doraemon + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(idaas-doraemon + jsoncpp) + target_include_directories(idaas-doraemon + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(idaas-doraemon + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(idaas-doraemon + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(idaas-doraemon + PRIVATE /usr/include/jsoncpp) + target_link_libraries(idaas-doraemon + jsoncpp) +endif() + +install(FILES ${idaas-doraemon_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/idaas-doraemon) +install(FILES ${idaas-doraemon_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/idaas-doraemon/model) +install(TARGETS idaas-doraemon + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/Idaas_doraemonClient.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/Idaas_doraemonClient.h new file mode 100644 index 000000000..6c6b90d8f --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/Idaas_doraemonClient.h @@ -0,0 +1,166 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_IDAAS_DORAEMONCLIENT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_IDAAS_DORAEMONCLIENT_H_ + +#include +#include +#include +#include +#include "Idaas_doraemonExport.h" +#include "model/CreateAuthenticatorRegistrationRequest.h" +#include "model/CreateAuthenticatorRegistrationResult.h" +#include "model/CreateUserAuthenticateOptionsRequest.h" +#include "model/CreateUserAuthenticateOptionsResult.h" +#include "model/DeregisterAuthenticatorRequest.h" +#include "model/DeregisterAuthenticatorResult.h" +#include "model/FetchAccessTokenRequest.h" +#include "model/FetchAccessTokenResult.h" +#include "model/GetAuthenticatorRequest.h" +#include "model/GetAuthenticatorResult.h" +#include "model/ListAuthenticationLogsRequest.h" +#include "model/ListAuthenticationLogsResult.h" +#include "model/ListAuthenticatorOpsLogsRequest.h" +#include "model/ListAuthenticatorOpsLogsResult.h" +#include "model/ListAuthenticatorsRequest.h" +#include "model/ListAuthenticatorsResult.h" +#include "model/ListPwnedPasswordsRequest.h" +#include "model/ListPwnedPasswordsResult.h" +#include "model/ListUsersRequest.h" +#include "model/ListUsersResult.h" +#include "model/RegisterAuthenticatorRequest.h" +#include "model/RegisterAuthenticatorResult.h" +#include "model/ServiceInvokeRequest.h" +#include "model/ServiceInvokeResult.h" +#include "model/UpdateAuthenticatorAttributeRequest.h" +#include "model/UpdateAuthenticatorAttributeResult.h" +#include "model/VerifyIdTokenRequest.h" +#include "model/VerifyIdTokenResult.h" +#include "model/VerifyUserAuthenticationRequest.h" +#include "model/VerifyUserAuthenticationResult.h" + + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT Idaas_doraemonClient : public RpcServiceClient + { + public: + typedef Outcome CreateAuthenticatorRegistrationOutcome; + typedef std::future CreateAuthenticatorRegistrationOutcomeCallable; + typedef std::function&)> CreateAuthenticatorRegistrationAsyncHandler; + typedef Outcome CreateUserAuthenticateOptionsOutcome; + typedef std::future CreateUserAuthenticateOptionsOutcomeCallable; + typedef std::function&)> CreateUserAuthenticateOptionsAsyncHandler; + typedef Outcome DeregisterAuthenticatorOutcome; + typedef std::future DeregisterAuthenticatorOutcomeCallable; + typedef std::function&)> DeregisterAuthenticatorAsyncHandler; + typedef Outcome FetchAccessTokenOutcome; + typedef std::future FetchAccessTokenOutcomeCallable; + typedef std::function&)> FetchAccessTokenAsyncHandler; + typedef Outcome GetAuthenticatorOutcome; + typedef std::future GetAuthenticatorOutcomeCallable; + typedef std::function&)> GetAuthenticatorAsyncHandler; + typedef Outcome ListAuthenticationLogsOutcome; + typedef std::future ListAuthenticationLogsOutcomeCallable; + typedef std::function&)> ListAuthenticationLogsAsyncHandler; + typedef Outcome ListAuthenticatorOpsLogsOutcome; + typedef std::future ListAuthenticatorOpsLogsOutcomeCallable; + typedef std::function&)> ListAuthenticatorOpsLogsAsyncHandler; + typedef Outcome ListAuthenticatorsOutcome; + typedef std::future ListAuthenticatorsOutcomeCallable; + typedef std::function&)> ListAuthenticatorsAsyncHandler; + typedef Outcome ListPwnedPasswordsOutcome; + typedef std::future ListPwnedPasswordsOutcomeCallable; + typedef std::function&)> ListPwnedPasswordsAsyncHandler; + typedef Outcome ListUsersOutcome; + typedef std::future ListUsersOutcomeCallable; + typedef std::function&)> ListUsersAsyncHandler; + typedef Outcome RegisterAuthenticatorOutcome; + typedef std::future RegisterAuthenticatorOutcomeCallable; + typedef std::function&)> RegisterAuthenticatorAsyncHandler; + typedef Outcome ServiceInvokeOutcome; + typedef std::future ServiceInvokeOutcomeCallable; + typedef std::function&)> ServiceInvokeAsyncHandler; + typedef Outcome UpdateAuthenticatorAttributeOutcome; + typedef std::future UpdateAuthenticatorAttributeOutcomeCallable; + typedef std::function&)> UpdateAuthenticatorAttributeAsyncHandler; + typedef Outcome VerifyIdTokenOutcome; + typedef std::future VerifyIdTokenOutcomeCallable; + typedef std::function&)> VerifyIdTokenAsyncHandler; + typedef Outcome VerifyUserAuthenticationOutcome; + typedef std::future VerifyUserAuthenticationOutcomeCallable; + typedef std::function&)> VerifyUserAuthenticationAsyncHandler; + + Idaas_doraemonClient(const Credentials &credentials, const ClientConfiguration &configuration); + Idaas_doraemonClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + Idaas_doraemonClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~Idaas_doraemonClient(); + CreateAuthenticatorRegistrationOutcome createAuthenticatorRegistration(const Model::CreateAuthenticatorRegistrationRequest &request)const; + void createAuthenticatorRegistrationAsync(const Model::CreateAuthenticatorRegistrationRequest& request, const CreateAuthenticatorRegistrationAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateAuthenticatorRegistrationOutcomeCallable createAuthenticatorRegistrationCallable(const Model::CreateAuthenticatorRegistrationRequest& request) const; + CreateUserAuthenticateOptionsOutcome createUserAuthenticateOptions(const Model::CreateUserAuthenticateOptionsRequest &request)const; + void createUserAuthenticateOptionsAsync(const Model::CreateUserAuthenticateOptionsRequest& request, const CreateUserAuthenticateOptionsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateUserAuthenticateOptionsOutcomeCallable createUserAuthenticateOptionsCallable(const Model::CreateUserAuthenticateOptionsRequest& request) const; + DeregisterAuthenticatorOutcome deregisterAuthenticator(const Model::DeregisterAuthenticatorRequest &request)const; + void deregisterAuthenticatorAsync(const Model::DeregisterAuthenticatorRequest& request, const DeregisterAuthenticatorAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeregisterAuthenticatorOutcomeCallable deregisterAuthenticatorCallable(const Model::DeregisterAuthenticatorRequest& request) const; + FetchAccessTokenOutcome fetchAccessToken(const Model::FetchAccessTokenRequest &request)const; + void fetchAccessTokenAsync(const Model::FetchAccessTokenRequest& request, const FetchAccessTokenAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + FetchAccessTokenOutcomeCallable fetchAccessTokenCallable(const Model::FetchAccessTokenRequest& request) const; + GetAuthenticatorOutcome getAuthenticator(const Model::GetAuthenticatorRequest &request)const; + void getAuthenticatorAsync(const Model::GetAuthenticatorRequest& request, const GetAuthenticatorAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetAuthenticatorOutcomeCallable getAuthenticatorCallable(const Model::GetAuthenticatorRequest& request) const; + ListAuthenticationLogsOutcome listAuthenticationLogs(const Model::ListAuthenticationLogsRequest &request)const; + void listAuthenticationLogsAsync(const Model::ListAuthenticationLogsRequest& request, const ListAuthenticationLogsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAuthenticationLogsOutcomeCallable listAuthenticationLogsCallable(const Model::ListAuthenticationLogsRequest& request) const; + ListAuthenticatorOpsLogsOutcome listAuthenticatorOpsLogs(const Model::ListAuthenticatorOpsLogsRequest &request)const; + void listAuthenticatorOpsLogsAsync(const Model::ListAuthenticatorOpsLogsRequest& request, const ListAuthenticatorOpsLogsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAuthenticatorOpsLogsOutcomeCallable listAuthenticatorOpsLogsCallable(const Model::ListAuthenticatorOpsLogsRequest& request) const; + ListAuthenticatorsOutcome listAuthenticators(const Model::ListAuthenticatorsRequest &request)const; + void listAuthenticatorsAsync(const Model::ListAuthenticatorsRequest& request, const ListAuthenticatorsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAuthenticatorsOutcomeCallable listAuthenticatorsCallable(const Model::ListAuthenticatorsRequest& request) const; + ListPwnedPasswordsOutcome listPwnedPasswords(const Model::ListPwnedPasswordsRequest &request)const; + void listPwnedPasswordsAsync(const Model::ListPwnedPasswordsRequest& request, const ListPwnedPasswordsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListPwnedPasswordsOutcomeCallable listPwnedPasswordsCallable(const Model::ListPwnedPasswordsRequest& request) const; + ListUsersOutcome listUsers(const Model::ListUsersRequest &request)const; + void listUsersAsync(const Model::ListUsersRequest& request, const ListUsersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListUsersOutcomeCallable listUsersCallable(const Model::ListUsersRequest& request) const; + RegisterAuthenticatorOutcome registerAuthenticator(const Model::RegisterAuthenticatorRequest &request)const; + void registerAuthenticatorAsync(const Model::RegisterAuthenticatorRequest& request, const RegisterAuthenticatorAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RegisterAuthenticatorOutcomeCallable registerAuthenticatorCallable(const Model::RegisterAuthenticatorRequest& request) const; + ServiceInvokeOutcome serviceInvoke(const Model::ServiceInvokeRequest &request)const; + void serviceInvokeAsync(const Model::ServiceInvokeRequest& request, const ServiceInvokeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ServiceInvokeOutcomeCallable serviceInvokeCallable(const Model::ServiceInvokeRequest& request) const; + UpdateAuthenticatorAttributeOutcome updateAuthenticatorAttribute(const Model::UpdateAuthenticatorAttributeRequest &request)const; + void updateAuthenticatorAttributeAsync(const Model::UpdateAuthenticatorAttributeRequest& request, const UpdateAuthenticatorAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateAuthenticatorAttributeOutcomeCallable updateAuthenticatorAttributeCallable(const Model::UpdateAuthenticatorAttributeRequest& request) const; + VerifyIdTokenOutcome verifyIdToken(const Model::VerifyIdTokenRequest &request)const; + void verifyIdTokenAsync(const Model::VerifyIdTokenRequest& request, const VerifyIdTokenAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + VerifyIdTokenOutcomeCallable verifyIdTokenCallable(const Model::VerifyIdTokenRequest& request) const; + VerifyUserAuthenticationOutcome verifyUserAuthentication(const Model::VerifyUserAuthenticationRequest &request)const; + void verifyUserAuthenticationAsync(const Model::VerifyUserAuthenticationRequest& request, const VerifyUserAuthenticationAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + VerifyUserAuthenticationOutcomeCallable verifyUserAuthenticationCallable(const Model::VerifyUserAuthenticationRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_IDAAS_DORAEMONCLIENT_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/Idaas_doraemonExport.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/Idaas_doraemonExport.h new file mode 100644 index 000000000..58b6b32db --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/Idaas_doraemonExport.h @@ -0,0 +1,32 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_IDAAS_DORAEMONEXPORT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_IDAAS_DORAEMONEXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_IDAAS_DORAEMON_LIBRARY) +# define ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_IDAAS_DORAEMON_EXPORT +#endif + +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_IDAAS_DORAEMONEXPORT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationRequest.h new file mode 100644 index 000000000..2fca821ae --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationRequest.h @@ -0,0 +1,66 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT CreateAuthenticatorRegistrationRequest : public RpcServiceRequest { +public: + CreateAuthenticatorRegistrationRequest(); + ~CreateAuthenticatorRegistrationRequest(); + std::string getClientExtendParamsJson() const; + void setClientExtendParamsJson(const std::string &clientExtendParamsJson); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getUserDisplayName() const; + void setUserDisplayName(const std::string &userDisplayName); + std::string getServerExtendParamsJson() const; + void setServerExtendParamsJson(const std::string &serverExtendParamsJson); + std::string getRegistrationContext() const; + void setRegistrationContext(const std::string ®istrationContext); + std::string getAuthenticatorType() const; + void setAuthenticatorType(const std::string &authenticatorType); + std::string getClientExtendParamsJsonSign() const; + void setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + std::string getUserName() const; + void setUserName(const std::string &userName); + +private: + std::string clientExtendParamsJson_; + std::string userId_; + std::string userDisplayName_; + std::string serverExtendParamsJson_; + std::string registrationContext_; + std::string authenticatorType_; + std::string clientExtendParamsJsonSign_; + std::string applicationExternalId_; + std::string userName_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationResult.h new file mode 100644 index 000000000..f18c89b26 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT CreateAuthenticatorRegistrationResult : public ServiceResult + { + public: + + + CreateAuthenticatorRegistrationResult(); + explicit CreateAuthenticatorRegistrationResult(const std::string &payload); + ~CreateAuthenticatorRegistrationResult(); + std::string getOptions()const; + std::string getChallengeBase64()const; + + protected: + void parse(const std::string &payload); + private: + std::string options_; + std::string challengeBase64_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsRequest.h new file mode 100644 index 000000000..de671e732 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsRequest.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT CreateUserAuthenticateOptionsRequest : public RpcServiceRequest { +public: + CreateUserAuthenticateOptionsRequest(); + ~CreateUserAuthenticateOptionsRequest(); + std::string getClientExtendParamsJson() const; + void setClientExtendParamsJson(const std::string &clientExtendParamsJson); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getBindHashBase64() const; + void setBindHashBase64(const std::string &bindHashBase64); + std::string getServerExtendParamsJson() const; + void setServerExtendParamsJson(const std::string &serverExtendParamsJson); + std::string getAuthenticatorType() const; + void setAuthenticatorType(const std::string &authenticatorType); + std::string getClientExtendParamsJsonSign() const; + void setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string clientExtendParamsJson_; + std::string userId_; + std::string bindHashBase64_; + std::string serverExtendParamsJson_; + std::string authenticatorType_; + std::string clientExtendParamsJsonSign_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsResult.h new file mode 100644 index 000000000..68b88a83c --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT CreateUserAuthenticateOptionsResult : public ServiceResult + { + public: + + + CreateUserAuthenticateOptionsResult(); + explicit CreateUserAuthenticateOptionsResult(const std::string &payload); + ~CreateUserAuthenticateOptionsResult(); + std::string getOptions()const; + std::string getChallengeBase64()const; + + protected: + void parse(const std::string &payload); + private: + std::string options_; + std::string challengeBase64_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorRequest.h new file mode 100644 index 000000000..f0961ad91 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorRequest.h @@ -0,0 +1,48 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_DEREGISTERAUTHENTICATORREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_DEREGISTERAUTHENTICATORREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT DeregisterAuthenticatorRequest : public RpcServiceRequest { +public: + DeregisterAuthenticatorRequest(); + ~DeregisterAuthenticatorRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getAuthenticatorUuid() const; + void setAuthenticatorUuid(const std::string &authenticatorUuid); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string userId_; + std::string authenticatorUuid_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_DEREGISTERAUTHENTICATORREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorResult.h new file mode 100644 index 000000000..9ac0f875c --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_DEREGISTERAUTHENTICATORRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_DEREGISTERAUTHENTICATORRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT DeregisterAuthenticatorResult : public ServiceResult + { + public: + + + DeregisterAuthenticatorResult(); + explicit DeregisterAuthenticatorResult(const std::string &payload); + ~DeregisterAuthenticatorResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_DEREGISTERAUTHENTICATORRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/FetchAccessTokenRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/FetchAccessTokenRequest.h new file mode 100644 index 000000000..db02c74ef --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/FetchAccessTokenRequest.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT FetchAccessTokenRequest : public RpcServiceRequest { +public: + FetchAccessTokenRequest(); + ~FetchAccessTokenRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getXClientIp() const; + void setXClientIp(const std::string &xClientIp); + std::string getMobileExtendParamsJsonSign() const; + void setMobileExtendParamsJsonSign(const std::string &mobileExtendParamsJsonSign); + std::string getServerExtendParamsJson() const; + void setServerExtendParamsJson(const std::string &serverExtendParamsJson); + std::string getMobileExtendParamsJson() const; + void setMobileExtendParamsJson(const std::string &mobileExtendParamsJson); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string userId_; + std::string xClientIp_; + std::string mobileExtendParamsJsonSign_; + std::string serverExtendParamsJson_; + std::string mobileExtendParamsJson_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/FetchAccessTokenResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/FetchAccessTokenResult.h new file mode 100644 index 000000000..5f27425a2 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/FetchAccessTokenResult.h @@ -0,0 +1,66 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT FetchAccessTokenResult : public ServiceResult + { + public: + struct Data + { + std::string refresh_token; + std::string scope; + std::string access_token; + std::string id_token; + std::string token_type; + std::string expires_in; + }; + + + FetchAccessTokenResult(); + explicit FetchAccessTokenResult(const std::string &payload); + ~FetchAccessTokenResult(); + std::string getMessage()const; + Data getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/GetAuthenticatorRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/GetAuthenticatorRequest.h new file mode 100644 index 000000000..5883895d6 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/GetAuthenticatorRequest.h @@ -0,0 +1,48 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT GetAuthenticatorRequest : public RpcServiceRequest { +public: + GetAuthenticatorRequest(); + ~GetAuthenticatorRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getAuthenticatorUuid() const; + void setAuthenticatorUuid(const std::string &authenticatorUuid); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string userId_; + std::string authenticatorUuid_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/GetAuthenticatorResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/GetAuthenticatorResult.h new file mode 100644 index 000000000..2cc2ae978 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/GetAuthenticatorResult.h @@ -0,0 +1,64 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT GetAuthenticatorResult : public ServiceResult + { + public: + struct Authenticator + { + long registerTime; + std::string type; + std::string authenticatorUuid; + std::string registerSourceIp; + std::string credentialId; + long lastVerifyTime; + std::string authenticatorName; + std::string lastVerifySourceIp; + std::string customAuthenticator; + std::string lastVerifyUserAgent; + }; + + + GetAuthenticatorResult(); + explicit GetAuthenticatorResult(const std::string &payload); + ~GetAuthenticatorResult(); + Authenticator getAuthenticator()const; + + protected: + void parse(const std::string &payload); + private: + Authenticator authenticator_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsRequest.h new file mode 100644 index 000000000..9d10bdbdb --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsRequest.h @@ -0,0 +1,69 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticationLogsRequest : public RpcServiceRequest { +public: + ListAuthenticationLogsRequest(); + ~ListAuthenticationLogsRequest(); + long getToTime() const; + void setToTime(long toTime); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getLogTag() const; + void setLogTag(const std::string &logTag); + long getPageNumber() const; + void setPageNumber(long pageNumber); + long getPageSize() const; + void setPageSize(long pageSize); + std::string getCredentialId() const; + void setCredentialId(const std::string &credentialId); + long getFromTime() const; + void setFromTime(long fromTime); + std::string getAuthenticatorUuid() const; + void setAuthenticatorUuid(const std::string &authenticatorUuid); + std::string getAuthenticatorType() const; + void setAuthenticatorType(const std::string &authenticatorType); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + long toTime_; + std::string userId_; + std::string logTag_; + long pageNumber_; + long pageSize_; + std::string credentialId_; + long fromTime_; + std::string authenticatorUuid_; + std::string authenticatorType_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsResult.h new file mode 100644 index 000000000..25300741c --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsResult.h @@ -0,0 +1,80 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticationLogsResult : public ServiceResult + { + public: + struct AuthenticationLogContentItem + { + std::string authenticatorType; + std::string authenticatorUuid; + std::string credentialId; + std::string challengeBase64; + std::string rawAuthenticationContext; + long authenticationTime; + std::string applicationExternalId; + std::string logTag; + std::string logParams; + std::string applicationUuid; + std::string userSourceIp; + std::string tenantId; + std::string authenticationAction; + std::string userId; + std::string authenticatorName; + std::string userAgent; + std::string errorCode; + bool verifyResult; + std::string errorMessage; + std::string aliUid; + }; + + + ListAuthenticationLogsResult(); + explicit ListAuthenticationLogsResult(const std::string &payload); + ~ListAuthenticationLogsResult(); + long getTotalCount()const; + std::vector getAuthenticationLogContent()const; + long getPageSize()const; + long getPageNumber()const; + + protected: + void parse(const std::string &payload); + private: + long totalCount_; + std::vector authenticationLogContent_; + long pageSize_; + long pageNumber_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsRequest.h new file mode 100644 index 000000000..f589d92d6 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsRequest.h @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticatorOpsLogsRequest : public RpcServiceRequest { +public: + ListAuthenticatorOpsLogsRequest(); + ~ListAuthenticatorOpsLogsRequest(); + long getToTime() const; + void setToTime(long toTime); + std::string getUserId() const; + void setUserId(const std::string &userId); + long getPageNumber() const; + void setPageNumber(long pageNumber); + long getPageSize() const; + void setPageSize(long pageSize); + long getFromTime() const; + void setFromTime(long fromTime); + std::string getAuthenticatorUuid() const; + void setAuthenticatorUuid(const std::string &authenticatorUuid); + std::string getAuthenticatorType() const; + void setAuthenticatorType(const std::string &authenticatorType); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + long toTime_; + std::string userId_; + long pageNumber_; + long pageSize_; + long fromTime_; + std::string authenticatorUuid_; + std::string authenticatorType_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsResult.h new file mode 100644 index 000000000..ac6edc969 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsResult.h @@ -0,0 +1,79 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticatorOpsLogsResult : public ServiceResult + { + public: + struct AuthenticationLogContentItem + { + std::string authenticatorType; + std::string authenticatorUuid; + std::string credentialId; + std::string challengeBase64; + std::string rawContext; + std::string applicationExternalId; + bool operationResult; + std::string operationAction; + long operationTime; + std::string logParams; + std::string applicationUuid; + std::string userSourceIp; + std::string tenantId; + std::string userId; + std::string authenticatorName; + std::string userAgent; + std::string errorCode; + std::string errorMessage; + std::string aliUid; + }; + + + ListAuthenticatorOpsLogsResult(); + explicit ListAuthenticatorOpsLogsResult(const std::string &payload); + ~ListAuthenticatorOpsLogsResult(); + long getTotalCount()const; + std::vector getAuthenticationLogContent()const; + long getPageSize()const; + long getPageNumber()const; + + protected: + void parse(const std::string &payload); + private: + long totalCount_; + std::vector authenticationLogContent_; + long pageSize_; + long pageNumber_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsRequest.h new file mode 100644 index 000000000..9ca70bb89 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsRequest.h @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticatorsRequest : public RpcServiceRequest { +public: + ListAuthenticatorsRequest(); + ~ListAuthenticatorsRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + long getPageNumber() const; + void setPageNumber(long pageNumber); + long getPageSize() const; + void setPageSize(long pageSize); + std::string getAuthenticatorType() const; + void setAuthenticatorType(const std::string &authenticatorType); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string userId_; + long pageNumber_; + long pageSize_; + std::string authenticatorType_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsResult.h new file mode 100644 index 000000000..6e09a1c49 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsResult.h @@ -0,0 +1,67 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticatorsResult : public ServiceResult + { + public: + struct AuthenticatorListDTO + { + long registerTime; + std::string type; + std::string authenticatorUuid; + std::string credentialId; + long lastVerifyTime; + std::string authenticatorName; + std::string applicationExternalId; + }; + + + ListAuthenticatorsResult(); + explicit ListAuthenticatorsResult(const std::string &payload); + ~ListAuthenticatorsResult(); + long getTotalCount()const; + long getPageSize()const; + long getPageNumber()const; + std::vector getAuthenticator()const; + + protected: + void parse(const std::string &payload); + private: + long totalCount_; + long pageSize_; + long pageNumber_; + std::vector authenticator_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsRequest.h new file mode 100644 index 000000000..ec3e1158e --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsRequest.h @@ -0,0 +1,42 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListPwnedPasswordsRequest : public RpcServiceRequest { +public: + ListPwnedPasswordsRequest(); + ~ListPwnedPasswordsRequest(); + std::string getPrefixHexPasswordSha1Hash() const; + void setPrefixHexPasswordSha1Hash(const std::string &prefixHexPasswordSha1Hash); + +private: + std::string prefixHexPasswordSha1Hash_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsResult.h new file mode 100644 index 000000000..99b976e1c --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListPwnedPasswordsResult : public ServiceResult + { + public: + struct Items + { + std::string hexPasswordSha1Hash; + long pwnedCount; + }; + + + ListPwnedPasswordsResult(); + explicit ListPwnedPasswordsResult(const std::string &payload); + ~ListPwnedPasswordsResult(); + long getTotalCount()const; + long getPageSize()const; + long getPageNumber()const; + std::vector getPwnedPasswordInfos()const; + + protected: + void parse(const std::string &payload); + private: + long totalCount_; + long pageSize_; + long pageNumber_; + std::vector pwnedPasswordInfos_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListUsersRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListUsersRequest.h new file mode 100644 index 000000000..86aca4980 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListUsersRequest.h @@ -0,0 +1,45 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTUSERSREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTUSERSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListUsersRequest : public RpcServiceRequest { +public: + ListUsersRequest(); + ~ListUsersRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string userId_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTUSERSREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListUsersResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListUsersResult.h new file mode 100644 index 000000000..53b366109 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListUsersResult.h @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTUSERSRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTUSERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListUsersResult : public ServiceResult + { + public: + struct UsersItem + { + std::string userName; + std::string userId; + std::string userDisplayName; + }; + + + ListUsersResult(); + explicit ListUsersResult(const std::string &payload); + ~ListUsersResult(); + long getTotalCount()const; + std::vector getUsers()const; + + protected: + void parse(const std::string &payload); + private: + long totalCount_; + std::vector users_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTUSERSRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorRequest.h new file mode 100644 index 000000000..8a35dbf3a --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorRequest.h @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT RegisterAuthenticatorRequest : public RpcServiceRequest { +public: + RegisterAuthenticatorRequest(); + ~RegisterAuthenticatorRequest(); + std::string getLogParams() const; + void setLogParams(const std::string &logParams); + std::string getClientExtendParamsJson() const; + void setClientExtendParamsJson(const std::string &clientExtendParamsJson); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getServerExtendParamsJson() const; + void setServerExtendParamsJson(const std::string &serverExtendParamsJson); + std::string getRegistrationContext() const; + void setRegistrationContext(const std::string ®istrationContext); + std::string getAuthenticatorName() const; + void setAuthenticatorName(const std::string &authenticatorName); + std::string getRequireChallengeBase64() const; + void setRequireChallengeBase64(const std::string &requireChallengeBase64); + std::string getAuthenticatorType() const; + void setAuthenticatorType(const std::string &authenticatorType); + std::string getClientExtendParamsJsonSign() const; + void setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign); + std::string getUserSourceIp() const; + void setUserSourceIp(const std::string &userSourceIp); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string logParams_; + std::string clientExtendParamsJson_; + std::string userId_; + std::string serverExtendParamsJson_; + std::string registrationContext_; + std::string authenticatorName_; + std::string requireChallengeBase64_; + std::string authenticatorType_; + std::string clientExtendParamsJsonSign_; + std::string userSourceIp_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorResult.h new file mode 100644 index 000000000..21b94037b --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT RegisterAuthenticatorResult : public ServiceResult + { + public: + + + RegisterAuthenticatorResult(); + explicit RegisterAuthenticatorResult(const std::string &payload); + ~RegisterAuthenticatorResult(); + std::string getEtasResponseSting()const; + std::string getAuthenticatorUuid()const; + + protected: + void parse(const std::string &payload); + private: + std::string etasResponseSting_; + std::string authenticatorUuid_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ServiceInvokeRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ServiceInvokeRequest.h new file mode 100644 index 000000000..dc1ffda6c --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ServiceInvokeRequest.h @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_SERVICEINVOKEREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_SERVICEINVOKEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ServiceInvokeRequest : public RpcServiceRequest { +public: + ServiceInvokeRequest(); + ~ServiceInvokeRequest(); + std::string getXClientIp() const; + void setXClientIp(const std::string &xClientIp); + std::string getMobileExtendParamsJsonSign() const; + void setMobileExtendParamsJsonSign(const std::string &mobileExtendParamsJsonSign); + std::string getServerExtendParamsJson() const; + void setServerExtendParamsJson(const std::string &serverExtendParamsJson); + std::string getDoraemonAction() const; + void setDoraemonAction(const std::string &doraemonAction); + std::string getMobileExtendParamsJson() const; + void setMobileExtendParamsJson(const std::string &mobileExtendParamsJson); + std::string getServiceCode() const; + void setServiceCode(const std::string &serviceCode); + bool getTestModel() const; + void setTestModel(bool testModel); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string xClientIp_; + std::string mobileExtendParamsJsonSign_; + std::string serverExtendParamsJson_; + std::string doraemonAction_; + std::string mobileExtendParamsJson_; + std::string serviceCode_; + bool testModel_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_SERVICEINVOKEREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ServiceInvokeResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ServiceInvokeResult.h new file mode 100644 index 000000000..d6b708b03 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ServiceInvokeResult.h @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_SERVICEINVOKERESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_SERVICEINVOKERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ServiceInvokeResult : public ServiceResult + { + public: + + + ServiceInvokeResult(); + explicit ServiceInvokeResult(const std::string &payload); + ~ServiceInvokeResult(); + std::string getIdToken()const; + std::string getMessage()const; + std::string getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string idToken_; + std::string message_; + std::string data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_SERVICEINVOKERESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeRequest.h new file mode 100644 index 000000000..6b493b7d2 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_UPDATEAUTHENTICATORATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_UPDATEAUTHENTICATORATTRIBUTEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT UpdateAuthenticatorAttributeRequest : public RpcServiceRequest { +public: + UpdateAuthenticatorAttributeRequest(); + ~UpdateAuthenticatorAttributeRequest(); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getAuthenticatorName() const; + void setAuthenticatorName(const std::string &authenticatorName); + std::string getAuthenticatorUuid() const; + void setAuthenticatorUuid(const std::string &authenticatorUuid); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string userId_; + std::string authenticatorName_; + std::string authenticatorUuid_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_UPDATEAUTHENTICATORATTRIBUTEREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeResult.h new file mode 100644 index 000000000..4e8693bf2 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_UPDATEAUTHENTICATORATTRIBUTERESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_UPDATEAUTHENTICATORATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT UpdateAuthenticatorAttributeResult : public ServiceResult + { + public: + + + UpdateAuthenticatorAttributeResult(); + explicit UpdateAuthenticatorAttributeResult(const std::string &payload); + ~UpdateAuthenticatorAttributeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_UPDATEAUTHENTICATORATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyIdTokenRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyIdTokenRequest.h new file mode 100644 index 000000000..70a38c72f --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyIdTokenRequest.h @@ -0,0 +1,45 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT VerifyIdTokenRequest : public RpcServiceRequest { +public: + VerifyIdTokenRequest(); + ~VerifyIdTokenRequest(); + std::string getJwtIdToken() const; + void setJwtIdToken(const std::string &jwtIdToken); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string jwtIdToken_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyIdTokenResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyIdTokenResult.h new file mode 100644 index 000000000..e35ae33a0 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyIdTokenResult.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT VerifyIdTokenResult : public ServiceResult + { + public: + + + VerifyIdTokenResult(); + explicit VerifyIdTokenResult(const std::string &payload); + ~VerifyIdTokenResult(); + std::string getUserId()const; + + protected: + void parse(const std::string &payload); + private: + std::string userId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationRequest.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationRequest.h new file mode 100644 index 000000000..32b2da9e1 --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationRequest.h @@ -0,0 +1,75 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONREQUEST_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Idaas_doraemon { +namespace Model { +class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT VerifyUserAuthenticationRequest : public RpcServiceRequest { +public: + VerifyUserAuthenticationRequest(); + ~VerifyUserAuthenticationRequest(); + std::string getLogParams() const; + void setLogParams(const std::string &logParams); + std::string getClientExtendParamsJson() const; + void setClientExtendParamsJson(const std::string &clientExtendParamsJson); + std::string getUserId() const; + void setUserId(const std::string &userId); + std::string getLogTag() const; + void setLogTag(const std::string &logTag); + std::string getServerExtendParamsJson() const; + void setServerExtendParamsJson(const std::string &serverExtendParamsJson); + std::string getRequireBindHashBase64() const; + void setRequireBindHashBase64(const std::string &requireBindHashBase64); + std::string getAuthenticationContext() const; + void setAuthenticationContext(const std::string &authenticationContext); + std::string getRequireChallengeBase64() const; + void setRequireChallengeBase64(const std::string &requireChallengeBase64); + std::string getAuthenticatorType() const; + void setAuthenticatorType(const std::string &authenticatorType); + std::string getClientExtendParamsJsonSign() const; + void setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign); + std::string getUserSourceIp() const; + void setUserSourceIp(const std::string &userSourceIp); + std::string getApplicationExternalId() const; + void setApplicationExternalId(const std::string &applicationExternalId); + +private: + std::string logParams_; + std::string clientExtendParamsJson_; + std::string userId_; + std::string logTag_; + std::string serverExtendParamsJson_; + std::string requireBindHashBase64_; + std::string authenticationContext_; + std::string requireChallengeBase64_; + std::string authenticatorType_; + std::string clientExtendParamsJsonSign_; + std::string userSourceIp_; + std::string applicationExternalId_; +}; +} // namespace Model +} // namespace Idaas_doraemon +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONREQUEST_H_ diff --git a/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationResult.h b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationResult.h new file mode 100644 index 000000000..289c44fbb --- /dev/null +++ b/idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationResult.h @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONRESULT_H_ +#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Idaas_doraemon + { + namespace Model + { + class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT VerifyUserAuthenticationResult : public ServiceResult + { + public: + struct AuthenticateResultInfo + { + std::string bindHashBase64; + std::string credentialId; + std::string userId; + }; + + + VerifyUserAuthenticationResult(); + explicit VerifyUserAuthenticationResult(const std::string &payload); + ~VerifyUserAuthenticationResult(); + std::string getIdToken()const; + AuthenticateResultInfo getAuthenticateResultInfo()const; + std::string getEtasSDKString()const; + bool getVerifyResult()const; + + protected: + void parse(const std::string &payload); + private: + std::string idToken_; + AuthenticateResultInfo authenticateResultInfo_; + std::string etasSDKString_; + bool verifyResult_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONRESULT_H_ \ No newline at end of file diff --git a/idaas-doraemon/src/Idaas-doraemonClient.cc b/idaas-doraemon/src/Idaas-doraemonClient.cc new file mode 100644 index 000000000..45f392a3c --- /dev/null +++ b/idaas-doraemon/src/Idaas-doraemonClient.cc @@ -0,0 +1,593 @@ +/* + * 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 +#include + +using namespace AlibabaCloud; +using namespace AlibabaCloud::Location; +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +namespace +{ + const std::string SERVICE_NAME = "idaas-doraemon"; +} + +Idaas_doraemonClient::Idaas_doraemonClient(const Credentials &credentials, const ClientConfiguration &configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) +{ + auto locationClient = std::make_shared(credentials, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); +} + +Idaas_doraemonClient::Idaas_doraemonClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) +{ + auto locationClient = std::make_shared(credentialsProvider, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); +} + +Idaas_doraemonClient::Idaas_doraemonClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) +{ + auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); +} + +Idaas_doraemonClient::~Idaas_doraemonClient() +{} + +Idaas_doraemonClient::CreateAuthenticatorRegistrationOutcome Idaas_doraemonClient::createAuthenticatorRegistration(const CreateAuthenticatorRegistrationRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateAuthenticatorRegistrationOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateAuthenticatorRegistrationOutcome(CreateAuthenticatorRegistrationResult(outcome.result())); + else + return CreateAuthenticatorRegistrationOutcome(outcome.error()); +} + +void Idaas_doraemonClient::createAuthenticatorRegistrationAsync(const CreateAuthenticatorRegistrationRequest& request, const CreateAuthenticatorRegistrationAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createAuthenticatorRegistration(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::CreateAuthenticatorRegistrationOutcomeCallable Idaas_doraemonClient::createAuthenticatorRegistrationCallable(const CreateAuthenticatorRegistrationRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createAuthenticatorRegistration(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::CreateUserAuthenticateOptionsOutcome Idaas_doraemonClient::createUserAuthenticateOptions(const CreateUserAuthenticateOptionsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateUserAuthenticateOptionsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateUserAuthenticateOptionsOutcome(CreateUserAuthenticateOptionsResult(outcome.result())); + else + return CreateUserAuthenticateOptionsOutcome(outcome.error()); +} + +void Idaas_doraemonClient::createUserAuthenticateOptionsAsync(const CreateUserAuthenticateOptionsRequest& request, const CreateUserAuthenticateOptionsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createUserAuthenticateOptions(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::CreateUserAuthenticateOptionsOutcomeCallable Idaas_doraemonClient::createUserAuthenticateOptionsCallable(const CreateUserAuthenticateOptionsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createUserAuthenticateOptions(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::DeregisterAuthenticatorOutcome Idaas_doraemonClient::deregisterAuthenticator(const DeregisterAuthenticatorRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeregisterAuthenticatorOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeregisterAuthenticatorOutcome(DeregisterAuthenticatorResult(outcome.result())); + else + return DeregisterAuthenticatorOutcome(outcome.error()); +} + +void Idaas_doraemonClient::deregisterAuthenticatorAsync(const DeregisterAuthenticatorRequest& request, const DeregisterAuthenticatorAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deregisterAuthenticator(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::DeregisterAuthenticatorOutcomeCallable Idaas_doraemonClient::deregisterAuthenticatorCallable(const DeregisterAuthenticatorRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deregisterAuthenticator(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::FetchAccessTokenOutcome Idaas_doraemonClient::fetchAccessToken(const FetchAccessTokenRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return FetchAccessTokenOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return FetchAccessTokenOutcome(FetchAccessTokenResult(outcome.result())); + else + return FetchAccessTokenOutcome(outcome.error()); +} + +void Idaas_doraemonClient::fetchAccessTokenAsync(const FetchAccessTokenRequest& request, const FetchAccessTokenAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, fetchAccessToken(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::FetchAccessTokenOutcomeCallable Idaas_doraemonClient::fetchAccessTokenCallable(const FetchAccessTokenRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->fetchAccessToken(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::GetAuthenticatorOutcome Idaas_doraemonClient::getAuthenticator(const GetAuthenticatorRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetAuthenticatorOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetAuthenticatorOutcome(GetAuthenticatorResult(outcome.result())); + else + return GetAuthenticatorOutcome(outcome.error()); +} + +void Idaas_doraemonClient::getAuthenticatorAsync(const GetAuthenticatorRequest& request, const GetAuthenticatorAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getAuthenticator(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::GetAuthenticatorOutcomeCallable Idaas_doraemonClient::getAuthenticatorCallable(const GetAuthenticatorRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getAuthenticator(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::ListAuthenticationLogsOutcome Idaas_doraemonClient::listAuthenticationLogs(const ListAuthenticationLogsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAuthenticationLogsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAuthenticationLogsOutcome(ListAuthenticationLogsResult(outcome.result())); + else + return ListAuthenticationLogsOutcome(outcome.error()); +} + +void Idaas_doraemonClient::listAuthenticationLogsAsync(const ListAuthenticationLogsRequest& request, const ListAuthenticationLogsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAuthenticationLogs(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::ListAuthenticationLogsOutcomeCallable Idaas_doraemonClient::listAuthenticationLogsCallable(const ListAuthenticationLogsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAuthenticationLogs(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::ListAuthenticatorOpsLogsOutcome Idaas_doraemonClient::listAuthenticatorOpsLogs(const ListAuthenticatorOpsLogsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAuthenticatorOpsLogsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAuthenticatorOpsLogsOutcome(ListAuthenticatorOpsLogsResult(outcome.result())); + else + return ListAuthenticatorOpsLogsOutcome(outcome.error()); +} + +void Idaas_doraemonClient::listAuthenticatorOpsLogsAsync(const ListAuthenticatorOpsLogsRequest& request, const ListAuthenticatorOpsLogsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAuthenticatorOpsLogs(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::ListAuthenticatorOpsLogsOutcomeCallable Idaas_doraemonClient::listAuthenticatorOpsLogsCallable(const ListAuthenticatorOpsLogsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAuthenticatorOpsLogs(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::ListAuthenticatorsOutcome Idaas_doraemonClient::listAuthenticators(const ListAuthenticatorsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAuthenticatorsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAuthenticatorsOutcome(ListAuthenticatorsResult(outcome.result())); + else + return ListAuthenticatorsOutcome(outcome.error()); +} + +void Idaas_doraemonClient::listAuthenticatorsAsync(const ListAuthenticatorsRequest& request, const ListAuthenticatorsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAuthenticators(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::ListAuthenticatorsOutcomeCallable Idaas_doraemonClient::listAuthenticatorsCallable(const ListAuthenticatorsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAuthenticators(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::ListPwnedPasswordsOutcome Idaas_doraemonClient::listPwnedPasswords(const ListPwnedPasswordsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListPwnedPasswordsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListPwnedPasswordsOutcome(ListPwnedPasswordsResult(outcome.result())); + else + return ListPwnedPasswordsOutcome(outcome.error()); +} + +void Idaas_doraemonClient::listPwnedPasswordsAsync(const ListPwnedPasswordsRequest& request, const ListPwnedPasswordsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listPwnedPasswords(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::ListPwnedPasswordsOutcomeCallable Idaas_doraemonClient::listPwnedPasswordsCallable(const ListPwnedPasswordsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listPwnedPasswords(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::ListUsersOutcome Idaas_doraemonClient::listUsers(const ListUsersRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListUsersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListUsersOutcome(ListUsersResult(outcome.result())); + else + return ListUsersOutcome(outcome.error()); +} + +void Idaas_doraemonClient::listUsersAsync(const ListUsersRequest& request, const ListUsersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listUsers(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::ListUsersOutcomeCallable Idaas_doraemonClient::listUsersCallable(const ListUsersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listUsers(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::RegisterAuthenticatorOutcome Idaas_doraemonClient::registerAuthenticator(const RegisterAuthenticatorRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RegisterAuthenticatorOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RegisterAuthenticatorOutcome(RegisterAuthenticatorResult(outcome.result())); + else + return RegisterAuthenticatorOutcome(outcome.error()); +} + +void Idaas_doraemonClient::registerAuthenticatorAsync(const RegisterAuthenticatorRequest& request, const RegisterAuthenticatorAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, registerAuthenticator(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::RegisterAuthenticatorOutcomeCallable Idaas_doraemonClient::registerAuthenticatorCallable(const RegisterAuthenticatorRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->registerAuthenticator(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::ServiceInvokeOutcome Idaas_doraemonClient::serviceInvoke(const ServiceInvokeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ServiceInvokeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ServiceInvokeOutcome(ServiceInvokeResult(outcome.result())); + else + return ServiceInvokeOutcome(outcome.error()); +} + +void Idaas_doraemonClient::serviceInvokeAsync(const ServiceInvokeRequest& request, const ServiceInvokeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, serviceInvoke(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::ServiceInvokeOutcomeCallable Idaas_doraemonClient::serviceInvokeCallable(const ServiceInvokeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->serviceInvoke(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::UpdateAuthenticatorAttributeOutcome Idaas_doraemonClient::updateAuthenticatorAttribute(const UpdateAuthenticatorAttributeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateAuthenticatorAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateAuthenticatorAttributeOutcome(UpdateAuthenticatorAttributeResult(outcome.result())); + else + return UpdateAuthenticatorAttributeOutcome(outcome.error()); +} + +void Idaas_doraemonClient::updateAuthenticatorAttributeAsync(const UpdateAuthenticatorAttributeRequest& request, const UpdateAuthenticatorAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateAuthenticatorAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::UpdateAuthenticatorAttributeOutcomeCallable Idaas_doraemonClient::updateAuthenticatorAttributeCallable(const UpdateAuthenticatorAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateAuthenticatorAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::VerifyIdTokenOutcome Idaas_doraemonClient::verifyIdToken(const VerifyIdTokenRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return VerifyIdTokenOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return VerifyIdTokenOutcome(VerifyIdTokenResult(outcome.result())); + else + return VerifyIdTokenOutcome(outcome.error()); +} + +void Idaas_doraemonClient::verifyIdTokenAsync(const VerifyIdTokenRequest& request, const VerifyIdTokenAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, verifyIdToken(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::VerifyIdTokenOutcomeCallable Idaas_doraemonClient::verifyIdTokenCallable(const VerifyIdTokenRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->verifyIdToken(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Idaas_doraemonClient::VerifyUserAuthenticationOutcome Idaas_doraemonClient::verifyUserAuthentication(const VerifyUserAuthenticationRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return VerifyUserAuthenticationOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return VerifyUserAuthenticationOutcome(VerifyUserAuthenticationResult(outcome.result())); + else + return VerifyUserAuthenticationOutcome(outcome.error()); +} + +void Idaas_doraemonClient::verifyUserAuthenticationAsync(const VerifyUserAuthenticationRequest& request, const VerifyUserAuthenticationAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, verifyUserAuthentication(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Idaas_doraemonClient::VerifyUserAuthenticationOutcomeCallable Idaas_doraemonClient::verifyUserAuthenticationCallable(const VerifyUserAuthenticationRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->verifyUserAuthentication(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/idaas-doraemon/src/model/CreateAuthenticatorRegistrationRequest.cc b/idaas-doraemon/src/model/CreateAuthenticatorRegistrationRequest.cc new file mode 100644 index 000000000..3d8629769 --- /dev/null +++ b/idaas-doraemon/src/model/CreateAuthenticatorRegistrationRequest.cc @@ -0,0 +1,108 @@ +/* + * 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 + +using AlibabaCloud::Idaas_doraemon::Model::CreateAuthenticatorRegistrationRequest; + +CreateAuthenticatorRegistrationRequest::CreateAuthenticatorRegistrationRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "CreateAuthenticatorRegistration") { + setMethod(HttpRequest::Method::Post); +} + +CreateAuthenticatorRegistrationRequest::~CreateAuthenticatorRegistrationRequest() {} + +std::string CreateAuthenticatorRegistrationRequest::getClientExtendParamsJson() const { + return clientExtendParamsJson_; +} + +void CreateAuthenticatorRegistrationRequest::setClientExtendParamsJson(const std::string &clientExtendParamsJson) { + clientExtendParamsJson_ = clientExtendParamsJson; + setParameter(std::string("ClientExtendParamsJson"), clientExtendParamsJson); +} + +std::string CreateAuthenticatorRegistrationRequest::getUserId() const { + return userId_; +} + +void CreateAuthenticatorRegistrationRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string CreateAuthenticatorRegistrationRequest::getUserDisplayName() const { + return userDisplayName_; +} + +void CreateAuthenticatorRegistrationRequest::setUserDisplayName(const std::string &userDisplayName) { + userDisplayName_ = userDisplayName; + setParameter(std::string("UserDisplayName"), userDisplayName); +} + +std::string CreateAuthenticatorRegistrationRequest::getServerExtendParamsJson() const { + return serverExtendParamsJson_; +} + +void CreateAuthenticatorRegistrationRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) { + serverExtendParamsJson_ = serverExtendParamsJson; + setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson); +} + +std::string CreateAuthenticatorRegistrationRequest::getRegistrationContext() const { + return registrationContext_; +} + +void CreateAuthenticatorRegistrationRequest::setRegistrationContext(const std::string ®istrationContext) { + registrationContext_ = registrationContext; + setParameter(std::string("RegistrationContext"), registrationContext); +} + +std::string CreateAuthenticatorRegistrationRequest::getAuthenticatorType() const { + return authenticatorType_; +} + +void CreateAuthenticatorRegistrationRequest::setAuthenticatorType(const std::string &authenticatorType) { + authenticatorType_ = authenticatorType; + setParameter(std::string("AuthenticatorType"), authenticatorType); +} + +std::string CreateAuthenticatorRegistrationRequest::getClientExtendParamsJsonSign() const { + return clientExtendParamsJsonSign_; +} + +void CreateAuthenticatorRegistrationRequest::setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign) { + clientExtendParamsJsonSign_ = clientExtendParamsJsonSign; + setParameter(std::string("ClientExtendParamsJsonSign"), clientExtendParamsJsonSign); +} + +std::string CreateAuthenticatorRegistrationRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void CreateAuthenticatorRegistrationRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + +std::string CreateAuthenticatorRegistrationRequest::getUserName() const { + return userName_; +} + +void CreateAuthenticatorRegistrationRequest::setUserName(const std::string &userName) { + userName_ = userName; + setParameter(std::string("UserName"), userName); +} + diff --git a/idaas-doraemon/src/model/CreateAuthenticatorRegistrationResult.cc b/idaas-doraemon/src/model/CreateAuthenticatorRegistrationResult.cc new file mode 100644 index 000000000..7a82b79a2 --- /dev/null +++ b/idaas-doraemon/src/model/CreateAuthenticatorRegistrationResult.cc @@ -0,0 +1,58 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +CreateAuthenticatorRegistrationResult::CreateAuthenticatorRegistrationResult() : + ServiceResult() +{} + +CreateAuthenticatorRegistrationResult::CreateAuthenticatorRegistrationResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateAuthenticatorRegistrationResult::~CreateAuthenticatorRegistrationResult() +{} + +void CreateAuthenticatorRegistrationResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ChallengeBase64"].isNull()) + challengeBase64_ = value["ChallengeBase64"].asString(); + if(!value["Options"].isNull()) + options_ = value["Options"].asString(); + +} + +std::string CreateAuthenticatorRegistrationResult::getOptions()const +{ + return options_; +} + +std::string CreateAuthenticatorRegistrationResult::getChallengeBase64()const +{ + return challengeBase64_; +} + diff --git a/idaas-doraemon/src/model/CreateUserAuthenticateOptionsRequest.cc b/idaas-doraemon/src/model/CreateUserAuthenticateOptionsRequest.cc new file mode 100644 index 000000000..93b3ef97d --- /dev/null +++ b/idaas-doraemon/src/model/CreateUserAuthenticateOptionsRequest.cc @@ -0,0 +1,90 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Idaas_doraemon::Model::CreateUserAuthenticateOptionsRequest; + +CreateUserAuthenticateOptionsRequest::CreateUserAuthenticateOptionsRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "CreateUserAuthenticateOptions") { + setMethod(HttpRequest::Method::Post); +} + +CreateUserAuthenticateOptionsRequest::~CreateUserAuthenticateOptionsRequest() {} + +std::string CreateUserAuthenticateOptionsRequest::getClientExtendParamsJson() const { + return clientExtendParamsJson_; +} + +void CreateUserAuthenticateOptionsRequest::setClientExtendParamsJson(const std::string &clientExtendParamsJson) { + clientExtendParamsJson_ = clientExtendParamsJson; + setParameter(std::string("ClientExtendParamsJson"), clientExtendParamsJson); +} + +std::string CreateUserAuthenticateOptionsRequest::getUserId() const { + return userId_; +} + +void CreateUserAuthenticateOptionsRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string CreateUserAuthenticateOptionsRequest::getBindHashBase64() const { + return bindHashBase64_; +} + +void CreateUserAuthenticateOptionsRequest::setBindHashBase64(const std::string &bindHashBase64) { + bindHashBase64_ = bindHashBase64; + setParameter(std::string("BindHashBase64"), bindHashBase64); +} + +std::string CreateUserAuthenticateOptionsRequest::getServerExtendParamsJson() const { + return serverExtendParamsJson_; +} + +void CreateUserAuthenticateOptionsRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) { + serverExtendParamsJson_ = serverExtendParamsJson; + setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson); +} + +std::string CreateUserAuthenticateOptionsRequest::getAuthenticatorType() const { + return authenticatorType_; +} + +void CreateUserAuthenticateOptionsRequest::setAuthenticatorType(const std::string &authenticatorType) { + authenticatorType_ = authenticatorType; + setParameter(std::string("AuthenticatorType"), authenticatorType); +} + +std::string CreateUserAuthenticateOptionsRequest::getClientExtendParamsJsonSign() const { + return clientExtendParamsJsonSign_; +} + +void CreateUserAuthenticateOptionsRequest::setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign) { + clientExtendParamsJsonSign_ = clientExtendParamsJsonSign; + setParameter(std::string("ClientExtendParamsJsonSign"), clientExtendParamsJsonSign); +} + +std::string CreateUserAuthenticateOptionsRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void CreateUserAuthenticateOptionsRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/CreateUserAuthenticateOptionsResult.cc b/idaas-doraemon/src/model/CreateUserAuthenticateOptionsResult.cc new file mode 100644 index 000000000..8c17baae9 --- /dev/null +++ b/idaas-doraemon/src/model/CreateUserAuthenticateOptionsResult.cc @@ -0,0 +1,58 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +CreateUserAuthenticateOptionsResult::CreateUserAuthenticateOptionsResult() : + ServiceResult() +{} + +CreateUserAuthenticateOptionsResult::CreateUserAuthenticateOptionsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateUserAuthenticateOptionsResult::~CreateUserAuthenticateOptionsResult() +{} + +void CreateUserAuthenticateOptionsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ChallengeBase64"].isNull()) + challengeBase64_ = value["ChallengeBase64"].asString(); + if(!value["Options"].isNull()) + options_ = value["Options"].asString(); + +} + +std::string CreateUserAuthenticateOptionsResult::getOptions()const +{ + return options_; +} + +std::string CreateUserAuthenticateOptionsResult::getChallengeBase64()const +{ + return challengeBase64_; +} + diff --git a/idaas-doraemon/src/model/DeregisterAuthenticatorRequest.cc b/idaas-doraemon/src/model/DeregisterAuthenticatorRequest.cc new file mode 100644 index 000000000..642767595 --- /dev/null +++ b/idaas-doraemon/src/model/DeregisterAuthenticatorRequest.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Idaas_doraemon::Model::DeregisterAuthenticatorRequest; + +DeregisterAuthenticatorRequest::DeregisterAuthenticatorRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "DeregisterAuthenticator") { + setMethod(HttpRequest::Method::Post); +} + +DeregisterAuthenticatorRequest::~DeregisterAuthenticatorRequest() {} + +std::string DeregisterAuthenticatorRequest::getUserId() const { + return userId_; +} + +void DeregisterAuthenticatorRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string DeregisterAuthenticatorRequest::getAuthenticatorUuid() const { + return authenticatorUuid_; +} + +void DeregisterAuthenticatorRequest::setAuthenticatorUuid(const std::string &authenticatorUuid) { + authenticatorUuid_ = authenticatorUuid; + setParameter(std::string("AuthenticatorUuid"), authenticatorUuid); +} + +std::string DeregisterAuthenticatorRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void DeregisterAuthenticatorRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/DeregisterAuthenticatorResult.cc b/idaas-doraemon/src/model/DeregisterAuthenticatorResult.cc new file mode 100644 index 000000000..9deb5edb3 --- /dev/null +++ b/idaas-doraemon/src/model/DeregisterAuthenticatorResult.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +DeregisterAuthenticatorResult::DeregisterAuthenticatorResult() : + ServiceResult() +{} + +DeregisterAuthenticatorResult::DeregisterAuthenticatorResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeregisterAuthenticatorResult::~DeregisterAuthenticatorResult() +{} + +void DeregisterAuthenticatorResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/idaas-doraemon/src/model/FetchAccessTokenRequest.cc b/idaas-doraemon/src/model/FetchAccessTokenRequest.cc new file mode 100644 index 000000000..9699e4bac --- /dev/null +++ b/idaas-doraemon/src/model/FetchAccessTokenRequest.cc @@ -0,0 +1,81 @@ +/* + * 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 + +using AlibabaCloud::Idaas_doraemon::Model::FetchAccessTokenRequest; + +FetchAccessTokenRequest::FetchAccessTokenRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "FetchAccessToken") { + setMethod(HttpRequest::Method::Post); +} + +FetchAccessTokenRequest::~FetchAccessTokenRequest() {} + +std::string FetchAccessTokenRequest::getUserId() const { + return userId_; +} + +void FetchAccessTokenRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string FetchAccessTokenRequest::getXClientIp() const { + return xClientIp_; +} + +void FetchAccessTokenRequest::setXClientIp(const std::string &xClientIp) { + xClientIp_ = xClientIp; + setParameter(std::string("XClientIp"), xClientIp); +} + +std::string FetchAccessTokenRequest::getMobileExtendParamsJsonSign() const { + return mobileExtendParamsJsonSign_; +} + +void FetchAccessTokenRequest::setMobileExtendParamsJsonSign(const std::string &mobileExtendParamsJsonSign) { + mobileExtendParamsJsonSign_ = mobileExtendParamsJsonSign; + setParameter(std::string("MobileExtendParamsJsonSign"), mobileExtendParamsJsonSign); +} + +std::string FetchAccessTokenRequest::getServerExtendParamsJson() const { + return serverExtendParamsJson_; +} + +void FetchAccessTokenRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) { + serverExtendParamsJson_ = serverExtendParamsJson; + setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson); +} + +std::string FetchAccessTokenRequest::getMobileExtendParamsJson() const { + return mobileExtendParamsJson_; +} + +void FetchAccessTokenRequest::setMobileExtendParamsJson(const std::string &mobileExtendParamsJson) { + mobileExtendParamsJson_ = mobileExtendParamsJson; + setParameter(std::string("MobileExtendParamsJson"), mobileExtendParamsJson); +} + +std::string FetchAccessTokenRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void FetchAccessTokenRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/FetchAccessTokenResult.cc b/idaas-doraemon/src/model/FetchAccessTokenResult.cc new file mode 100644 index 000000000..c51882865 --- /dev/null +++ b/idaas-doraemon/src/model/FetchAccessTokenResult.cc @@ -0,0 +1,83 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +FetchAccessTokenResult::FetchAccessTokenResult() : + ServiceResult() +{} + +FetchAccessTokenResult::FetchAccessTokenResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +FetchAccessTokenResult::~FetchAccessTokenResult() +{} + +void FetchAccessTokenResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["Access_token"].isNull()) + data_.access_token = dataNode["Access_token"].asString(); + if(!dataNode["Token_type"].isNull()) + data_.token_type = dataNode["Token_type"].asString(); + if(!dataNode["Scope"].isNull()) + data_.scope = dataNode["Scope"].asString(); + if(!dataNode["Expires_in"].isNull()) + data_.expires_in = dataNode["Expires_in"].asString(); + if(!dataNode["Refresh_token"].isNull()) + data_.refresh_token = dataNode["Refresh_token"].asString(); + if(!dataNode["Id_token"].isNull()) + data_.id_token = dataNode["Id_token"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string FetchAccessTokenResult::getMessage()const +{ + return message_; +} + +FetchAccessTokenResult::Data FetchAccessTokenResult::getData()const +{ + return data_; +} + +std::string FetchAccessTokenResult::getCode()const +{ + return code_; +} + +bool FetchAccessTokenResult::getSuccess()const +{ + return success_; +} + diff --git a/idaas-doraemon/src/model/GetAuthenticatorRequest.cc b/idaas-doraemon/src/model/GetAuthenticatorRequest.cc new file mode 100644 index 000000000..422287dec --- /dev/null +++ b/idaas-doraemon/src/model/GetAuthenticatorRequest.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Idaas_doraemon::Model::GetAuthenticatorRequest; + +GetAuthenticatorRequest::GetAuthenticatorRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "GetAuthenticator") { + setMethod(HttpRequest::Method::Post); +} + +GetAuthenticatorRequest::~GetAuthenticatorRequest() {} + +std::string GetAuthenticatorRequest::getUserId() const { + return userId_; +} + +void GetAuthenticatorRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string GetAuthenticatorRequest::getAuthenticatorUuid() const { + return authenticatorUuid_; +} + +void GetAuthenticatorRequest::setAuthenticatorUuid(const std::string &authenticatorUuid) { + authenticatorUuid_ = authenticatorUuid; + setParameter(std::string("AuthenticatorUuid"), authenticatorUuid); +} + +std::string GetAuthenticatorRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void GetAuthenticatorRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/GetAuthenticatorResult.cc b/idaas-doraemon/src/model/GetAuthenticatorResult.cc new file mode 100644 index 000000000..1b76ecc4b --- /dev/null +++ b/idaas-doraemon/src/model/GetAuthenticatorResult.cc @@ -0,0 +1,70 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +GetAuthenticatorResult::GetAuthenticatorResult() : + ServiceResult() +{} + +GetAuthenticatorResult::GetAuthenticatorResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetAuthenticatorResult::~GetAuthenticatorResult() +{} + +void GetAuthenticatorResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto authenticatorNode = value["Authenticator"]; + if(!authenticatorNode["AuthenticatorUuid"].isNull()) + authenticator_.authenticatorUuid = authenticatorNode["AuthenticatorUuid"].asString(); + if(!authenticatorNode["CredentialId"].isNull()) + authenticator_.credentialId = authenticatorNode["CredentialId"].asString(); + if(!authenticatorNode["Type"].isNull()) + authenticator_.type = authenticatorNode["Type"].asString(); + if(!authenticatorNode["AuthenticatorName"].isNull()) + authenticator_.authenticatorName = authenticatorNode["AuthenticatorName"].asString(); + if(!authenticatorNode["RegisterTime"].isNull()) + authenticator_.registerTime = std::stol(authenticatorNode["RegisterTime"].asString()); + if(!authenticatorNode["LastVerifyTime"].isNull()) + authenticator_.lastVerifyTime = std::stol(authenticatorNode["LastVerifyTime"].asString()); + if(!authenticatorNode["RegisterSourceIp"].isNull()) + authenticator_.registerSourceIp = authenticatorNode["RegisterSourceIp"].asString(); + if(!authenticatorNode["LastVerifySourceIp"].isNull()) + authenticator_.lastVerifySourceIp = authenticatorNode["LastVerifySourceIp"].asString(); + if(!authenticatorNode["LastVerifyUserAgent"].isNull()) + authenticator_.lastVerifyUserAgent = authenticatorNode["LastVerifyUserAgent"].asString(); + if(!authenticatorNode["CustomAuthenticator"].isNull()) + authenticator_.customAuthenticator = authenticatorNode["CustomAuthenticator"].asString(); + +} + +GetAuthenticatorResult::Authenticator GetAuthenticatorResult::getAuthenticator()const +{ + return authenticator_; +} + diff --git a/idaas-doraemon/src/model/ListAuthenticationLogsRequest.cc b/idaas-doraemon/src/model/ListAuthenticationLogsRequest.cc new file mode 100644 index 000000000..cd3be79ef --- /dev/null +++ b/idaas-doraemon/src/model/ListAuthenticationLogsRequest.cc @@ -0,0 +1,117 @@ +/* + * 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 + +using AlibabaCloud::Idaas_doraemon::Model::ListAuthenticationLogsRequest; + +ListAuthenticationLogsRequest::ListAuthenticationLogsRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ListAuthenticationLogs") { + setMethod(HttpRequest::Method::Post); +} + +ListAuthenticationLogsRequest::~ListAuthenticationLogsRequest() {} + +long ListAuthenticationLogsRequest::getToTime() const { + return toTime_; +} + +void ListAuthenticationLogsRequest::setToTime(long toTime) { + toTime_ = toTime; + setParameter(std::string("ToTime"), std::to_string(toTime)); +} + +std::string ListAuthenticationLogsRequest::getUserId() const { + return userId_; +} + +void ListAuthenticationLogsRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string ListAuthenticationLogsRequest::getLogTag() const { + return logTag_; +} + +void ListAuthenticationLogsRequest::setLogTag(const std::string &logTag) { + logTag_ = logTag; + setParameter(std::string("LogTag"), logTag); +} + +long ListAuthenticationLogsRequest::getPageNumber() const { + return pageNumber_; +} + +void ListAuthenticationLogsRequest::setPageNumber(long pageNumber) { + pageNumber_ = pageNumber; + setParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +long ListAuthenticationLogsRequest::getPageSize() const { + return pageSize_; +} + +void ListAuthenticationLogsRequest::setPageSize(long pageSize) { + pageSize_ = pageSize; + setParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +std::string ListAuthenticationLogsRequest::getCredentialId() const { + return credentialId_; +} + +void ListAuthenticationLogsRequest::setCredentialId(const std::string &credentialId) { + credentialId_ = credentialId; + setParameter(std::string("CredentialId"), credentialId); +} + +long ListAuthenticationLogsRequest::getFromTime() const { + return fromTime_; +} + +void ListAuthenticationLogsRequest::setFromTime(long fromTime) { + fromTime_ = fromTime; + setParameter(std::string("FromTime"), std::to_string(fromTime)); +} + +std::string ListAuthenticationLogsRequest::getAuthenticatorUuid() const { + return authenticatorUuid_; +} + +void ListAuthenticationLogsRequest::setAuthenticatorUuid(const std::string &authenticatorUuid) { + authenticatorUuid_ = authenticatorUuid; + setParameter(std::string("AuthenticatorUuid"), authenticatorUuid); +} + +std::string ListAuthenticationLogsRequest::getAuthenticatorType() const { + return authenticatorType_; +} + +void ListAuthenticationLogsRequest::setAuthenticatorType(const std::string &authenticatorType) { + authenticatorType_ = authenticatorType; + setParameter(std::string("AuthenticatorType"), authenticatorType); +} + +std::string ListAuthenticationLogsRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void ListAuthenticationLogsRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/ListAuthenticationLogsResult.cc b/idaas-doraemon/src/model/ListAuthenticationLogsResult.cc new file mode 100644 index 000000000..571c38cd5 --- /dev/null +++ b/idaas-doraemon/src/model/ListAuthenticationLogsResult.cc @@ -0,0 +1,116 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +ListAuthenticationLogsResult::ListAuthenticationLogsResult() : + ServiceResult() +{} + +ListAuthenticationLogsResult::ListAuthenticationLogsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAuthenticationLogsResult::~ListAuthenticationLogsResult() +{} + +void ListAuthenticationLogsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allAuthenticationLogContentNode = value["AuthenticationLogContent"]["authenticationLogContentItem"]; + for (auto valueAuthenticationLogContentauthenticationLogContentItem : allAuthenticationLogContentNode) + { + AuthenticationLogContentItem authenticationLogContentObject; + if(!valueAuthenticationLogContentauthenticationLogContentItem["TenantId"].isNull()) + authenticationLogContentObject.tenantId = valueAuthenticationLogContentauthenticationLogContentItem["TenantId"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["AliUid"].isNull()) + authenticationLogContentObject.aliUid = valueAuthenticationLogContentauthenticationLogContentItem["AliUid"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["ApplicationUuid"].isNull()) + authenticationLogContentObject.applicationUuid = valueAuthenticationLogContentauthenticationLogContentItem["ApplicationUuid"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["ApplicationExternalId"].isNull()) + authenticationLogContentObject.applicationExternalId = valueAuthenticationLogContentauthenticationLogContentItem["ApplicationExternalId"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["UserId"].isNull()) + authenticationLogContentObject.userId = valueAuthenticationLogContentauthenticationLogContentItem["UserId"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorUuid"].isNull()) + authenticationLogContentObject.authenticatorUuid = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorUuid"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorName"].isNull()) + authenticationLogContentObject.authenticatorName = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorName"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["CredentialId"].isNull()) + authenticationLogContentObject.credentialId = valueAuthenticationLogContentauthenticationLogContentItem["CredentialId"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorType"].isNull()) + authenticationLogContentObject.authenticatorType = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorType"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticationAction"].isNull()) + authenticationLogContentObject.authenticationAction = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticationAction"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["ChallengeBase64"].isNull()) + authenticationLogContentObject.challengeBase64 = valueAuthenticationLogContentauthenticationLogContentItem["ChallengeBase64"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticationTime"].isNull()) + authenticationLogContentObject.authenticationTime = std::stol(valueAuthenticationLogContentauthenticationLogContentItem["AuthenticationTime"].asString()); + if(!valueAuthenticationLogContentauthenticationLogContentItem["UserAgent"].isNull()) + authenticationLogContentObject.userAgent = valueAuthenticationLogContentauthenticationLogContentItem["UserAgent"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["UserSourceIp"].isNull()) + authenticationLogContentObject.userSourceIp = valueAuthenticationLogContentauthenticationLogContentItem["UserSourceIp"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["RawAuthenticationContext"].isNull()) + authenticationLogContentObject.rawAuthenticationContext = valueAuthenticationLogContentauthenticationLogContentItem["RawAuthenticationContext"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["VerifyResult"].isNull()) + authenticationLogContentObject.verifyResult = valueAuthenticationLogContentauthenticationLogContentItem["VerifyResult"].asString() == "true"; + if(!valueAuthenticationLogContentauthenticationLogContentItem["ErrorCode"].isNull()) + authenticationLogContentObject.errorCode = valueAuthenticationLogContentauthenticationLogContentItem["ErrorCode"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["ErrorMessage"].isNull()) + authenticationLogContentObject.errorMessage = valueAuthenticationLogContentauthenticationLogContentItem["ErrorMessage"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["LogTag"].isNull()) + authenticationLogContentObject.logTag = valueAuthenticationLogContentauthenticationLogContentItem["LogTag"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["LogParams"].isNull()) + authenticationLogContentObject.logParams = valueAuthenticationLogContentauthenticationLogContentItem["LogParams"].asString(); + authenticationLogContent_.push_back(authenticationLogContentObject); + } + if(!value["TotalCount"].isNull()) + totalCount_ = std::stol(value["TotalCount"].asString()); + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stol(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stol(value["PageSize"].asString()); + +} + +long ListAuthenticationLogsResult::getTotalCount()const +{ + return totalCount_; +} + +std::vector ListAuthenticationLogsResult::getAuthenticationLogContent()const +{ + return authenticationLogContent_; +} + +long ListAuthenticationLogsResult::getPageSize()const +{ + return pageSize_; +} + +long ListAuthenticationLogsResult::getPageNumber()const +{ + return pageNumber_; +} + diff --git a/idaas-doraemon/src/model/ListAuthenticatorOpsLogsRequest.cc b/idaas-doraemon/src/model/ListAuthenticatorOpsLogsRequest.cc new file mode 100644 index 000000000..49180d6e8 --- /dev/null +++ b/idaas-doraemon/src/model/ListAuthenticatorOpsLogsRequest.cc @@ -0,0 +1,99 @@ +/* + * 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 + +using AlibabaCloud::Idaas_doraemon::Model::ListAuthenticatorOpsLogsRequest; + +ListAuthenticatorOpsLogsRequest::ListAuthenticatorOpsLogsRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ListAuthenticatorOpsLogs") { + setMethod(HttpRequest::Method::Post); +} + +ListAuthenticatorOpsLogsRequest::~ListAuthenticatorOpsLogsRequest() {} + +long ListAuthenticatorOpsLogsRequest::getToTime() const { + return toTime_; +} + +void ListAuthenticatorOpsLogsRequest::setToTime(long toTime) { + toTime_ = toTime; + setParameter(std::string("ToTime"), std::to_string(toTime)); +} + +std::string ListAuthenticatorOpsLogsRequest::getUserId() const { + return userId_; +} + +void ListAuthenticatorOpsLogsRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +long ListAuthenticatorOpsLogsRequest::getPageNumber() const { + return pageNumber_; +} + +void ListAuthenticatorOpsLogsRequest::setPageNumber(long pageNumber) { + pageNumber_ = pageNumber; + setParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +long ListAuthenticatorOpsLogsRequest::getPageSize() const { + return pageSize_; +} + +void ListAuthenticatorOpsLogsRequest::setPageSize(long pageSize) { + pageSize_ = pageSize; + setParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +long ListAuthenticatorOpsLogsRequest::getFromTime() const { + return fromTime_; +} + +void ListAuthenticatorOpsLogsRequest::setFromTime(long fromTime) { + fromTime_ = fromTime; + setParameter(std::string("FromTime"), std::to_string(fromTime)); +} + +std::string ListAuthenticatorOpsLogsRequest::getAuthenticatorUuid() const { + return authenticatorUuid_; +} + +void ListAuthenticatorOpsLogsRequest::setAuthenticatorUuid(const std::string &authenticatorUuid) { + authenticatorUuid_ = authenticatorUuid; + setParameter(std::string("AuthenticatorUuid"), authenticatorUuid); +} + +std::string ListAuthenticatorOpsLogsRequest::getAuthenticatorType() const { + return authenticatorType_; +} + +void ListAuthenticatorOpsLogsRequest::setAuthenticatorType(const std::string &authenticatorType) { + authenticatorType_ = authenticatorType; + setParameter(std::string("AuthenticatorType"), authenticatorType); +} + +std::string ListAuthenticatorOpsLogsRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void ListAuthenticatorOpsLogsRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/ListAuthenticatorOpsLogsResult.cc b/idaas-doraemon/src/model/ListAuthenticatorOpsLogsResult.cc new file mode 100644 index 000000000..fc8d423c0 --- /dev/null +++ b/idaas-doraemon/src/model/ListAuthenticatorOpsLogsResult.cc @@ -0,0 +1,114 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +ListAuthenticatorOpsLogsResult::ListAuthenticatorOpsLogsResult() : + ServiceResult() +{} + +ListAuthenticatorOpsLogsResult::ListAuthenticatorOpsLogsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAuthenticatorOpsLogsResult::~ListAuthenticatorOpsLogsResult() +{} + +void ListAuthenticatorOpsLogsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allAuthenticationLogContentNode = value["AuthenticationLogContent"]["authenticationLogContentItem"]; + for (auto valueAuthenticationLogContentauthenticationLogContentItem : allAuthenticationLogContentNode) + { + AuthenticationLogContentItem authenticationLogContentObject; + if(!valueAuthenticationLogContentauthenticationLogContentItem["TenantId"].isNull()) + authenticationLogContentObject.tenantId = valueAuthenticationLogContentauthenticationLogContentItem["TenantId"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["AliUid"].isNull()) + authenticationLogContentObject.aliUid = valueAuthenticationLogContentauthenticationLogContentItem["AliUid"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["ApplicationUuid"].isNull()) + authenticationLogContentObject.applicationUuid = valueAuthenticationLogContentauthenticationLogContentItem["ApplicationUuid"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["ApplicationExternalId"].isNull()) + authenticationLogContentObject.applicationExternalId = valueAuthenticationLogContentauthenticationLogContentItem["ApplicationExternalId"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["UserId"].isNull()) + authenticationLogContentObject.userId = valueAuthenticationLogContentauthenticationLogContentItem["UserId"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorUuid"].isNull()) + authenticationLogContentObject.authenticatorUuid = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorUuid"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorName"].isNull()) + authenticationLogContentObject.authenticatorName = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorName"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["CredentialId"].isNull()) + authenticationLogContentObject.credentialId = valueAuthenticationLogContentauthenticationLogContentItem["CredentialId"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorType"].isNull()) + authenticationLogContentObject.authenticatorType = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorType"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["OperationAction"].isNull()) + authenticationLogContentObject.operationAction = valueAuthenticationLogContentauthenticationLogContentItem["OperationAction"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["ChallengeBase64"].isNull()) + authenticationLogContentObject.challengeBase64 = valueAuthenticationLogContentauthenticationLogContentItem["ChallengeBase64"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["OperationTime"].isNull()) + authenticationLogContentObject.operationTime = std::stol(valueAuthenticationLogContentauthenticationLogContentItem["OperationTime"].asString()); + if(!valueAuthenticationLogContentauthenticationLogContentItem["UserAgent"].isNull()) + authenticationLogContentObject.userAgent = valueAuthenticationLogContentauthenticationLogContentItem["UserAgent"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["UserSourceIp"].isNull()) + authenticationLogContentObject.userSourceIp = valueAuthenticationLogContentauthenticationLogContentItem["UserSourceIp"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["RawContext"].isNull()) + authenticationLogContentObject.rawContext = valueAuthenticationLogContentauthenticationLogContentItem["RawContext"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["OperationResult"].isNull()) + authenticationLogContentObject.operationResult = valueAuthenticationLogContentauthenticationLogContentItem["OperationResult"].asString() == "true"; + if(!valueAuthenticationLogContentauthenticationLogContentItem["ErrorCode"].isNull()) + authenticationLogContentObject.errorCode = valueAuthenticationLogContentauthenticationLogContentItem["ErrorCode"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["ErrorMessage"].isNull()) + authenticationLogContentObject.errorMessage = valueAuthenticationLogContentauthenticationLogContentItem["ErrorMessage"].asString(); + if(!valueAuthenticationLogContentauthenticationLogContentItem["LogParams"].isNull()) + authenticationLogContentObject.logParams = valueAuthenticationLogContentauthenticationLogContentItem["LogParams"].asString(); + authenticationLogContent_.push_back(authenticationLogContentObject); + } + if(!value["TotalCount"].isNull()) + totalCount_ = std::stol(value["TotalCount"].asString()); + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stol(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stol(value["PageSize"].asString()); + +} + +long ListAuthenticatorOpsLogsResult::getTotalCount()const +{ + return totalCount_; +} + +std::vector ListAuthenticatorOpsLogsResult::getAuthenticationLogContent()const +{ + return authenticationLogContent_; +} + +long ListAuthenticatorOpsLogsResult::getPageSize()const +{ + return pageSize_; +} + +long ListAuthenticatorOpsLogsResult::getPageNumber()const +{ + return pageNumber_; +} + diff --git a/idaas-doraemon/src/model/ListAuthenticatorsRequest.cc b/idaas-doraemon/src/model/ListAuthenticatorsRequest.cc new file mode 100644 index 000000000..cc304841f --- /dev/null +++ b/idaas-doraemon/src/model/ListAuthenticatorsRequest.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Idaas_doraemon::Model::ListAuthenticatorsRequest; + +ListAuthenticatorsRequest::ListAuthenticatorsRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ListAuthenticators") { + setMethod(HttpRequest::Method::Post); +} + +ListAuthenticatorsRequest::~ListAuthenticatorsRequest() {} + +std::string ListAuthenticatorsRequest::getUserId() const { + return userId_; +} + +void ListAuthenticatorsRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +long ListAuthenticatorsRequest::getPageNumber() const { + return pageNumber_; +} + +void ListAuthenticatorsRequest::setPageNumber(long pageNumber) { + pageNumber_ = pageNumber; + setParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +long ListAuthenticatorsRequest::getPageSize() const { + return pageSize_; +} + +void ListAuthenticatorsRequest::setPageSize(long pageSize) { + pageSize_ = pageSize; + setParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +std::string ListAuthenticatorsRequest::getAuthenticatorType() const { + return authenticatorType_; +} + +void ListAuthenticatorsRequest::setAuthenticatorType(const std::string &authenticatorType) { + authenticatorType_ = authenticatorType; + setParameter(std::string("AuthenticatorType"), authenticatorType); +} + +std::string ListAuthenticatorsRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void ListAuthenticatorsRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/ListAuthenticatorsResult.cc b/idaas-doraemon/src/model/ListAuthenticatorsResult.cc new file mode 100644 index 000000000..219d7fac8 --- /dev/null +++ b/idaas-doraemon/src/model/ListAuthenticatorsResult.cc @@ -0,0 +1,90 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +ListAuthenticatorsResult::ListAuthenticatorsResult() : + ServiceResult() +{} + +ListAuthenticatorsResult::ListAuthenticatorsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAuthenticatorsResult::~ListAuthenticatorsResult() +{} + +void ListAuthenticatorsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allAuthenticatorNode = value["Authenticator"]["AuthenticatorListDTO"]; + for (auto valueAuthenticatorAuthenticatorListDTO : allAuthenticatorNode) + { + AuthenticatorListDTO authenticatorObject; + if(!valueAuthenticatorAuthenticatorListDTO["ApplicationExternalId"].isNull()) + authenticatorObject.applicationExternalId = valueAuthenticatorAuthenticatorListDTO["ApplicationExternalId"].asString(); + if(!valueAuthenticatorAuthenticatorListDTO["AuthenticatorUuid"].isNull()) + authenticatorObject.authenticatorUuid = valueAuthenticatorAuthenticatorListDTO["AuthenticatorUuid"].asString(); + if(!valueAuthenticatorAuthenticatorListDTO["CredentialId"].isNull()) + authenticatorObject.credentialId = valueAuthenticatorAuthenticatorListDTO["CredentialId"].asString(); + if(!valueAuthenticatorAuthenticatorListDTO["Type"].isNull()) + authenticatorObject.type = valueAuthenticatorAuthenticatorListDTO["Type"].asString(); + if(!valueAuthenticatorAuthenticatorListDTO["AuthenticatorName"].isNull()) + authenticatorObject.authenticatorName = valueAuthenticatorAuthenticatorListDTO["AuthenticatorName"].asString(); + if(!valueAuthenticatorAuthenticatorListDTO["RegisterTime"].isNull()) + authenticatorObject.registerTime = std::stol(valueAuthenticatorAuthenticatorListDTO["RegisterTime"].asString()); + if(!valueAuthenticatorAuthenticatorListDTO["LastVerifyTime"].isNull()) + authenticatorObject.lastVerifyTime = std::stol(valueAuthenticatorAuthenticatorListDTO["LastVerifyTime"].asString()); + authenticator_.push_back(authenticatorObject); + } + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stol(value["PageNumber"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stol(value["TotalCount"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stol(value["PageSize"].asString()); + +} + +long ListAuthenticatorsResult::getTotalCount()const +{ + return totalCount_; +} + +long ListAuthenticatorsResult::getPageSize()const +{ + return pageSize_; +} + +long ListAuthenticatorsResult::getPageNumber()const +{ + return pageNumber_; +} + +std::vector ListAuthenticatorsResult::getAuthenticator()const +{ + return authenticator_; +} + diff --git a/idaas-doraemon/src/model/ListPwnedPasswordsRequest.cc b/idaas-doraemon/src/model/ListPwnedPasswordsRequest.cc new file mode 100644 index 000000000..cc84972c7 --- /dev/null +++ b/idaas-doraemon/src/model/ListPwnedPasswordsRequest.cc @@ -0,0 +1,36 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Idaas_doraemon::Model::ListPwnedPasswordsRequest; + +ListPwnedPasswordsRequest::ListPwnedPasswordsRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ListPwnedPasswords") { + setMethod(HttpRequest::Method::Post); +} + +ListPwnedPasswordsRequest::~ListPwnedPasswordsRequest() {} + +std::string ListPwnedPasswordsRequest::getPrefixHexPasswordSha1Hash() const { + return prefixHexPasswordSha1Hash_; +} + +void ListPwnedPasswordsRequest::setPrefixHexPasswordSha1Hash(const std::string &prefixHexPasswordSha1Hash) { + prefixHexPasswordSha1Hash_ = prefixHexPasswordSha1Hash; + setParameter(std::string("PrefixHexPasswordSha1Hash"), prefixHexPasswordSha1Hash); +} + diff --git a/idaas-doraemon/src/model/ListPwnedPasswordsResult.cc b/idaas-doraemon/src/model/ListPwnedPasswordsResult.cc new file mode 100644 index 000000000..9b4cb8a69 --- /dev/null +++ b/idaas-doraemon/src/model/ListPwnedPasswordsResult.cc @@ -0,0 +1,80 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +ListPwnedPasswordsResult::ListPwnedPasswordsResult() : + ServiceResult() +{} + +ListPwnedPasswordsResult::ListPwnedPasswordsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListPwnedPasswordsResult::~ListPwnedPasswordsResult() +{} + +void ListPwnedPasswordsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allPwnedPasswordInfosNode = value["PwnedPasswordInfos"]["items"]; + for (auto valuePwnedPasswordInfositems : allPwnedPasswordInfosNode) + { + Items pwnedPasswordInfosObject; + if(!valuePwnedPasswordInfositems["HexPasswordSha1Hash"].isNull()) + pwnedPasswordInfosObject.hexPasswordSha1Hash = valuePwnedPasswordInfositems["HexPasswordSha1Hash"].asString(); + if(!valuePwnedPasswordInfositems["PwnedCount"].isNull()) + pwnedPasswordInfosObject.pwnedCount = std::stol(valuePwnedPasswordInfositems["PwnedCount"].asString()); + pwnedPasswordInfos_.push_back(pwnedPasswordInfosObject); + } + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stol(value["PageNumber"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stol(value["TotalCount"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stol(value["PageSize"].asString()); + +} + +long ListPwnedPasswordsResult::getTotalCount()const +{ + return totalCount_; +} + +long ListPwnedPasswordsResult::getPageSize()const +{ + return pageSize_; +} + +long ListPwnedPasswordsResult::getPageNumber()const +{ + return pageNumber_; +} + +std::vector ListPwnedPasswordsResult::getPwnedPasswordInfos()const +{ + return pwnedPasswordInfos_; +} + diff --git a/idaas-doraemon/src/model/ListUsersRequest.cc b/idaas-doraemon/src/model/ListUsersRequest.cc new file mode 100644 index 000000000..fbe50277d --- /dev/null +++ b/idaas-doraemon/src/model/ListUsersRequest.cc @@ -0,0 +1,45 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Idaas_doraemon::Model::ListUsersRequest; + +ListUsersRequest::ListUsersRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ListUsers") { + setMethod(HttpRequest::Method::Post); +} + +ListUsersRequest::~ListUsersRequest() {} + +std::string ListUsersRequest::getUserId() const { + return userId_; +} + +void ListUsersRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string ListUsersRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void ListUsersRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/ListUsersResult.cc b/idaas-doraemon/src/model/ListUsersResult.cc new file mode 100644 index 000000000..861319cf9 --- /dev/null +++ b/idaas-doraemon/src/model/ListUsersResult.cc @@ -0,0 +1,68 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +ListUsersResult::ListUsersResult() : + ServiceResult() +{} + +ListUsersResult::ListUsersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListUsersResult::~ListUsersResult() +{} + +void ListUsersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allUsersNode = value["Users"]["usersItem"]; + for (auto valueUsersusersItem : allUsersNode) + { + UsersItem usersObject; + if(!valueUsersusersItem["UserId"].isNull()) + usersObject.userId = valueUsersusersItem["UserId"].asString(); + if(!valueUsersusersItem["UserName"].isNull()) + usersObject.userName = valueUsersusersItem["UserName"].asString(); + if(!valueUsersusersItem["UserDisplayName"].isNull()) + usersObject.userDisplayName = valueUsersusersItem["UserDisplayName"].asString(); + users_.push_back(usersObject); + } + if(!value["TotalCount"].isNull()) + totalCount_ = std::stol(value["TotalCount"].asString()); + +} + +long ListUsersResult::getTotalCount()const +{ + return totalCount_; +} + +std::vector ListUsersResult::getUsers()const +{ + return users_; +} + diff --git a/idaas-doraemon/src/model/RegisterAuthenticatorRequest.cc b/idaas-doraemon/src/model/RegisterAuthenticatorRequest.cc new file mode 100644 index 000000000..71dc922c4 --- /dev/null +++ b/idaas-doraemon/src/model/RegisterAuthenticatorRequest.cc @@ -0,0 +1,126 @@ +/* + * 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 + +using AlibabaCloud::Idaas_doraemon::Model::RegisterAuthenticatorRequest; + +RegisterAuthenticatorRequest::RegisterAuthenticatorRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "RegisterAuthenticator") { + setMethod(HttpRequest::Method::Post); +} + +RegisterAuthenticatorRequest::~RegisterAuthenticatorRequest() {} + +std::string RegisterAuthenticatorRequest::getLogParams() const { + return logParams_; +} + +void RegisterAuthenticatorRequest::setLogParams(const std::string &logParams) { + logParams_ = logParams; + setParameter(std::string("LogParams"), logParams); +} + +std::string RegisterAuthenticatorRequest::getClientExtendParamsJson() const { + return clientExtendParamsJson_; +} + +void RegisterAuthenticatorRequest::setClientExtendParamsJson(const std::string &clientExtendParamsJson) { + clientExtendParamsJson_ = clientExtendParamsJson; + setParameter(std::string("ClientExtendParamsJson"), clientExtendParamsJson); +} + +std::string RegisterAuthenticatorRequest::getUserId() const { + return userId_; +} + +void RegisterAuthenticatorRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string RegisterAuthenticatorRequest::getServerExtendParamsJson() const { + return serverExtendParamsJson_; +} + +void RegisterAuthenticatorRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) { + serverExtendParamsJson_ = serverExtendParamsJson; + setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson); +} + +std::string RegisterAuthenticatorRequest::getRegistrationContext() const { + return registrationContext_; +} + +void RegisterAuthenticatorRequest::setRegistrationContext(const std::string ®istrationContext) { + registrationContext_ = registrationContext; + setParameter(std::string("RegistrationContext"), registrationContext); +} + +std::string RegisterAuthenticatorRequest::getAuthenticatorName() const { + return authenticatorName_; +} + +void RegisterAuthenticatorRequest::setAuthenticatorName(const std::string &authenticatorName) { + authenticatorName_ = authenticatorName; + setParameter(std::string("AuthenticatorName"), authenticatorName); +} + +std::string RegisterAuthenticatorRequest::getRequireChallengeBase64() const { + return requireChallengeBase64_; +} + +void RegisterAuthenticatorRequest::setRequireChallengeBase64(const std::string &requireChallengeBase64) { + requireChallengeBase64_ = requireChallengeBase64; + setParameter(std::string("RequireChallengeBase64"), requireChallengeBase64); +} + +std::string RegisterAuthenticatorRequest::getAuthenticatorType() const { + return authenticatorType_; +} + +void RegisterAuthenticatorRequest::setAuthenticatorType(const std::string &authenticatorType) { + authenticatorType_ = authenticatorType; + setParameter(std::string("AuthenticatorType"), authenticatorType); +} + +std::string RegisterAuthenticatorRequest::getClientExtendParamsJsonSign() const { + return clientExtendParamsJsonSign_; +} + +void RegisterAuthenticatorRequest::setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign) { + clientExtendParamsJsonSign_ = clientExtendParamsJsonSign; + setParameter(std::string("ClientExtendParamsJsonSign"), clientExtendParamsJsonSign); +} + +std::string RegisterAuthenticatorRequest::getUserSourceIp() const { + return userSourceIp_; +} + +void RegisterAuthenticatorRequest::setUserSourceIp(const std::string &userSourceIp) { + userSourceIp_ = userSourceIp; + setParameter(std::string("UserSourceIp"), userSourceIp); +} + +std::string RegisterAuthenticatorRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void RegisterAuthenticatorRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/RegisterAuthenticatorResult.cc b/idaas-doraemon/src/model/RegisterAuthenticatorResult.cc new file mode 100644 index 000000000..54f808c46 --- /dev/null +++ b/idaas-doraemon/src/model/RegisterAuthenticatorResult.cc @@ -0,0 +1,58 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +RegisterAuthenticatorResult::RegisterAuthenticatorResult() : + ServiceResult() +{} + +RegisterAuthenticatorResult::RegisterAuthenticatorResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RegisterAuthenticatorResult::~RegisterAuthenticatorResult() +{} + +void RegisterAuthenticatorResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["AuthenticatorUuid"].isNull()) + authenticatorUuid_ = value["AuthenticatorUuid"].asString(); + if(!value["EtasResponseSting"].isNull()) + etasResponseSting_ = value["EtasResponseSting"].asString(); + +} + +std::string RegisterAuthenticatorResult::getEtasResponseSting()const +{ + return etasResponseSting_; +} + +std::string RegisterAuthenticatorResult::getAuthenticatorUuid()const +{ + return authenticatorUuid_; +} + diff --git a/idaas-doraemon/src/model/ServiceInvokeRequest.cc b/idaas-doraemon/src/model/ServiceInvokeRequest.cc new file mode 100644 index 000000000..0fba6f28b --- /dev/null +++ b/idaas-doraemon/src/model/ServiceInvokeRequest.cc @@ -0,0 +1,99 @@ +/* + * 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 + +using AlibabaCloud::Idaas_doraemon::Model::ServiceInvokeRequest; + +ServiceInvokeRequest::ServiceInvokeRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ServiceInvoke") { + setMethod(HttpRequest::Method::Post); +} + +ServiceInvokeRequest::~ServiceInvokeRequest() {} + +std::string ServiceInvokeRequest::getXClientIp() const { + return xClientIp_; +} + +void ServiceInvokeRequest::setXClientIp(const std::string &xClientIp) { + xClientIp_ = xClientIp; + setParameter(std::string("XClientIp"), xClientIp); +} + +std::string ServiceInvokeRequest::getMobileExtendParamsJsonSign() const { + return mobileExtendParamsJsonSign_; +} + +void ServiceInvokeRequest::setMobileExtendParamsJsonSign(const std::string &mobileExtendParamsJsonSign) { + mobileExtendParamsJsonSign_ = mobileExtendParamsJsonSign; + setParameter(std::string("MobileExtendParamsJsonSign"), mobileExtendParamsJsonSign); +} + +std::string ServiceInvokeRequest::getServerExtendParamsJson() const { + return serverExtendParamsJson_; +} + +void ServiceInvokeRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) { + serverExtendParamsJson_ = serverExtendParamsJson; + setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson); +} + +std::string ServiceInvokeRequest::getDoraemonAction() const { + return doraemonAction_; +} + +void ServiceInvokeRequest::setDoraemonAction(const std::string &doraemonAction) { + doraemonAction_ = doraemonAction; + setParameter(std::string("DoraemonAction"), doraemonAction); +} + +std::string ServiceInvokeRequest::getMobileExtendParamsJson() const { + return mobileExtendParamsJson_; +} + +void ServiceInvokeRequest::setMobileExtendParamsJson(const std::string &mobileExtendParamsJson) { + mobileExtendParamsJson_ = mobileExtendParamsJson; + setParameter(std::string("MobileExtendParamsJson"), mobileExtendParamsJson); +} + +std::string ServiceInvokeRequest::getServiceCode() const { + return serviceCode_; +} + +void ServiceInvokeRequest::setServiceCode(const std::string &serviceCode) { + serviceCode_ = serviceCode; + setParameter(std::string("ServiceCode"), serviceCode); +} + +bool ServiceInvokeRequest::getTestModel() const { + return testModel_; +} + +void ServiceInvokeRequest::setTestModel(bool testModel) { + testModel_ = testModel; + setParameter(std::string("TestModel"), testModel ? "true" : "false"); +} + +std::string ServiceInvokeRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void ServiceInvokeRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/ServiceInvokeResult.cc b/idaas-doraemon/src/model/ServiceInvokeResult.cc new file mode 100644 index 000000000..cb58cb51b --- /dev/null +++ b/idaas-doraemon/src/model/ServiceInvokeResult.cc @@ -0,0 +1,79 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +ServiceInvokeResult::ServiceInvokeResult() : + ServiceResult() +{} + +ServiceInvokeResult::ServiceInvokeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ServiceInvokeResult::~ServiceInvokeResult() +{} + +void ServiceInvokeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Data"].isNull()) + data_ = value["Data"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["IdToken"].isNull()) + idToken_ = value["IdToken"].asString(); + +} + +std::string ServiceInvokeResult::getIdToken()const +{ + return idToken_; +} + +std::string ServiceInvokeResult::getMessage()const +{ + return message_; +} + +std::string ServiceInvokeResult::getData()const +{ + return data_; +} + +std::string ServiceInvokeResult::getCode()const +{ + return code_; +} + +bool ServiceInvokeResult::getSuccess()const +{ + return success_; +} + diff --git a/idaas-doraemon/src/model/UpdateAuthenticatorAttributeRequest.cc b/idaas-doraemon/src/model/UpdateAuthenticatorAttributeRequest.cc new file mode 100644 index 000000000..979006a51 --- /dev/null +++ b/idaas-doraemon/src/model/UpdateAuthenticatorAttributeRequest.cc @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Idaas_doraemon::Model::UpdateAuthenticatorAttributeRequest; + +UpdateAuthenticatorAttributeRequest::UpdateAuthenticatorAttributeRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "UpdateAuthenticatorAttribute") { + setMethod(HttpRequest::Method::Post); +} + +UpdateAuthenticatorAttributeRequest::~UpdateAuthenticatorAttributeRequest() {} + +std::string UpdateAuthenticatorAttributeRequest::getUserId() const { + return userId_; +} + +void UpdateAuthenticatorAttributeRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string UpdateAuthenticatorAttributeRequest::getAuthenticatorName() const { + return authenticatorName_; +} + +void UpdateAuthenticatorAttributeRequest::setAuthenticatorName(const std::string &authenticatorName) { + authenticatorName_ = authenticatorName; + setParameter(std::string("AuthenticatorName"), authenticatorName); +} + +std::string UpdateAuthenticatorAttributeRequest::getAuthenticatorUuid() const { + return authenticatorUuid_; +} + +void UpdateAuthenticatorAttributeRequest::setAuthenticatorUuid(const std::string &authenticatorUuid) { + authenticatorUuid_ = authenticatorUuid; + setParameter(std::string("AuthenticatorUuid"), authenticatorUuid); +} + +std::string UpdateAuthenticatorAttributeRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void UpdateAuthenticatorAttributeRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/UpdateAuthenticatorAttributeResult.cc b/idaas-doraemon/src/model/UpdateAuthenticatorAttributeResult.cc new file mode 100644 index 000000000..e868ee50d --- /dev/null +++ b/idaas-doraemon/src/model/UpdateAuthenticatorAttributeResult.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +UpdateAuthenticatorAttributeResult::UpdateAuthenticatorAttributeResult() : + ServiceResult() +{} + +UpdateAuthenticatorAttributeResult::UpdateAuthenticatorAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateAuthenticatorAttributeResult::~UpdateAuthenticatorAttributeResult() +{} + +void UpdateAuthenticatorAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/idaas-doraemon/src/model/VerifyIdTokenRequest.cc b/idaas-doraemon/src/model/VerifyIdTokenRequest.cc new file mode 100644 index 000000000..6baa5b981 --- /dev/null +++ b/idaas-doraemon/src/model/VerifyIdTokenRequest.cc @@ -0,0 +1,45 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Idaas_doraemon::Model::VerifyIdTokenRequest; + +VerifyIdTokenRequest::VerifyIdTokenRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "VerifyIdToken") { + setMethod(HttpRequest::Method::Post); +} + +VerifyIdTokenRequest::~VerifyIdTokenRequest() {} + +std::string VerifyIdTokenRequest::getJwtIdToken() const { + return jwtIdToken_; +} + +void VerifyIdTokenRequest::setJwtIdToken(const std::string &jwtIdToken) { + jwtIdToken_ = jwtIdToken; + setParameter(std::string("JwtIdToken"), jwtIdToken); +} + +std::string VerifyIdTokenRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void VerifyIdTokenRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/VerifyIdTokenResult.cc b/idaas-doraemon/src/model/VerifyIdTokenResult.cc new file mode 100644 index 000000000..913bf723e --- /dev/null +++ b/idaas-doraemon/src/model/VerifyIdTokenResult.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +VerifyIdTokenResult::VerifyIdTokenResult() : + ServiceResult() +{} + +VerifyIdTokenResult::VerifyIdTokenResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +VerifyIdTokenResult::~VerifyIdTokenResult() +{} + +void VerifyIdTokenResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["UserId"].isNull()) + userId_ = value["UserId"].asString(); + +} + +std::string VerifyIdTokenResult::getUserId()const +{ + return userId_; +} + diff --git a/idaas-doraemon/src/model/VerifyUserAuthenticationRequest.cc b/idaas-doraemon/src/model/VerifyUserAuthenticationRequest.cc new file mode 100644 index 000000000..42ea687e7 --- /dev/null +++ b/idaas-doraemon/src/model/VerifyUserAuthenticationRequest.cc @@ -0,0 +1,135 @@ +/* + * 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 + +using AlibabaCloud::Idaas_doraemon::Model::VerifyUserAuthenticationRequest; + +VerifyUserAuthenticationRequest::VerifyUserAuthenticationRequest() + : RpcServiceRequest("idaas-doraemon", "2021-05-20", "VerifyUserAuthentication") { + setMethod(HttpRequest::Method::Post); +} + +VerifyUserAuthenticationRequest::~VerifyUserAuthenticationRequest() {} + +std::string VerifyUserAuthenticationRequest::getLogParams() const { + return logParams_; +} + +void VerifyUserAuthenticationRequest::setLogParams(const std::string &logParams) { + logParams_ = logParams; + setParameter(std::string("LogParams"), logParams); +} + +std::string VerifyUserAuthenticationRequest::getClientExtendParamsJson() const { + return clientExtendParamsJson_; +} + +void VerifyUserAuthenticationRequest::setClientExtendParamsJson(const std::string &clientExtendParamsJson) { + clientExtendParamsJson_ = clientExtendParamsJson; + setParameter(std::string("ClientExtendParamsJson"), clientExtendParamsJson); +} + +std::string VerifyUserAuthenticationRequest::getUserId() const { + return userId_; +} + +void VerifyUserAuthenticationRequest::setUserId(const std::string &userId) { + userId_ = userId; + setParameter(std::string("UserId"), userId); +} + +std::string VerifyUserAuthenticationRequest::getLogTag() const { + return logTag_; +} + +void VerifyUserAuthenticationRequest::setLogTag(const std::string &logTag) { + logTag_ = logTag; + setParameter(std::string("LogTag"), logTag); +} + +std::string VerifyUserAuthenticationRequest::getServerExtendParamsJson() const { + return serverExtendParamsJson_; +} + +void VerifyUserAuthenticationRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) { + serverExtendParamsJson_ = serverExtendParamsJson; + setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson); +} + +std::string VerifyUserAuthenticationRequest::getRequireBindHashBase64() const { + return requireBindHashBase64_; +} + +void VerifyUserAuthenticationRequest::setRequireBindHashBase64(const std::string &requireBindHashBase64) { + requireBindHashBase64_ = requireBindHashBase64; + setParameter(std::string("RequireBindHashBase64"), requireBindHashBase64); +} + +std::string VerifyUserAuthenticationRequest::getAuthenticationContext() const { + return authenticationContext_; +} + +void VerifyUserAuthenticationRequest::setAuthenticationContext(const std::string &authenticationContext) { + authenticationContext_ = authenticationContext; + setParameter(std::string("AuthenticationContext"), authenticationContext); +} + +std::string VerifyUserAuthenticationRequest::getRequireChallengeBase64() const { + return requireChallengeBase64_; +} + +void VerifyUserAuthenticationRequest::setRequireChallengeBase64(const std::string &requireChallengeBase64) { + requireChallengeBase64_ = requireChallengeBase64; + setParameter(std::string("RequireChallengeBase64"), requireChallengeBase64); +} + +std::string VerifyUserAuthenticationRequest::getAuthenticatorType() const { + return authenticatorType_; +} + +void VerifyUserAuthenticationRequest::setAuthenticatorType(const std::string &authenticatorType) { + authenticatorType_ = authenticatorType; + setParameter(std::string("AuthenticatorType"), authenticatorType); +} + +std::string VerifyUserAuthenticationRequest::getClientExtendParamsJsonSign() const { + return clientExtendParamsJsonSign_; +} + +void VerifyUserAuthenticationRequest::setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign) { + clientExtendParamsJsonSign_ = clientExtendParamsJsonSign; + setParameter(std::string("ClientExtendParamsJsonSign"), clientExtendParamsJsonSign); +} + +std::string VerifyUserAuthenticationRequest::getUserSourceIp() const { + return userSourceIp_; +} + +void VerifyUserAuthenticationRequest::setUserSourceIp(const std::string &userSourceIp) { + userSourceIp_ = userSourceIp; + setParameter(std::string("UserSourceIp"), userSourceIp); +} + +std::string VerifyUserAuthenticationRequest::getApplicationExternalId() const { + return applicationExternalId_; +} + +void VerifyUserAuthenticationRequest::setApplicationExternalId(const std::string &applicationExternalId) { + applicationExternalId_ = applicationExternalId; + setParameter(std::string("ApplicationExternalId"), applicationExternalId); +} + diff --git a/idaas-doraemon/src/model/VerifyUserAuthenticationResult.cc b/idaas-doraemon/src/model/VerifyUserAuthenticationResult.cc new file mode 100644 index 000000000..878378fe0 --- /dev/null +++ b/idaas-doraemon/src/model/VerifyUserAuthenticationResult.cc @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Idaas_doraemon; +using namespace AlibabaCloud::Idaas_doraemon::Model; + +VerifyUserAuthenticationResult::VerifyUserAuthenticationResult() : + ServiceResult() +{} + +VerifyUserAuthenticationResult::VerifyUserAuthenticationResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +VerifyUserAuthenticationResult::~VerifyUserAuthenticationResult() +{} + +void VerifyUserAuthenticationResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto authenticateResultInfoNode = value["AuthenticateResultInfo"]; + if(!authenticateResultInfoNode["UserId"].isNull()) + authenticateResultInfo_.userId = authenticateResultInfoNode["UserId"].asString(); + if(!authenticateResultInfoNode["CredentialId"].isNull()) + authenticateResultInfo_.credentialId = authenticateResultInfoNode["CredentialId"].asString(); + if(!authenticateResultInfoNode["BindHashBase64"].isNull()) + authenticateResultInfo_.bindHashBase64 = authenticateResultInfoNode["BindHashBase64"].asString(); + if(!value["VerifyResult"].isNull()) + verifyResult_ = value["VerifyResult"].asString() == "true"; + if(!value["EtasSDKString"].isNull()) + etasSDKString_ = value["EtasSDKString"].asString(); + if(!value["IdToken"].isNull()) + idToken_ = value["IdToken"].asString(); + +} + +std::string VerifyUserAuthenticationResult::getIdToken()const +{ + return idToken_; +} + +VerifyUserAuthenticationResult::AuthenticateResultInfo VerifyUserAuthenticationResult::getAuthenticateResultInfo()const +{ + return authenticateResultInfo_; +} + +std::string VerifyUserAuthenticationResult::getEtasSDKString()const +{ + return etasSDKString_; +} + +bool VerifyUserAuthenticationResult::getVerifyResult()const +{ + return verifyResult_; +} +