public JsonResult Register(RegisterUserInput input) { //TODO: Return better exception messages! //TODO: Show captcha after filling register form, not on startup! if (!ModelState.IsValid) { throw new UserFriendlyException("Your form is invalid!"); } var recaptchaHelper = this.GetRecaptchaVerificationHelper(); if (String.IsNullOrEmpty(recaptchaHelper.Response)) { throw new UserFriendlyException("Captcha answer cannot be empty."); } var recaptchaResult = recaptchaHelper.VerifyRecaptchaResponse(); if (recaptchaResult != RecaptchaVerificationResult.Success) { throw new UserFriendlyException("Incorrect captcha answer."); } input.ProfileImage = ProfileImageHelper.GenerateRandomProfileImage(); _userAppService.RegisterUser(input); return(Json(new AbpMvcAjaxResponse { TargetUrl = Url.Action("ActivationInfo") })); }
public async Task <ActionResult> Register(RegisterUserInput registerUser) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new IdentityUser { UserName = registerUser.Email, Email = registerUser.Email, EmailConfirmed = true }; var result = await _userManager.CreateAsync(user, registerUser.Password); if (result.Succeeded) { await _signInManager.SignInAsync(user, false); return(Ok(GenerateToken())); } return(BadRequest(string.Join(",", result.Errors.Select(s => s.Description)))); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <AuthenticationPayload> RegisterAsync(RegisterUserInput input, [ScopedService] GeoDbContext context) { var existingUser = context.Users .Where(i => i.Email.ToLower() == input.Email.ToLower()) .SingleOrDefault(); if (existingUser != null) { return(new AuthenticationPayload(null, "User with this email address already exists")); } var salt = HashHelper.GenerateSalt(); var newUser = new User { Email = input.Email, Salt = salt, Hash = HashHelper.GenerateHash(salt, input.Password) }; var createdUser = await context.Users.AddAsync(newUser); await context.SaveChangesAsync(); return(GenerateAuthenticationResultForUser(newUser)); }
/// <summary> /// The Execute /// </summary> /// <param name="input">The input<see cref="RegisterUserInput"/></param> /// <returns>The <see cref="Task"/></returns> public async Task Execute(RegisterUserInput input) { if (input is null) { _outputPort.WriteError(Messages.InputIsNull); _logger.LogInformation("Input is null"); return; } _logger.LogInformation("Validation ok, Registering new user detail.."); input.User.Guid = Guid.NewGuid().ToString(); await _userRepository.Insert(input.User); var lastInsertedId = 1; if (lastInsertedId <= 0) { _logger.LogInformation(Messages.CouldNotRegister); this._outputPort.NotFound(Messages.CouldNotRegister); return; } var output = new RegisterUserOutput { Id = lastInsertedId }; _outputPort.Standard(output); }
public async Task <ResponseData <ValidateUserResult> > RegisterUser( [FromBody] RegisterUserInput registerUserInput) { try { if (User.Identity.IsAuthenticated) { if (User.Claims.Single(r => r.Type == "role").Value == Startup.Configuration.GetSection("AccessLevel").GetSection("AccessLevel1").Value) { if (ModelState.IsValid) { return(await manageUserRepository.RegisterUser(registerUserInput.userName, registerUserInput.userPasswordHash, registerUserInput.userRoleID, registerUserInput.userFirstName, registerUserInput.userLastName, registerUserInput.userEmail)); } else { return(new ResponseData <ValidateUserResult>() { responseCode = (int)ResponseStatusEnum.BadRequest, responseStatusDescription = "Bad Request", responseResults = null }); } } else { return(new ResponseData <ValidateUserResult>() { responseCode = (int)ResponseStatusEnum.AuthorizationFail, responseStatusDescription = "Authorization Fail", responseResults = null }); } } else { return(new ResponseData <ValidateUserResult>() { responseCode = (int)ResponseStatusEnum.AuthenticationFail, responseStatusDescription = "Authentication Fail", responseResults = null }); } } catch (Exception ex) { Console.WriteLine(ex.Message.ToString()); return(new ResponseData <ValidateUserResult>() { responseCode = (int)ResponseStatusEnum.APIError, responseStatusDescription = "API Error", responseResults = null }); } }
public async Task <IActionResult> Register(RegisterUserInput input) { if (ModelState.IsValid) { await _userService.RegisterUser(input); return(RedirectToAction("Login")); } return(View(input)); }
public async Task <ApiResult> RegisterUser([FromBody] RegisterUserInput input) { var newUser = new User { UserName = input.UserName, Email = input.Email }; await userService.AddUser(newUser, input.Password, "user", CancellationToken.None); return(ApiResult.SuccessResult); }
public async Task <IActionResult> RegisterUser(RegisterUserRequest request) { if (request.Password != request.ConfirmPassword) { // TODO use FluentValidation return(BadRequest("Password and ConfirmPassword does not match")); } var registerUserInput = new RegisterUserInput(request.FirstName, request.LastName, request.Username, request.Email, request.Password); await _registerInputHandler.HandleAsync(registerUserInput, _registerOutputHandler); return(_registerOutputHandler.Result()); }
public async Task <IResult <IAccessTokenOutput> > Handle(RegisterUserInput userInput, CancellationToken cancellationToken) { var validationResult = Validator.Validate(userInput); if (validationResult.Errors.Count > 0) { return(new Result <IAccessTokenOutput>(validationResult.Errors)); } var user = new User { Email = userInput.UserName, UserName = userInput.UserName, FirstName = userInput.FirstName, LastName = userInput.LastName, SecurityStamp = Guid.NewGuid().ToString() }; var identityResult = await UserService.CreateAsync(user, userInput.Password, cancellationToken); if (!identityResult.Succeeded) { return(new Result <IAccessTokenOutput>(identityResult.Errors)); } var linkUserWithRoleResult = await Mediator.Send(new LinkUserAndRoleInput { UserName = userInput.UserName, RoleName = RoleType.Patient.ToString() }, cancellationToken); if (linkUserWithRoleResult.Errors.Count() > 0) { return(new Result <IAccessTokenOutput>(linkUserWithRoleResult.Errors)); } await PatientRepo.AddAsync(new Patient { IdentityUserId = user.Id, }, cancellationToken); await UoW.SaveAsync(cancellationToken); // Auto login after registrаtion (successful user registration should return access_token) return(await Mediator.Send(new UserCredentialsInput() { UserName = userInput.UserName, Password = userInput.Password }, cancellationToken)); }
public async Task <RegisterUserOutput> RegisterUser(RegisterUserInput request) { UserEntity input = new UserEntity() { UserName = request.UserName, Password = request.Password }; var user = await _userRepository.Add(input); return(new RegisterUserOutput() { Method = "RegisterUser", Result = user != default ? "SUCCESS" : "ERROR", Payload = user.CreateDto() });
public async Task <ActionResult <string> > AddUser([FromBody] RegisterUserInput registerUserInput) { try { var result = await _registerUserService.RegisterUser(registerUserInput); return(StatusCode((int)HttpStatusCode.Created, result)); } catch (DefaultException e) { throw new DefaultException(e.StatusCode, e.Message); } catch (Exception) { throw; } }
public void RegisterUser(RegisterUserInput registerUser) { var existingUser = _userRepository.FirstOrDefault(u => u.Email == registerUser.EmailAddress); if (existingUser != null) { if (!existingUser.EmailConfirmed) { SendConfirmationEmail(existingUser); throw new UserFriendlyException("You registered with this email address before (" + registerUser.EmailAddress + ")! We re-sent an activation code to your email!"); } throw new UserFriendlyException("There is already a user with this email address (" + registerUser.EmailAddress + ")! Select another email address!"); } var userEntity = new User { PersonUser = new Person { FirstName = registerUser.Name, LastName = registerUser.LastName, EmailAddresses = new List <Email> { new Email { EmailAddress = registerUser.EmailAddress } }, PhoneNumbers = new PhoneNumber { HomePhoneNumber = registerUser.Phone } }, PhoneNumber = registerUser.Phone, Email = registerUser.EmailAddress, PasswordHash = registerUser.Password, //UserName = registerUser.UserName }; //var userEntity = registerUser; userEntity.PasswordHash = new PasswordHasher().HashPassword(userEntity.PasswordHash); userEntity.EmailConfirmationCode = _userManager.GenerateEmailConfirmationTokenAsync(userEntity.Id).Result; _userRepository.Insert(userEntity); SendConfirmationEmail(userEntity); }
public async Task <string> RegisterPhone(RegisterUserInput input) { #if true if (!input.IsPhoneValid()) { throw new UserFriendlyException(L("InvalidPhoneNumber")); } if (await UserManager.Users.AnyAsync(x => x.PhoneNumber == input.ContactNumber)) { throw new UserFriendlyException(L("PhoneNumberExists")); } return(await Task.Run(() => UserManager.GenerateTempToken(input.ContactNumber))); #else return(await Task.Run(() => string.Empty)); #endif }
//Public Methods public RegisterUserOutput RegisterUser(RegisterUserInput input) { try { RestHTTP http = new RestHTTP(); RestRequest req = new RestRequest("api/accounts/create", RestSharp.Method.POST); req.AddJsonBody(input); RegisterUserOutput response = http.HttpPost <RegisterUserOutput>(req); return(response); } catch (Exception ex) { WriteLogFile.Append("RegisterUser : "); WriteLogFile.Append(ex.Message); WriteLogFile.Append(ex.StackTrace); } return(null); }
public async Task RegisterUserPassingTest() { RegisterUserInput registerUserInput = new RegisterUserInput() { userName = Guid.NewGuid().ToString().Substring(0, 20), userPasswordHash = "bb96c2fc40d2d54617d6f276febe571f623a8dadf0b734855299b0e107fda32cf6b69f2da32b36445d73690b93cbd0f7bfc20e0f7f28553d2a4428f23b716e90", userRoleID = 1, userFirstName = "Test", userLastName = "Free", userEmail = "*****@*****.**" }; string registerUserInputJsonString = JsonConvert.SerializeObject(registerUserInput); HttpResponseMessage httpResponse = await ConnectHelper.HttpPostHelper(httpClient, registerUserInputJsonString, "ManageUser/RegisterUser"); Assert.Equal(httpResponse.StatusCode, HttpStatusCode.OK); var httpResponseContent = JObject.Parse(await httpResponse.Content.ReadAsStringAsync()); Assert.Equal(Convert.ToInt32(httpResponseContent.GetValue("responseCode").ToString()), (int)ResponseStatusEnum.Success); }
public IActionResult RegisterAccount(RegisterUserInput inputUser) { if (string.IsNullOrWhiteSpace(inputUser.Username) || string.IsNullOrWhiteSpace(inputUser.Password) || string.IsNullOrWhiteSpace(inputUser.Captcha)) { _logger.LogInformation("Username, password or captcha is empty."); return(BadRequest()); } if (inputUser.Username.Length > 50) { _logger.LogInformation("Username exceeds permitted length."); return(BadRequest()); } if (!_captcha.VerifyCaptcha(inputUser.Captcha, HttpContext.Connection.RemoteIpAddress, "register")) { _logger.LogInformation("Captcha failed verification"); return(BadRequest()); } if (Guid.TryParse(inputUser.Token, out _) && _memoryCache.TryGetValue("R1" + inputUser.Token, out User cachedUser)) { _memoryCache.Remove("R1" + inputUser.Token); cachedUser.Password = inputUser.Password; cachedUser.Username = inputUser.Username.ToLower(); if (_authHandler.RegisterUser(ref cachedUser)) { _activityLogger.LogRegister(Request.HttpContext.Connection.RemoteIpAddress, cachedUser); return(Ok()); } _logger.LogInformation("Auth handler rejected account."); return(BadRequest()); } _logger.LogInformation("Token is invalid."); return(BadRequest()); }
public void RegisterUser(RegisterUserInput registerUser) { var existingUser = _userRepository.FirstOrDefault(u => u.EmailAddress == registerUser.EmailAddress); if (existingUser != null) { if (!existingUser.IsEmailConfirmed) { SendConfirmationEmail(existingUser); throw new UserFriendlyException("You registere with this email address before (" + registerUser.EmailAddress + ")! We re-sent an activation code to your email!"); } throw new UserFriendlyException("There is already a user with this email address (" + registerUser.EmailAddress + ")! Select another email address!"); } var userEntity = registerUser.MapTo <TaskeverUser>(); userEntity.Password = new PasswordHasher().HashPassword(userEntity.Password); userEntity.GenerateEmailConfirmationCode(); _userRepository.Insert(userEntity); SendConfirmationEmail(userEntity); }
/// <summary> /// 创建用户 /// </summary> /// <param name="input">input</param> /// <returns></returns> public async Task Register(RegisterUserInput input) { await ValidateCode(input.ValidateCode); var user = input.MapTo <User>(); user.IsActive = true; user.Password = new PasswordHasher().HashPassword(input.Password); if (input.ValidateCode.ValidateType == ValidateType.手机) { user.IsPhoneNoConfirm = true; } else { user.IsEmailConfirmed = true; } var identityResult = await UserManager.CreateAsync(user); if (!identityResult.Succeeded) { throw new UserFriendlyException(identityResult.Errors.JoinAsString(" ")); } }
public async Task RegisterUser(RegisterUserInput input) { if (!UserManager.VerifyTempToken(input.ContactNumber, input.VerificationCode)) { throw new UserFriendlyException(L("InvalidPhoneVerificationCode")); } if (string.IsNullOrWhiteSpace(input.Name) || string.IsNullOrWhiteSpace(input.Email)) { throw new UserFriendlyException(L("MissingFields")); } if (await UserManager.Users.AnyAsync(x => x.EmailAddress == input.Email)) { throw new UserFriendlyException(L("EmailExists")); } var user = User.CreateAppUser(input.ContactNumber, input.Name, input.Email, input.Password); user.SetNormalizedNames(); var userId = await UserManager.CreateUserAndGetIdAsync(user); await CurrentUnitOfWork.SaveChangesAsync(); }
public virtual async Task RegisterUser(RegisterUserInput input) { Ensure.NotNull(input, nameof(input)); await _userManager.RegisterUser(input.TenantName, input.CellPhone, input.UserName); }
public async Task <IActionResult> Register(RegisterUserInput model, CancellationToken cancellationToken) { var result = await Mediator.Value.Send(model, cancellationToken); return(PresentResult(result)); }
public async Task <IActionResult> Register(RegisterUserInput model) { var result = await RegisterUserCommand.Value.RegisterAsync(model); return(PresentResult(result)); }
public async Task <bool> VerifyPhone(RegisterUserInput input) { return(await Task.Run(() => UserManager.VerifyTempToken(input.ContactNumber, input.VerificationCode))); }
public IHttpActionResult RegisterUser(RegisterUserInput input) { RegisterUserOutput output = _authSvc.RegisterUser(input); return Ok(output); }