public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration) { //var user = _mapper.Map<User>(userForRegistration); var user = new User { FirstName = userForRegistration.FirstName, LastName = userForRegistration.LastName, UserName = userForRegistration.UserName, Email = userForRegistration.Email, PhoneNumber = userForRegistration.PhoneNumber }; var result = await _userManager.CreateAsync(user, userForRegistration.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } await _userManager.AddToRolesAsync(user, userForRegistration.Roles); return(StatusCode(201)); }
public async Task <IActionResult> Register([FromBody] UserForRegistrationDto userForRegisterDto) { if (!string.IsNullOrEmpty(userForRegisterDto.Username)) { userForRegisterDto.Username = userForRegisterDto.Username.ToLower(); } if (await _repo.UserExists(userForRegisterDto.Username)) { ModelState.AddModelError("Username", "username already exists"); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var userToCreate = new User { UserName = userForRegisterDto.Username }; var createUser = await _repo.Register(userToCreate, userForRegisterDto.Password); return(StatusCode(201)); }
public async Task <IActionResult> Register(UserForRegistrationDto userForRegistrationDto) { var userToCreate = _mapper.Map <User>(userForRegistrationDto); if (await _userManager.FindByEmailAsync(userForRegistrationDto.Email) != null) { return(Conflict("Email aleardy exist")); } var createUserResult = await _userManager.CreateAsync(userToCreate, userForRegistrationDto.Password); if (createUserResult.Succeeded) { if (string.IsNullOrWhiteSpace(userForRegistrationDto.RoleName)) { userForRegistrationDto.RoleName = "Customer"; } var addRoleToUserResult = await _userManager.AddToRoleAsync(userToCreate, userForRegistrationDto.RoleName); if (addRoleToUserResult.Succeeded) { var userToReturn = _mapper.Map <UserForDetailsDto>(userToCreate); return(CreatedAtRoute("GetUser", new { controller = "Users", userId = userToCreate.Id }, userToReturn)); } return(BadRequest(addRoleToUserResult.Errors)); } return(BadRequest(createUserResult.Errors)); }
private User MapUserFromReqToUser(UserForRegistrationDto userFromReq) { User user = new User(); user.City = userFromReq.City; user.CountryId = userFromReq.CountryId; user.Email = userFromReq.Email; user.Name = userFromReq.Name; user.Phone = userFromReq.Phone; user.PostalCode = userFromReq.PostalCode; user.Street = userFromReq.Street; user.Surname = userFromReq.Surname; user.EmailConfirmationToken = Guid.NewGuid().ToString(); user.IsActivated = false; // var country = _context.Countries.FirstOrDefault(c => c.Id == userFromReq.CountryId); // user.Country = country; byte[] passwordHash, passwordSalt; _authService.CreatePasswordHash(userFromReq.Password, out passwordHash, out passwordSalt); user.PasswordHash = passwordHash; user.PasswordSalt = passwordSalt; return(user); }
//[ServiceFilter(typeof(ValidationFilterAttribute))] public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration) { var user = _mapper.Map <User>(userForRegistration); var result = await _userManager.CreateAsync(user, userForRegistration.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } if (!userForRegistration.Roles.Any()) { _logger.LogInfo("Roles doesn't exist in the registration DTO object, adding the default one."); await _userManager.AddToRoleAsync(user, "Manager"); } else { await _userManager.AddToRolesAsync(user, userForRegistration.Roles); } return(StatusCode(201)); }
public async Task <RegistrationResponseDto> Registration(UserForRegistrationDto newUser) { var result = new RegistrationResponseDto(); var user = new IdentityUser { UserName = newUser.Email, Email = newUser.Email }; var createResult = await _userManager.CreateAsync(user, newUser.Password); result.IsSuccessfulRegistration = createResult.Succeeded; if (createResult.Succeeded) { if (_userManager.Options.SignIn.RequireConfirmedAccount) { var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); result.ConfirmCodeForSample = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code)); } } foreach (var error in createResult.Errors) { result.Errors = createResult.Errors.Select(c => c.Description).ToList(); } return(result); }
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistrationDto) { if (!ModelState.IsValid) { return(BadRequest(new RegistrationResponseDto { Errors = ModelState.Values.SelectMany(v => v.Errors.Select(b => b.ErrorMessage)) })); } var isEmailFree = await _userService.IsEmailFree(userForRegistrationDto?.Email !); if (!isEmailFree) { return(BadRequest(new RegistrationResponseDto { Errors = new string[] { "Email is linked with an existing account" } })); } var user = _mapper.Map <User>(userForRegistrationDto); user !.UserId = await _userService.GetNextId(); user.Password = BC.HashPassword(user.Password); await _userService.CreateUser(user); return(StatusCode(201)); }
//------------------------------------------------------------------------------------------------- public Result Registration(UserForRegistrationDto user) { Result res; if (user == null) { res = new Result() { Content = "خطایی رخ داده است", Value = false }; } else if ( user.FirstName == null || user.Email == null || user.LastName == null || user.Username == null || user.password == null ) { res = new Result() { Content = "یکی از فیلد های اجباری پرنشده است", Value = false }; } else { res = _repository.Registration(user); } return(res); }
/// <summary> /// Registers new user <see cref="UserForRegistrationDto"/> in the system. /// </summary> /// <param name="user">User for registration</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="InvalidOperationException"></exception> public void Register(UserForRegistrationDto user) { if (user == null) { throw new ArgumentNullException(nameof(user), "User to register cannot be null."); } var query = @"INSERT INTO [User](Id, Username, Password, Email) VALUES(NEWID(), @name, @password, @userEmail)"; using (SqlConnection connection = new SqlConnection(_connectionString)) { DynamicParameters parameters = new DynamicParameters(); parameters.Add("@name", user.Username); if (user.Password != user.ConfirmPassword) { throw new InvalidOperationException("Confirmation password is not equal to the password."); } string hashedPassword = BCrypt.Net.BCrypt.HashPassword(user.Password); parameters.Add("@password", hashedPassword); parameters.Add("@userEmail", user.Email); if (IsUsernameUnique(connection, user.Username) && IsEmailUnique(connection, user.Email)) { connection.Query(query, parameters); } else { throw new InvalidOperationException("User with this username or email already exists."); } } }
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration) { var user = _mapper.Map <User>(userForRegistration); var result = await _userManager.CreateAsync(user, userForRegistration.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } throw ProblemDetailsErrorHelper.ProblemDetailsError(ModelState); } //https://stackoverflow.com/questions/6855624/plus-sign-in-query-string // we need to url encode token because token is not url safe var token = await _userManager.GenerateEmailConfirmationTokenAsync(user); RedirectResult redirectResult = new RedirectResult($"{_frontendConfiguration.BaseUrl}{_frontendConfiguration.AuthenticationControllerName}" + $"{_frontendConfiguration.RegisterConfirm}?email={user.Email}&token={HttpUtility.UrlEncode(token)}"); var message = new Message(user.Email, "Register confirm", redirectResult.Url, redirectResult.Url); await _emailSender.SendEmail(message); return(StatusCode(201)); }
public async Task <IActionResult> Register(UserForRegistrationDto newUser) { newUser.Username = newUser.Username.ToLower(); var userToCreate = _mapper.Map <User>(newUser); IdentityResult createUsrResult = await _userManager.CreateAsync(userToCreate, newUser.Password); if (!createUsrResult.Succeeded) { return(BadRequest(createUsrResult.Errors)); } IdentityResult addRoleResult = await _userManager.AddToRoleAsync(userToCreate, RoleNames.Member); if (!addRoleResult.Succeeded) { return(BadRequest(addRoleResult.Errors)); } userToCreate = await _authRepo.CreateFirstEnvironment(userToCreate); var token = await _userManager.GenerateEmailConfirmationTokenAsync(userToCreate); await _mailer.SendConfirmationMail(userToCreate.Id, userToCreate.Email, token, false); var userToReturn = _mapper.Map <UserForEditDto>(userToCreate); Response.ExposeHeader("location"); return(CreatedAtRoute(nameof(UsersController.GetUser), new { controller = "Users", id = userToReturn.Id }, userToReturn)); }
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration) { if (userForRegistration == null) { _logger.LogError($"Object sent from client is null."); return(BadRequest()); } if (!ModelState.IsValid) { _logger.LogError($"Invalid model state for the object."); } var user = _mapper.Map <User>(userForRegistration); var result = await _userManager.CreateAsync(user, userForRegistration.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } await _userManager.AddToRolesAsync(user, userForRegistration.Roles); return(StatusCode(201)); }
//------------------------------------------------------------------------------------------------- public Result Registration(UserForRegistrationDto user) { Result res = new Result(); var userFromDb = new UserQ().GetUser(user.Username.Trim()); if (userFromDb != null) { res.Value = false; res.Content = "نام کاربری موجود است"; } else { using (_db = new IdeaManagmentDatabaseEntities()) { var newUser = new USER() { EMAIL = user.Email.Trim(), FIRST_NAME = user.FirstName.Trim(), LAST_NAME = user.LastName.Trim(), USERNAME = user.Username.Trim(), PASSWORD = user.password.Trim(), SAVE_DATE = DateTime.Now }; _db.USERS.Add(newUser); _db.SaveChanges(); res.Value = true; res.Content = "کاربر ایجاد شد"; } } return(res); }
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration) { if (userForRegistration == null || !ModelState.IsValid) { return(BadRequest()); } var user = _mapper.Map <User>(userForRegistration); var result = await _userManager.CreateAsync(user, userForRegistration.Password); if (!result.Succeeded) { var errors = result.Errors.Select(e => e.Description); return(BadRequest(new RegistrationResponseDto { Errors = errors })); } var token = await _userManager.GenerateEmailConfirmationTokenAsync(user); var param = new Dictionary <string, string> { { "token", token }, { "email", user.Email } }; var callback = QueryHelpers.AddQueryString(userForRegistration.ClientURI, param); var message = new Message(new string[] { "*****@*****.**" }, "Email Confirmation token", callback, null); await _emailSender.SendEmailAsync(message); await _userManager.AddToRoleAsync(user, "Viewer"); return(StatusCode(201)); }
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration) { var user = _mapper.Map <User>(userForRegistration); var result = await _userManager.CreateAsync(user, userForRegistration.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } var confirmationToken = await _userManager.GenerateEmailConfirmationTokenAsync(user); var confirmationLink = Url.Action(nameof(ConfirmEmail), "Authentication", new { confirmationToken, email = user.Email }, Request.Scheme); var message = new Message(new string[] { user.Email }, "Account confirmation email link", confirmationLink); await _emailSender.SendEmailAsync(message); await _userManager.AddToRolesAsync(user, userForRegistration.Roles); return(StatusCode(201)); }
public async Task <bool> RegisterUser(UserForRegistrationDto userForRegistration, ModelStateDictionary modelState) { _user = _mapper.Map <User>(userForRegistration); var result = await _userManager.CreateAsync(_user, userForRegistration.Password); if (userForRegistration.Password != userForRegistration.ConfirmPassword) { modelState.TryAddModelError("error", "Password mismatch"); return(false); } if (!result.Succeeded) { foreach (var error in result.Errors) { modelState.TryAddModelError(error.Code, error.Description); } return(false); } // await CreateEmailToken(user); userForRegistration.Roles ??= new List <string> { "User" }; await _userManager.AddToRolesAsync(_user, userForRegistration.Roles); return(true); }
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto input) { // TODO: validate input object coming from client and send appropriate response. var user = new User { FirstName = input.FirstName, // Custom property LastName = input.LastName, // Custom property UserName = input.UserName, Email = input.Email, PhoneNumber = input.PhoneNumber }; var result = await _userManager.CreateAsync(user, input.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } // TODO: validate role exists. If not then add user to default role. await _userManager.AddToRolesAsync(user, input.Roles); return(StatusCode(201)); }
public async Task <IActionResult> CreateUser([FromForm] UserForRegistrationDto userRegistrationDetails) { if (userRegistrationDetails == null) { throw new ArgumentNullException(nameof(userRegistrationDetails)); } var result = await _userAdminSvc.CreateUserAsync(userRegistrationDetails).ConfigureAwait(false); string message; if (result != null) { message = $"User successfully created. \"Username\"={userRegistrationDetails.Username}, \"UserId\"={result.UserId}"; _logger.LogInformation(message); Alert(message, AlertType.success); return(RedirectToAction("Index")); } message = $"An error occurred. Could not create user. \"Username\"={userRegistrationDetails.Username}"; _logger.LogError(message); Alert(message, AlertType.danger); return(RedirectToAction("Index")); }
//------------------------------------------------------------------------------------------------- public Result Registration(UserForRegistrationDto user) { Result res; if (user == null) { res = new Result() { content = "خطایی رخ داده است", value = false }; } else if ( user.FIRST_NAME == null || user.EMAIL == null || user.LAST_NAME == null || user.USERNAME == null || user.PASSWORD == null ) { res = new Result() { content = "یکی از فیلد های اجباری پرنشده است", value = false }; } else { res = _repository.Registration(user); } return(res); }
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration) { var user = _mapper.Map <User>(userForRegistration); foreach (var role in userForRegistration.Roles) { if (!await _roleManager.RoleExistsAsync(role)) { return(BadRequest($"{role} role doesn't exist in the database.")); } } var result = await _userManager.CreateAsync(user, userForRegistration.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } await _userManager.AddToRolesAsync(user, userForRegistration.Roles); return(StatusCode(201)); }
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration) { if (userForRegistration == null) { return(BadRequest(new RegistrationResponseDto { Errors = new[] { "Please provide user info in the body" } })); } if (!ModelState.IsValid) { var errors = ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage); return(BadRequest(new RegistrationResponseDto { Errors = errors })); } var user = _mapper.Map <User>(userForRegistration); var result = await _userManager.CreateAsync(user, userForRegistration.Password); if (!result.Succeeded) { var errors = result.Errors.Select(e => e.Description); return(BadRequest(new RegistrationResponseDto { Errors = errors })); } return(StatusCode(201)); }
public async Task <RegistrationResponseDto> RegisterUser(UserForRegistrationDto userForRegistration) { var content = JsonSerializer.Serialize(userForRegistration); var bodyContent = new StringContent(content, Encoding.UTF8, _applicationJson); HttpResponseMessage registrationResult = await _client.PostAsync("api/user/registration", bodyContent); string registrationContent = await registrationResult.Content.ReadAsStringAsync(); var result = JsonSerializer.Deserialize <RegistrationResponseDto>(registrationContent, new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); if (!registrationResult.IsSuccessStatusCode) { return(result); } await _localStorage.SetItemAsync("authToken", result.Token); await _localStorage.SetItemAsync("refreshToken", result.RefreshToken); ((AuthStateProvider)_authStateProvider).NotifyUserAuthentication(result.Token); _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", result.Token); return(new RegistrationResponseDto { IsSuccessfulRegistration = true }); }
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistrationDto) { var user = _mapper.Map <User>(userForRegistrationDto); var result = await _userManager.CreateAsync(user, userForRegistrationDto.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.TryAddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } else { EmailService emailService = new EmailService(); var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); // создаем ссылку для подтверждения var callbackUrl = Url.Action("authentication", "api", new { userId = user.Id, code = code }, protocol: Request.Scheme); // отправка письма await emailService.SendEmailAsync(user.Email, "Подтверждение электронной почты", "Для завершения регистрации перейдите по ссылке:: <a href=\"" + callbackUrl + "\">завершить регистрацию</a>"); } await _userManager.AddToRolesAsync(user, userForRegistrationDto.Roles); return(StatusCode(201)); }
public async Task <IActionResult> Createuser([FromBody] UserForRegistrationDto model) { var result = await _userManager.CreateAsync( new ApplicationUser() { UserName = model.UserName, DisplayName = model.DisplayName, Created = DateTime.Now, IsDeleted = false }, model.Password ); if (result.Succeeded) { var user = _userManager.FindByNameAsync(model.UserName).Result; var selectedRoles = model.Roles; selectedRoles = selectedRoles ?? new string[] { }; result = _userManager.AddToRolesAsync(user, selectedRoles).Result; if (result.Succeeded) { return(Ok()); } return(BadRequest("Failed to add roles")); } return(BadRequest("Failed to register user")); }
public async Task <IActionResult> Register(UserForRegistrationDto userForRegistration) { await _authValidatorService.ValidateForRegistration(userForRegistration); await _authService.Register(userForRegistration); return(Ok()); }
public async Task <IActionResult> Registration([FromBody] UserForRegistrationDto userForRegistration) { if (await _userService.RegisterUser(userForRegistration, ModelState)) { return(StatusCode(201)); } return(BadRequest(ModelState)); }
public async Task <IActionResult> UpdateUser([FromForm] UserForRegistrationDto user) { if (Request.Form.Files.Count != 0) { user.SelecetdFile = Request.Form.Files[0]; } else { user.SelecetdFile = null; } if (user.SelecetdFile != null) { var folderName = Path.Combine("wwwroot", "Images"); var pathToSave = Path.Combine(Directory.GetCurrentDirectory(), folderName); if (user.SelecetdFile.Length > 0) { var objfiles = new DTOProductImage(); var fullPath = Path.Combine(pathToSave, user.SelecetdFile.FileName); var dbPath = Path.Combine("Images", user.SelecetdFile.FileName); using (var stream = new FileStream(fullPath, FileMode.Create)) { user.SelecetdFile.CopyTo(stream); } using (var target = new MemoryStream()) { user.SelecetdFile.CopyTo(target); objfiles.Image = target.ToArray(); } user.ProductImage = objfiles; user.ProductImage.ImagePath = dbPath; } } try { bool success = await _service.UpdateUser(user); if (success) { return(Ok()); } else { return(NotFound()); } } catch { return(NotFound()); } }
public void CreateUserAsync_UserForRegistrationDtoValid_ReturnsUserFullDetailsDto() { var mockDal = Substitute.For <IUserDal>(); var mockLogger = Substitute.For <ILogger <UserAdministrationService> >(); var mockCryptoSvc = Substitute.For <ICryptographyService>(); var adminSvc = new UserAdministrationService(mockLogger, mockDal, mockCryptoSvc); var mockRegistration = new UserForRegistrationDto() { Title = Title.Miss, FirstName = "Aoife", LastName = "McGonagle", Username = "******", Password = "******", ConfirmPassword = "******", JobDescription = "Head Honcho", Role = UserRole.MedicalPractitioner, State = AccountState.Active }; var mockJobDescription = new JobDescription() { Description = "Head Honcho", Role = UserRole.MedicalPractitioner }; var mockEmployeeDetails = new Employee() { Firstname = "Aoife", Lastname = "McGonagle", Title = Title.Miss, }; var mockUser = new User() { EmployeeDetails = mockEmployeeDetails, Username = "******", JobDescription = mockJobDescription, State = AccountState.Active }; mockDal.AddAsync(Arg.Any <User>()).Returns(mockUser); var result = adminSvc.CreateUserAsync(mockRegistration).GetAwaiter().GetResult(); Assert.That(result, Is.Not.Null); Assert.That(result.Title, Is.EqualTo(Title.Miss)); Assert.That(result.Firstname, Is.EqualTo("Aoife")); Assert.That(result.Lastname, Is.EqualTo("McGonagle")); Assert.That(result.Username, Is.EqualTo("amcg")); Assert.That(result.JobDescription, Is.EqualTo("Head Honcho")); Assert.That(result.Role, Is.EqualTo(UserRole.MedicalPractitioner)); Assert.That(result.State, Is.EqualTo(AccountState.Active)); }
public async Task <IActionResult> CreateUser(UserForRegistrationDto userForRegistrationDto) { var userToCreate = new User { Name = userForRegistrationDto.Name }; var createdUser = await _userRepository.CreateUserAsync(userToCreate); return(Ok()); }
public async System.Threading.Tasks.Task <IdentityResult> AddUserAsync(UserForRegistrationDto userForRegistration) { var user = _mapper.Map <User>(userForRegistration); var result = await _userManager.CreateAsync(user, userForRegistration.Password); if (result.Succeeded) { await _userManager.AddToRoleAsync(user, "Developer"); } return(result); }