public void CanGetUserRolesOnNewAccount() { String username = "******"; String password = "******"; AccountRegistrationRequest request = new AccountRegistrationRequest() { Email = "*****@*****.**", Password = password, Username = username, }; AccountRegistrationResponse response = client.RegisterAccount(request); Assert.IsTrue(response.Token != null); Assert.IsTrue(response.User.Id != null); Assert.AreEqual(response.User.Username, username); GetRolesResponse roleResponse = client.GetRoles(new GetRolesRequest() { }); Assert.IsTrue(roleResponse.Status.IsSuccess); Assert.IsTrue(roleResponse.Claims.Contains(UserClaim.User)); Assert.IsFalse(roleResponse.Claims.Contains(UserClaim.Admin)); }
public async Task <AccountRegistrationResponse> RegistrationAsync(AccountRegistrationRequest request) { if (request.Account.Email == null) { throw AbortBadRequest("missing email address"); } if (request.Account.Username.Length < 2) { throw AbortBadRequest("username too short"); } try { var document = Document.FromJson(SerializeJson(new AccountRecord { PK = request.Account.Username.ToLowerInvariant(), Password = HashText(request.Account.Password), Email = request.Account.Email, Name = request.User?.Name, ProfileImage = request.User?.ProfileImage, Salt = Guid.NewGuid().ToString("N").ToUpperInvariant() })); await _table.PutItemAsync(document, new PutItemOperationConfig { ConditionalExpression = new Expression { ExpressionStatement = "attribute_not_exists(PK)" } }); return(new AccountRegistrationResponse { }); } catch (ConditionalCheckFailedException) { throw AbortBadRequest("account is already registered"); } }
public async Task <AccountRegistrationResponse> RegisterUserAsync(AccountRegistrationRequest request) { var existsUser = await GetUserByPhoneAsync(request.Phone); if (existsUser?.CreateUserPlace == CreateUserPlace.FromRegistration) { return(new AccountRegistrationResponse() { Code = ResponseCode.UserWithTheSamePhoneExists }); } var user = _userEntityFactory.Create( request.Name, request.LastName, request.Phone, request.Password, CreateUserPlace.FromRegistration); _userRepository.Add(user); await _userRepository.SaveChangesAsync(); return(new AccountRegistrationResponse() { User = _mapper.Map <UserModel>(user) }); }
public void PlayerCannotRegisterWithTheSameUsername() { String username = "******"; String password = "******"; AccountRegistrationRequest request = new AccountRegistrationRequest() { Email = "*****@*****.**", Password = password, Username = username, }; AccountRegistrationResponse response = client.RegisterAccount(request); String userId = response.User.Id; Assert.IsTrue(response.Token != null); Assert.IsTrue(response.User.Id != null); Assert.IsTrue(response.User.Username == username); request.Email = "*****@*****.**"; var exception = client.RegisterAccount(request); Assert.AreEqual(exception.Status.IsSuccess, false); Assert.That(exception.Status.Detail, Is.EqualTo(ResponseType.DUPLICATE.ToString())); }
public override AccountRegistrationResponse RegisterAccount(AccountRegistrationRequest request, CallOptions options) { AccountRegistrationResponse response = base.RegisterAccount(request, options); Auth.Login(response.Token); return(response); }
public override async Task <AccountRegistrationResponse> RegisterAccount(AccountRegistrationRequest request, ServerCallContext context) { DbUserModel dbUserModel = await DbUserModel.GetUserFromUsername(request.Username); if (dbUserModel != null) { return new AccountRegistrationResponse() { Status = ResponseFactory.createResponse(ResponseType.DUPLICATE) } } ; // Create a new user model DbUserModel model = new DbUserModel(request); await model.SaveToDatabase(); string token = JwtManager.GenerateToken(model.UserModel.Id); context.ResponseTrailers.Add("Authorization", token); return(new AccountRegistrationResponse { Token = token, User = model.AsUser(), Status = ResponseFactory.createResponse(ResponseType.SUCCESS), }); }
public override AccountRegistrationResponse RegisterAccount(AccountRegistrationRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken)) { AccountRegistrationResponse response = base.RegisterAccount(request, headers, deadline, cancellationToken); Auth.Login(response.Token); return(response); }
/// <summary> /// Đăng ký, tạo mới tài khoản /// </summary> /// <param name="request"></param> /// <returns>Thông tin tài khoản</returns> public async Task <Response <AuthenticationResult> > RegisterAsync(AccountRegistrationRequest request) { if (request.Role.Count == 0) { request.Role.Add(Constant.ROLE_USER); } if (String.IsNullOrEmpty(request.Password)) { _logger.LogError(Constant.PASS_NULL); return(new Response <AuthenticationResult>(Constant.STATUS_ERROR, new List <string> { Constant.PASS_NULL })); } var existingUser = await _userManager.FindByEmailAsync(request.Email); if (existingUser != null) { _logger.LogError(Constant.USER_EXIST); return(new Response <AuthenticationResult> { Data = null, Message = new List <string> { Constant.USER_EXIST }, Status = Constant.STATUS_ERROR, TotalData = 0 }); } var newUser = new AppUser { Email = request.Email, UserName = request.FirstName + request.LastName, FirstName = request.FirstName, LastName = request.LastName, Age = request.Age, Address = request.Address, Id = Guid.NewGuid() }; var createdUser = await _userManager.CreateAsync(newUser, request.Password); if (!createdUser.Succeeded) { _logger.LogError("Create User Failed"); return(new Response <AuthenticationResult>(Constant.STATUS_ERROR, createdUser.Errors.Select(x => x.Description))); } await _userManager.AddToRolesAsync(newUser, request.Role); var dataResponse = await GenerateAuthenticationResultForUserAsync(newUser); _logger.LogInformation("Create account success"); return(new Response <AuthenticationResult>(Constant.STATUS_SUCESS, null, dataResponse, 1)); }
public async Task <AccountRegistrationResponse> Register(AccountRegistrationRequest request) { var inputPassword = request.Password; request.Password = _hashService.HashPassword(request.Password); var result = await _userService.RegisterUserAsync(request); await Login(new AccountLoginRequest() { Phone = request.Phone, Password = inputPassword }); return(result); }
public async Task Register(Account account, User user) { var requestBody = new AccountRegistrationRequest { Account = account, User = user }; var json = JsonConvert.SerializeObject(requestBody); var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/registration") { Content = new StringContent(json, Encoding.UTF8, "application/json") }; using (await Client.SendMessage(requestMessage)) { } }
public ActionResult Register(RegisterModel model, string returnUrl, FormCollection form) { if (_workContext.CurrentAccount == null || _workContext.CurrentAccount.IsRegistered()) { //Already registered customer. _authenticationService.SignOut(); //Save a new record // _workContext.CurrentAccount = _accountService.InsertGuestAccount(); } var account = new Account() { Birthdate = model.Birthdate, Contact = model.Contact, Country = model.Country, Email = model.Email, Deleted = false, Gender = model.Gender, Language = model.Language, CreatedOnUtc = DateTime.Now, LastActivityDateUtc = DateTime.Now, AccountGuid = Guid.NewGuid() }; if (ModelState.IsValid) { var registrationRequest = new AccountRegistrationRequest(account, model.Email, model.Password, PasswordFormat.Hashed); // _accountService.InsertGuestAccount var registrationResult = _accountRegistrationService.RegisterAccount(registrationRequest); if (registrationResult.Success) { _accountService.CreateAccount(account); _authenticationService.SignIn(account, true); return(RedirectToRoute("HomePage")); } else { foreach (var error in registrationResult.Errors) { ModelState.AddModelError("", error); } } } return(View(model)); }
private void CreateDefaultAdmin(string defaultUserEmail, string defaultUserPassword) { var admin = new Account() { AccountGuid = Guid.NewGuid(), Active = true, CreatedOnUtc = DateTime.UtcNow, LastActivityDateUtc = DateTime.UtcNow, }; var arAdmin = _accountService.GetAccountRoleBySystemName(SystemAccountRoleNames.Administrators); admin.AccountRoles.Add(arAdmin); _accountService.InsertAccount(admin); var registrarRequest = new AccountRegistrationRequest(admin, defaultUserEmail, defaultUserEmail, defaultUserPassword, PasswordFormat.Hashed); var registrarResult = _accountRegistrationService.RegisterAccount(registrarRequest); }
public void UserCanRegisterNewAccount() { String username = "******"; String password = "******"; AccountRegistrationRequest request = new AccountRegistrationRequest() { Email = "*****@*****.**", Password = password, Username = username, }; AccountRegistrationResponse response = client.RegisterAccount(request); Assert.IsTrue(response.Token != null); Assert.IsTrue(response.User.Id != null); Assert.AreEqual(response.User.Username, username); }
public String createAccount(String username) { String pass = RandomString(13); AccountRegistrationRequest request = new AccountRegistrationRequest() { Email = "*****@*****.**", Password = pass, Username = username, DeviceIdentifier = Guid.NewGuid().ToString(), }; AccountRegistrationResponse response = client.RegisterAccount(request); userIds.Add(username, response.User.Id); accounts.Add(username, pass); return(response.User.Id); }
public void UserIsLoggedInAfterRegistering() { String username = "******"; String password = "******"; AccountRegistrationRequest request = new AccountRegistrationRequest() { Email = "*****@*****.**", Password = password, Username = username, }; AccountRegistrationResponse response = client.RegisterAccount(request); Assert.IsTrue(response.Token != null); Assert.IsTrue(response.User.Id != null); Assert.AreEqual(response.User.Username, username); AuthorizedHealthCheckResponse AuthResponse = client.AuthorizedHealthCheck(new AuthorizedHealthCheckRequest()); Assert.IsTrue(AuthResponse != null); }
public DbUserModel(AccountRegistrationRequest registration) { string deviceIdentifier; if (string.IsNullOrEmpty(registration.DeviceIdentifier)) { deviceIdentifier = registration.Email; } else { deviceIdentifier = registration.DeviceIdentifier; } UserModel = new UserModel() { Id = Guid.NewGuid().ToString(), Username = registration.Username, Email = registration.Email, EmailVerified = false, PasswordHash = JwtManager.HashPassword(registration.Password), Claims = { UserClaim.User }, DeviceIdentifier = deviceIdentifier }; }
public virtual AuthorizationResult Authorize(OpenAuthenticationParameters parameters) { var userFound = _openAuthenticationService.GetUser(parameters); var userLoggedIn = _currentActivity.CurrentAccount.IsRegistered() ? _currentActivity.CurrentAccount : null; if (AccountAlreadyExists(userFound, userLoggedIn)) { if (AccountIsAssignedToLoggedOnAccount(userFound, userLoggedIn)) { // The person is trying to log in as himself.. bit weird return new AuthorizationResult(OpenAuthenticationStatus.Authenticated); } var result = new AuthorizationResult(OpenAuthenticationStatus.Error); result.AddError("Account is already assigned"); return result; } if (AccountDoesNotExistAndUserIsNotLoggedOn(userFound, userLoggedIn)) { ExternalAuthorizerHelper.StoreParametersForRoundTrip(parameters); if (AutoRegistrationIsEnabled()) { #region Register user var currentAccount = _currentActivity.CurrentAccount; var details = new RegistrationDetails(parameters); var randomPassword = CommonHelper.GenerateRandomDigitCode(20); bool isApproved = _accountSettings.UserRegistrationType == UserRegistrationType.Standard; var registrationRequest = new AccountRegistrationRequest(currentAccount, details.EmailAddress, _accountSettings.UsernamesEnabled ? details.UserName : details.EmailAddress, randomPassword, PasswordFormat.Clear, isApproved); var registrationResult = _accountRegistrationService.RegisterAccount(registrationRequest); if (registrationResult.Success) { //store other parameters (form fields) if (!String.IsNullOrEmpty(details.FirstName)) _genericAttributeService.SaveAttribute(currentAccount, SystemAttributeNames.FirstName, details.FirstName); if (!String.IsNullOrEmpty(details.LastName)) _genericAttributeService.SaveAttribute(currentAccount, SystemAttributeNames.LastName, details.LastName); userFound = currentAccount; _openAuthenticationService.AssociateExternalAccountWithUser(currentAccount, parameters); ExternalAuthorizerHelper.RemoveParameters(); //code below is copied from AccountController.Register method //authenticate if (isApproved) _authenticationService.SignIn(userFound ?? userLoggedIn, false); //notifications if (_accountSettings.NotifyNewRegistration) _workflowMessageService.SendAccountRegisteredNotificationMessage(currentAccount, _localizationSettings.DefaultAdminLanguageId); switch (_accountSettings.UserRegistrationType) { case UserRegistrationType.EmailValidation: { //email validation message _genericAttributeService.SaveAttribute(currentAccount, SystemAttributeNames.AccountActivationToken, Guid.NewGuid().ToString()); _workflowMessageService.SendAccountEmailValidationMessage(currentAccount, _currentActivity.CurrentLanguage.Id); //result return new AuthorizationResult(OpenAuthenticationStatus.AutoRegisteredEmailValidation); } case UserRegistrationType.AdminApproval: { //result return new AuthorizationResult(OpenAuthenticationStatus.AutoRegisteredAdminApproval); } case UserRegistrationType.Standard: { //send account welcome message _workflowMessageService.SendAccountWelcomeMessage(currentAccount, _currentActivity.CurrentLanguage.Id); //result return new AuthorizationResult(OpenAuthenticationStatus.AutoRegisteredStandard); } default: break; } } else { ExternalAuthorizerHelper.RemoveParameters(); var result = new AuthorizationResult(OpenAuthenticationStatus.Error); foreach (var error in registrationResult.Errors) result.AddError(string.Format(error)); return result; } #endregion } else if (RegistrationIsEnabled()) { return new AuthorizationResult(OpenAuthenticationStatus.AssociateOnLogon); } else { ExternalAuthorizerHelper.RemoveParameters(); var result = new AuthorizationResult(OpenAuthenticationStatus.Error); result.AddError("Registration is disabled"); return result; } } if (userFound == null) { _openAuthenticationService.AssociateExternalAccountWithUser(userLoggedIn, parameters); } //authenticate _authenticationService.SignIn(userFound ?? userLoggedIn, false); return new AuthorizationResult(OpenAuthenticationStatus.Authenticated); }
/// <summary> /// Register account /// </summary> /// <param name="request">Request</param> /// <returns>Result</returns> public virtual AccountRegistrationResult RegisterAccount(AccountRegistrationRequest request) { if (request == null) throw new ArgumentNullException("request"); if (request.Account == null) throw new ArgumentException("Can't load current account"); var result = new AccountRegistrationResult(); if (request.Account.IsSearchEngineAccount()) { result.AddError("Search engine can't be registered"); return result; } if (request.Account.IsRegistered()) { result.AddError("Current account is already registered"); return result; } if (String.IsNullOrEmpty(request.Email)) { result.AddError(_localizationService.GetResource("Account.Register.Errors.EmailIsNotProvided")); return result; } if (!CommonHelper.IsValidEmail(request.Email)) { result.AddError(_localizationService.GetResource("Common.WrongEmail")); return result; } if (String.IsNullOrWhiteSpace(request.Password)) { result.AddError(_localizationService.GetResource("Account.Register.Errors.PasswordIsNotProvided")); return result; } if (_accountSettings.UsernamesEnabled) { if (String.IsNullOrEmpty(request.Username)) { result.AddError(_localizationService.GetResource("Account.Register.Errors.UsernameIsNotProvided")); return result; } } //validate unique user if (_accountService.GetAccountByEmail(request.Email) != null) { result.AddError(_localizationService.GetResource("Account.Register.Errors.EmailAlreadyExists")); return result; } if (_accountSettings.UsernamesEnabled) { if (_accountService.GetAccountByUsername(request.Username) != null) { result.AddError(_localizationService.GetResource("Account.Register.Errors.UsernameAlreadyExists")); return result; } } //at this point request is valid request.Account.Username = request.Username; request.Account.Email = request.Email; request.Account.PasswordFormat = request.PasswordFormat; switch (request.PasswordFormat) { case PasswordFormat.Clear: { request.Account.Password = request.Password; } break; case PasswordFormat.Encrypted: { request.Account.Password = _encryptionService.EncryptText(request.Password); } break; case PasswordFormat.Hashed: { string saltKey = _encryptionService.CreateSaltKey(5); request.Account.PasswordSalt = saltKey; request.Account.Password = _encryptionService.CreatePasswordHash(request.Password, saltKey, _accountSettings.HashedPasswordFormat); } break; default: break; } request.Account.Active = request.IsApproved; //add to 'Registered' role var registeredRole = _accountService.GetAccountRoleBySystemName(SystemAccountRoleNames.Registered); if (registeredRole == null) throw new AaronException("'Registered' role could not be loaded"); request.Account.AccountRoles.Add(registeredRole); //remove from 'Guests' role var guestRole = request.Account.AccountRoles.FirstOrDefault(cr => cr.SystemName == SystemAccountRoleNames.Guests); if (guestRole != null) request.Account.AccountRoles.Remove(guestRole); _accountService.UpdateAccount(request.Account); return result; }
public override AsyncUnaryCall <AccountRegistrationResponse> RegisterAccountAsync(AccountRegistrationRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken)) { AsyncUnaryCall <AccountRegistrationResponse> response = base.RegisterAccountAsync(request, headers, deadline, cancellationToken); response.ResponseAsync.ContinueWith((authResponse) => { Auth.Login(authResponse.Result.Token); }); return(response); }
public override AsyncUnaryCall <AccountRegistrationResponse> RegisterAccountAsync(AccountRegistrationRequest request, CallOptions options) { AsyncUnaryCall <AccountRegistrationResponse> response = base.RegisterAccountAsync(request, options); response.ResponseAsync.ContinueWith((authResponse) => { Auth.Login(authResponse.Result.Token); }); return(response); }
public async Task <HttpOperationResponse <object> > PostRegisterWithHttpMessagesAsync(AccountRegistrationRequest registrationRequest, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (registrationRequest == null) { throw new ValidationException(ValidationRules.CannotBeNull, "registrationRequest"); } // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("registrationRequest", registrationRequest); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "PostRegister", tracingParameters); } // Construct URL var _baseUrl = Client.BaseUri.AbsoluteUri; var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/account/register").ToString(); // Create HTTP transport objects var _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("POST"); _httpRequest.RequestUri = new System.Uri(_url); // Set Headers if (customHeaders != null) { foreach (var _header in customHeaders) { if (_httpRequest.Headers.Contains(_header.Key)) { _httpRequest.Headers.Remove(_header.Key); } _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value); } } // Serialize Request string _requestContent = null; if (registrationRequest != null) { _requestContent = Microsoft.Rest.Serialization.SafeJsonConvert.SerializeObject(registrationRequest, Client.SerializationSettings); _httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8); _httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 200) { var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); if (_httpResponse.Content != null) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); } else { _responseContent = string.Empty; } ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new HttpOperationResponse <object>(); _result.Request = _httpRequest; _result.Response = _httpResponse; // Deserialize Response if ((int)_statusCode == 200) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = Microsoft.Rest.Serialization.SafeJsonConvert.DeserializeObject <object>(_responseContent, Client.DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } if (_shouldTrace) { ServiceClientTracing.Exit(_invocationId, _result); } return(_result); }
public static object PostRegister(this IAccount operations, AccountRegistrationRequest registrationRequest) { return(operations.PostRegisterAsync(registrationRequest).GetAwaiter().GetResult()); }
public static async Task <object> PostRegisterAsync(this IAccount operations, AccountRegistrationRequest registrationRequest, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.PostRegisterWithHttpMessagesAsync(registrationRequest, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public async Task <Response <AuthenticationResult> > Register([FromBody] AccountRegistrationRequest request) { return(await _accountService.RegisterAsync(request)); }