public async Task <IdentityResult> CreateAsync(SignupDto dto) { var user = _mapper.Map <User>(dto); user.UserName = user.Email; IdentityResult result = await _userManager.CreateAsync(user, user.Password); if (result.Succeeded) { } object data = new { email = user.Email, firstName = user.FirstName, lastName = user.LastName, created_at = DateTime.Now, last_login = DateTime.Now, phones = user.Phones }; //_repositoryFacade.SetCache( // user.Email.ToString(), JsonConvert.SerializeObject( // data, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.Indented })); return(result); }
public async Task <IActionResult> CreateUserAsync([FromBody] SignupDto dto, [FromServices] IValidator <SignupDto> validator) { var validated = await validator.ValidateAsync(dto); if (!validated.IsValid) { return(UnprocessableEntity(validated.Errors.Select(e => new { message = e.ErrorMessage, statusCode = e.ErrorCode }).Distinct())); } var user = this._mapper.Map <ApplicationUser>(dto); user.CreatedAt = DateTime.Now; IdentityResult result = await _userManager.CreateAsync(user, user.Password); if (result.Succeeded) { var response = await _userManager.FindByEmailAsync(user.Email); if (response != null) { return(Ok(new { message = "successful operation", statusCode = 200 })); } return(BadRequest()); } return(UnprocessableEntity(result.Errors.Where(e => e.Code.ToUpper() == "DuplicateEmail".ToUpper()).Select(e => new { message = "E-mail already exists", statusCode = 422 }).Distinct())); }
/// <summary> /// Signups the specified new user. /// </summary> /// <param name="newUser">The new user.</param> /// <returns></returns> public bool Signup(SignupDto newUser) { User user = new User(); var checkUser = glitteDb.Users.Where(i => i.Email == newUser.Email).SingleOrDefault(); try { if (checkUser == null) { user.Firstname = newUser.Firstname; user.Lastname = newUser.Lastname; user.Image = newUser.Image; user.Country_id = newUser.Country_id; user.Email = newUser.Email; user.Password = newUser.Password; user.Phone = newUser.Phone; glitteDb.Users.Add(user); glitteDb.SaveChanges(); return(true); } } catch (Exception) { return(false); } return(false); }
public async Task <User> Create(SignupDto user) { // validation if (string.IsNullOrWhiteSpace(user.Password)) { throw new Exception("Password is required"); } if (await _context.Users.AnyAsync(x => x.Username == user.Username)) { throw new Exception($"Username {user.Username} is already taken"); } User newUser = new User(); if (newUser.Id == null) { newUser.Id = Guid.NewGuid().ToString(); } byte[] passwordHash, passwordSalt; CreatePasswordHash(user.Password, out passwordHash, out passwordSalt); newUser.Email = user.Email; newUser.Username = user.Username; newUser.Name = user.Name; newUser.PasswordHash = passwordHash; newUser.PasswordSalt = passwordSalt; _context.Users.Add(newUser); _context.SaveChanges(); return(newUser); }
public bool Signup(SignupDto userData) { if (ModelState.IsValid) { UserBll userBll = new UserBll(); return(userBll.Signup(userData)); } return(false); }
public async Task SignupUser(SignupDto entity) { var userToDb = _mapper.Map <SignupDto, User> (entity); if (userToDb != null) { await _userManager.CreateAsync(userToDb, entity.Password); } }
public async Task <ActionResult> SignUpUser([FromBody] SignupDto user) { if (user == null) { return(BadRequest()); } await _uow.UserRepository.SignupUser(user); return(Ok(user)); }
public async Task <IDataResult <ApplicationUser> > SignUp(SignupDto registerDto) { var result = await _userManager.CreateAsync(new ApplicationUser { UserName = registerDto.Email, Email = registerDto.Email }, registerDto.Password); if (result.Succeeded) { var user = await _userManager.FindByEmailAsync(registerDto.Email); return(new SuccessDataResult <ApplicationUser>(user, "Başaıyla kaydedildi")); } return(new ErrorDataResult <ApplicationUser>("Kayıt Başarısız")); }
public async Task <IActionResult> SignUp(SignupDto signupDto) { var user = new ApplicationUser { UserName = signupDto.UserName, Email = signupDto.Email }; var result = await this.userService.CreateAsync(user, signupDto.Password); return(Ok(result)); }
public async Task <ActionResult> Signup([FromBody] SignupDto signupDto) { try { await this.UserService.Signup(signupDto.username, signupDto.password); return(Ok(new { message = "Ok!" })); } catch (Exception e) { return(BadRequest(new { error = e.Message })); } }
public async Task <IActionResult> SignUp(SignupDto signupDto) { var user = new ApplicationUser { UserName = signupDto.Username, Email = signupDto.Email, City = signupDto.City }; var result = await _userManager.CreateAsync(user, signupDto.Password); //password hashleneceği için yukarı yazmadık if (!result.Succeeded) { return(BadRequest(Response <NoContent> .Fail(result.Errors.Select(x => x.Description).ToList(), 400))); } return(NoContent()); }
public async Task <IActionResult> SignupAsync(SignupDto dto) { var result = await _homeService.CreateAsync(dto); if (result.Succeeded) { _logger.LogInformation("會員 {0} 註冊成功", dto.Account); return(Ok(result.Data)); } foreach (var error in result.Errors) { ModelState.AddModelError(error.Code, error.Description); } return(ValidationProblem()); }
public async Task <IActionResult> Signup(SignupDto data) { try { var signupData = _mapper.Map <User>(data); _authenticationService.Register(signupData, data.Password); await _unitOfWork.Save(); var authData = _mapper.Map <AuthDto>(signupData); return(Ok(authData)); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <IActionResult> Signup([FromBody] SignupDto user) { try { if (user.Password != user.ConfirmPassword) { return(BadRequest("Passwords do not match")); } var newUser = await _userService.Create(user); return(Ok(newUser)); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <IActionResult> SignupAsync([FromBody] SignupDto signupDto, [FromServices] IValidator <SignupDto> validator) { var validated = await validator.ValidateAsync(signupDto); if (!validated.IsValid) { return(BadRequest(validated.Errors.Select(e => new { message = e.ErrorMessage, statusCode = e.ErrorCode }).Distinct())); } var result = await _authService.CreateAsync(signupDto); if (!result.Succeeded) { return(Ok(result.Errors.Select(e => new { message = "E-mail already exists", statusCode = 409 }))); } return(Ok(new { message = "user created", statusCode = 201 })); }
public async Task <IActionResult> SignUp(SignupDto signupDto) { var user = new ApplicationUser { UserName = signupDto.UserName, Email = signupDto.Email, City = signupDto.City }; var result = await _userManager.CreateAsync(user, signupDto.Password); if (!result.Succeeded) { return(BadRequest(Response <NoContent> .Fail(result.Errors.Select(x => x.Description).ToList(), (int)ResponseCodes.BadRequest))); } return(NoContent()); }
public async Task <IActionResult> Register(SignupDto signupDto) { var userExists = await _authService.UserExists(signupDto.Email); if (!userExists.IsSuccess) { return(BadRequest(userExists.Message)); } var registerResult = await _authService.SignUp(signupDto); var result = _authService.CreateAccessToken(registerResult.Data, ipAddress()); if (result.IsSuccess) { return(Ok(result.Data)); } return(BadRequest(result.Message)); }
public async Task <ActionResult <SignupResponseDto> > SignupUser([FromBody] SignupDto signupDetails) { // Handle HTTP requests // Validate incoming models // Pass on to the relevant service // Catch any errors // Return response with valid codes if (signupDetails == null) { throw new BusinessException("No signup details provided"); } if (!ModelState.IsValid) { throw new BusinessException("Invalid model object"); } //additional code var response = await _userService.SignupsUserAsync(signupDetails); return(response); }
public async Task <IActionResult> Signup(SignupDto signup) { if (await _userManager.Users.AnyAsync(u => u.Email == signup.Email.ToLower())) { ModelState.AddModelError("EmailAddress", "An account with that email address already exists"); return(new UnprocessableEntityObjectResult(new ValidationProblemDetails(ModelState))); } var user = new AppUser { Email = signup.Email, UserName = signup.Email }; var result = await _userManager.CreateAsync(user, signup.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.AddModelError(error.Code, error.Description); } return(new UnprocessableEntityObjectResult(new ValidationProblemDetails(ModelState))); } return(CreatedAtAction( actionName: nameof(UsersController.GetUser), controllerName: UsersController.ControllerName, routeValues: new { userId = user.Id }, value: new UserDto { Email = user.Email, PhoneNumber = user.PhoneNumber, UserId = user.Id, Username = user.UserName })); }
public async Task <ApplicationResult <Member> > CreateAsync(SignupDto dto) { var member = await FindByAccountAsync(dto.Account); if (member == null) { return(ApplicationResult <Member> .Failed(new ApplicationError { Code = nameof(Member.Account), Description = "會員已存在!" })); } var newMemberSeq = Guid.NewGuid(); var newMember = new FdMember() { MemberSeq = newMemberSeq, Account = dto.Account, Password = dto.Password, CreateTime = DateTime.Now, UpdateTime = DateTime.Now }; await _memberRepository.InsertAsync(newMember); var effectRows = await _unitOfWork.SaveChangesAsync(); var result = effectRows > 0 ? ApplicationResult <Member> .Success : ApplicationResult <Member> .Failed(); if (result.Succeeded) { result.Data = _mapper.Map <Member>(newMember); } return(result); }
public bool Signup(SignupDto newUser) { operationOnUser = new UserOperation(); return(operationOnUser.Signup(newUser)); }
public async Task <SignupResponseDto> SignupsUserAsync(SignupDto signup) { // Use the User ID to retrieve the user that is not verified var user = await _userRepository.FindByIdAsync(signup.UserId); if (user == null) { throw new BusinessException("User ID does not exist."); } else if (user.IsInitialised) { throw new BusinessException("User is already initialised."); } // Initialise generator for later var generator = RandomNumberGenerator.Create(); // Name validation if (signup.Name.Length < 3 || signup.Name.Length > 64) { throw new BusinessException("Name length must be between 4-64 characters."); } // Password validation if (signup.Password.Length == 2048) { throw new BusinessException("Josh, let's not get ahead of ourselves."); } else if (signup.Password.Length < 10 || signup.Password.Length > 1024) { throw new BusinessException("Password must be between 10-1024 characeters."); } // Check if MFA is required if (user.MFAEnabled) { // Generate a new TOTP Code if (user.TOTPSecret == "" || signup.MFACode == "") { // Generate TOTP byte[] rndArray = new byte[30]; generator.GetBytes(rndArray); // var totpSecret = ByteStringConversion.ToString(rndArray); var totpSecret = Base32Encoding.ToString(rndArray); if (totpSecret == null || totpSecret == "") { throw new BusinessException("Error when trying to create MFA code for user, please tell Dave there is an issue."); } // Add it to user user.TOTPSecret = totpSecret; // Save the user _userRepository.Update(user); await _unitOfWork.CompleteAsync(); // Return TOTP value return(new SignupResponseDto(false, totpSecret)); } else // Attempt to validate incoming code { var totp = new Totp(Base32Encoding.ToBytes(user.TOTPSecret)); long timeWindowUsed = 0; var isValid = totp.VerifyTotp(signup.MFACode, out timeWindowUsed, VerificationWindow.RfcSpecifiedNetworkDelay); if (!isValid) { throw new BusinessException("The MFA Code provided was not valid. Please try again."); } } } // If all previous requirements are met: // generate the salt byte[] saltRndArray = new byte[32]; generator.GetBytes(saltRndArray); var salt = ByteStringConversion.ToString(saltRndArray); // hash the salt and password var hashedPassword = ""; using (SHA256 sha256Hash = SHA256.Create()) { // ComputeHash - returns byte array byte[] hashedPasswordByteArray = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(salt + signup.Password)); hashedPassword = ByteStringConversion.ToString(hashedPasswordByteArray); } // set the salt and password hash for the user if (salt != "" || hashedPassword != "") { user.PasswordSalt = salt; user.PasswordHash = hashedPassword; } // Set the name user.Name = signup.Name; // Set the initialised flag user.IsInitialised = true; _userRepository.Update(user); await _unitOfWork.CompleteAsync(); return(new SignupResponseDto(true, "")); }
public IActionResult SetupMFA([FromBody] SignupDto signupDetails) { throw new NotImplementedException(); }