public async Task <ActionResult <AppUser> > Login(RegisterUserDto registerUserDto) { var user = await _context.Users.SingleOrDefaultAsync(user => user.UserName == registerUserDto.UserName); if (user == null) { return(Unauthorized("User does not exists")); } using var hmac = new HMACSHA512(user.PasswordSalt); var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerUserDto.Password)); for (int index = 0; index < user.PasswordHash.Length; index++) { if (computedHash[index] != user.PasswordHash[index]) { return(Unauthorized("Invalid password")); } } return(user); }
public async Task <bool> Register(RegisterUserDto model) { //if (!ModelState.IsValid) //{ // return BadRequest(ModelState); //} var user = new NawafizApp.Services.Identity.IdentityUser() { Email = model.Email, UserName = model.Email, CreationDate = Utils.ServerNow, FullName = model.FullName }; IdentityResult result = await UserManager.CreateAsync(user, model.Password); //if (!result.Succeeded) //{ // return GetErrorResult(result); //} UserManager.AddToRole(user.Id, "ClientRole"); return(true); }
public async Task <ActionResult <UserDto> > Register(RegisterUserDto registerUserDto) { using var hmac = new HMACSHA512(); if (await UserExists(registerUserDto.UserName)) { return(BadRequest("User already exists")); } AppUser appUser = new AppUser { UserName = registerUserDto.UserName.ToLower(), PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerUserDto.Password)), PasswordSalt = hmac.Key }; _context.Users.Add(appUser); await _context.SaveChangesAsync(); return(new UserDto { UserName = registerUserDto.UserName, Token = tokenService.CreateToken(appUser) }); }
public IHttpActionResult RegisterAdminUser([FromBody] RegisterUserDto registerUserDto) { if (!ModelState.IsValid) { return(BadRequest(GeneralErrorMessages.MODEL_STATE_ERROR)); } try { var userManager = new UserManager(); var response = userManager.CreateAdmin(registerUserDto); if (response.Error != null) { return(BadRequest(response.Error)); } return(Created("User has been created: ", registerUserDto.UserAccountDto.Username)); } catch (Exception) { return(InternalServerError()); } }
public void Post(RegisterUserDto registerUser) { //TODO verify facebook //register var user = this.unitOfWork.Users.Get(u => u.FacebookId == registerUser.FacebookId); if (user != null) { //update user.AuthToken = registerUser.AuthToken; user.GCMClientToken = registerUser.GCMClientToken; this.unitOfWork.Users.Update(user); } else { //register var newUser = UserConverter.AsUser.Compile().Invoke(registerUser); this.unitOfWork.Users.Create(newUser); } this.unitOfWork.SaveChanges(); }
public async Task <IActionResult> Register(RegisterUserDto registerUserDto) { if (!ModelState.IsValid) { return(View()); } var errors = new List <String>(); await _userService.Register(registerUserDto, errors); if (errors.Count == 0) { return(RedirectToAction("index", "home")); } foreach (var error in errors) { ModelState.AddModelError("", error); } return(View()); }
public void Execute(RegisterUserDto request) { _validator.ValidateAndThrow(request); _context.Users.Add(new User { FirstName = request.FirstName, LastName = request.LastName, Username = request.Username, Password = request.Password, Email = request.Email, RoleId = request.RoleId }); _context.SaveChanges(); _sender.Send(new SendEmailDto { Content = "<h1>Successfull registration!</h1>", SendTo = request.Email, Subject = "Registration" }); }
public async Task RegisterUser_CompanyNameIsAlreadyRegistered() { var dto = new RegisterUserDto(); dto.UserInfo = new RegisterUserDto.UserInfoDto { FirstName = "Unknown", LastName = "Unknown", Email = "*****@*****.**", Username = "******", Password = "******", Role = "admin" }; dto.CompanyInfo = new RegisterUserDto.CompanyInfoDto { CompanyName = "companyName" }; //var useCase = new RegisterUserCommand(dto); //var request = new RegisterUserCommand.RequestHandler(context, mapper); //await request.Handle(useCase, new CancellationToken()); }
public async Task <AuthTokenDto> RegisterAsync(RegisterUserDto registerUserDto) { var user = await _userRepository.GetAsync(registerUserDto.Email); if (user is not null) { throw new ServiceException(ExceptionMessage.User.EmailAlreadyUsed); } var userId = Guid.NewGuid(); var userSalt = _encryptService.GenerateSalt(); var passwordHash = _encryptService.GetHash(registerUserDto.Password, userSalt); user = new User(userId, new UserIdentity { Email = registerUserDto.Email, Salt = userSalt, Password = passwordHash }); await _userRepository.AddAsync(user); return(_jwtService.GenerateToken(user)); }
public async Task <IActionResult> Register([FromBody] RegisterUserDto registerUserDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var newUser = new User() { Email = registerUserDto.Email, RoleId = registerUserDto.RoleId, Name = registerUserDto.Name }; var passwordHash = _passwordHasher.HashPassword(newUser, registerUserDto.Password); newUser.PasswordHash = passwordHash; await _context.Users.AddAsync(newUser); await _context.SaveChangesAsync(); return(StatusCode(StatusCodes.Status201Created)); }
public async Task <IActionResult> Register([FromBody] RegisterUserDto request) { if (User.Identity.IsAuthenticated) { return(StatusCode(StatusCodes.Status401Unauthorized)); } if (ModelState.IsValid) { RegisterResponse response = new RegisterResponse(); var registrationResultUser = await this.identityService.RegisterUserAsync(request); if (registrationResultUser != null) { response.Success = true; response.Message = "Registration success"; } return(Ok(response)); } return(StatusCode(StatusCodes.Status400BadRequest)); }
public async Task <IActionResult> CreateUser([FromBody] RegisterUserDto userDto) { try { var user = await userService.RegisterUser(userDto); return(Ok(user)); } catch (Exception ex) { return(StatusCode(StatusCodes.Status500InternalServerError, new ResponseDto <List <UserDto> > { Errors = new List <ErrorDto> { new ErrorDto { ErrorCode = 1, ErrorMessage = ex.Message } } })); } }
public HttpResponseMessage RegisterUser(RegisterUserDto dto) { if (!ModelState.IsValid) { var errorList = (from item in ModelState.Values from error in item.Errors select error.ErrorMessage).ToArray(); return(new HttpResponseMessage(HttpStatusCode.BadRequest) { RequestMessage = Request, ReasonPhrase = JsonConvert.SerializeObject(errorList) }); } var resp = courierService.RegisterUser(dto); if (resp == null) { return(new HttpResponseMessage(HttpStatusCode.BadRequest) { RequestMessage = Request, ReasonPhrase = "" }); } return(Request.CreateResponse(HttpStatusCode.OK, resp, "application/json")); }
public async Task <IActionResult> Register(RegisterUserDto model) { var userExists = await _userManager.FindByNameAsync(model.Email); if (userExists != null) { ModelState.AddModelError("UserExcisting", "User already exists!"); return(View(model)); } if (ModelState.IsValid) { User user = new User() { Email = model.Email, SecurityStamp = Guid.NewGuid().ToString(), UserName = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await _signInManager.PasswordSignInAsync(user.Email, model.Password, true, false); await _userManager.AddToRoleAsync(user, UserRoles.User); return(RedirectToAction("Index", "Home")); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } } return(View(model)); }
// RegisterUser <username> <password> <repeat-password> <email> public string Execute(string[] data) { if (data.Length != DataLength) { throw new InvalidOperationException(InvalidCommandMessage); } string username = data[0]; string password = data[1]; string reapeatPassword = data[2]; string email = data[3]; var registerUserDto = new RegisterUserDto { Username = username, Password = password, Email = email }; var userExist = this.userService.Exists(username); if (userExist) { throw new InvalidOperationException(string.Format(RegisterUserMessages.UserIsTakenMessage, username)); } if (password != reapeatPassword) { throw new ArgumentException(RegisterUserMessages.PasswordDontMatchMessage); } this.userService.Register(username, password, email); string result = string.Format(RegisterUserMessages.SuccessMessage, username); return(result); }
public string Execute(string[] data) { string username = data[0]; string password = data[1]; string repeatPassword = data[2]; string email = data[3]; if (userSessionService.IsLoggedIn()) { throw new ArgumentException("You are logged in!"); } if (password != repeatPassword) { throw new ArgumentException("Passwords do not match!"); } RegisterUserDto userDto = new RegisterUserDto { Username = username, Password = password, Email = email }; if (!IsValid(userDto)) { throw new ArgumentException("Invalid user!"); } var isUsernameExist = userService.Exists(username); if (isUsernameExist) { throw new InvalidOperationException($"Username {username} is already taken!"); } userService.Register(username, password, email); return($"User {username} was registered successfully!"); }
public User RegisterUser(RegisterUserDto input) { //checkRole var dataRole = _roles.Find(x => x.roleName == input.RoleName).FirstOrDefault(); if (dataRole == null) { dataRole = new Role { roleName = input.RoleName }; _roles.InsertOne(dataRole); } //checkUser var dataUser = _user.Find(x => x.userName == input.userName).FirstOrDefault(); if (dataUser != null) { throw new Exception("Username Already Exist"); } dataUser = new User { userName = input.userName, email = input.email, phoneNumber = input.phoneNumber, RoleId = dataRole.Id }; dataUser.password = _passwordHasher.HashPassword(dataUser, input.password); _user.InsertOne(dataUser); return(dataUser); }
public void Execute(RegisterUserDto request) { _validator.ValidateAndThrow(request); _context.Users.Include(x => x.UserUseCases); var user = _mapper.Map <User>(request); _context.Users.Add(user); _context.SaveChanges(); // --- OVAJ DEO --- int[] allowedUseCases = new int[] { 3, 6, 12, 13, 17, 18, 19, 20, 21 }; //var id = 1; foreach (var auc in allowedUseCases) { _context.UserUseCase.Add(new UserUseCase { //Id = id, UserId = user.Id, UseCaseId = auc }); //id++; } _context.SaveChanges(); _sender.Send(new SendEmailDto { Subject = "Registration", Content = "<h1>Successffully Registration</h1>", SendTo = request.Email }); }
// RegisterUser <username> <password> <repeat-password> <email> public string Execute(string[] data) { string username = data[0]; string password = data[1]; string repeatPassword = data[2]; string email = data[3]; var registerUserDto = new RegisterUserDto { Username = username, Password = password, Email = email }; this.userService.Register(username, password, email); if (IsValid(registerUserDto)) { throw new ArgumentException("Invalid data!"); } var userExist = this.userService.Exists(username); if (userExist) { throw new InvalidOperationException($"Username {username} is already taken!"); } if (password != repeatPassword) { throw new ArgumentException("Password do not match!"); } this.userService.Register(username, password, email); return($"User {username} was registred successfully!"); }
public bool EmailAfterRegistration(RegisterUserDto registerUserDto) { string subject = "Top Tests Services"; string data = registerUserDto.Name; string htmlBody = @" <html lang=""en""> <body style='width:720px'> <h2>Dear " + registerUserDto.Name + @",</h2> <p style='font-family: Arial,sans-serif'>You have been registered in the online test service. <br> Please confirm registration and follow this link </p> <div style='text-align:center'><a href='http://*****:*****@"' style='font-size:30px'>Change Password</a></div> <p style='font-family: Arial,sans-serif'>We appreciate that you are with us and using service<br>Have a nice day,<br>Testex Education Platform</p> <img src=""cid:WinLogo"" /> </body> </html>"; string messageBody = string.Format(htmlBody, data); AlternateView alternateViewHtml = AlternateView.CreateAlternateViewFromString(htmlBody, Encoding.UTF8, MediaTypeNames.Text.Html); MailMessage mailMessage = new MailMessage("*****@*****.**", registerUserDto.Email, subject, messageBody); mailMessage.AlternateViews.Add(alternateViewHtml); using (SmtpClient smpt = new SmtpClient("smtp.gmail.com", 587)) { smpt.EnableSsl = true; smpt.DeliveryMethod = SmtpDeliveryMethod.Network; smpt.UseDefaultCredentials = false; smpt.Credentials = new NetworkCredential("*****@*****.**", "basket2009"); MailMessage message = new MailMessage(); message.To.Add(registerUserDto.Email); message.From = new MailAddress("*****@*****.**"); message.DeliveryNotificationOptions = DeliveryNotificationOptions.OnFailure; message.Subject = "Top Tests"; message.Body = "Something"; smpt.Send(mailMessage); } return(true); }
public async Task <UserDto> RegisterAsync(RegisterUserDto newUser) { if (newUser == null) { throw new ArgumentNullException(nameof(newUser), "newUser cannot be null"); } var user = _mapper.Map <User>(newUser); var isCurrentUser = await _context.Users.AnyAsync(u => u.Email == user.Email); if (isCurrentUser) { throw new UserExistsException(); } await _context.Users.AddAsync(user); await _unitOfWork.CompleteAsync(); var userDto = _mapper.Map <UserDto>(user); return(userDto); }
public IActionResult Register([FromBody] RegisterUserDto user) { string errCode = "01"; // check email if (!credentialSrvice.CheckEmail(user.Email)) { return(new Response(HttpStatusCode.Conflict, new Error[] { new Error { Code = ErrorCode + errCode + "01", Detail = "This email has already been taken." } }).ToActionResult()); } credentialSrvice.AddUserByUserInfo(user); var payload = new { email = user.Email, password = user.Password }; return(new Response(HttpStatusCode.Accepted, payload).ToActionResult()); }
public ActionResult Register([FromBody] RegisterUserDto registerUserDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var newUser = new User() { Email = registerUserDto.Email, DateOfBirth = registerUserDto.DateOfBirth, Nationality = registerUserDto.Nationality, RoleId = registerUserDto.RoleId }; // Hashed Password is presented for specified user var passwordHash = _passwordHasher.HashPassword(newUser, registerUserDto.Password); newUser.PasswordHash = passwordHash; _meetupContext.Users.Add(newUser); _meetupContext.SaveChanges(); return(Ok()); }
public IDataResult <User> Register(RegisterUserDto registerUserDto) { var validator = new UserValidator(); var validateResult = validator.Validate(registerUserDto); if (!validateResult.IsValid) { var validationErros = ValidationHelper.GetErrors(validateResult.Errors); return(new ErrorDataResult <User>("Kullanıcı oluşturma işlemi başarısız oldu.", validationErros)); } byte[] passwordHash, passwordSalt; HashingHelper.CreatePasswordHash(registerUserDto.Password, out passwordHash, out passwordSalt); var user = new User() { Email = registerUserDto.Email, FullName = registerUserDto.FullName, PasswordHash = passwordHash, PasswordSalt = passwordSalt, Roles = "Owner" }; return(_userDal.Add(user)); }
public async Task Register_Method_Test_CreateUserAsync_Call_Once_Return_Not_Null_Result() { // Arrange var request = new RegisterUserDto(); var model = new RegisterUserViewModel() { Request = request }; var returnModel = new AuthorizationResultDto() { IsSuccessful = true }; _userService.Setup(f => f.CreateUserAsync(model.Request)).ReturnsAsync(returnModel); var controller = new AccountController(_userService.Object); // Act var result = await controller.Register(model); // Assert Assert.IsNotNull(result); _userService.Verify(f => f.CreateUserAsync(request), Times.Once); }
public async Task RegisterUserAsync(RegisterUserDto registerUser) { var user = await _userManager.FindByNameAsync(registerUser.Email); if (user != null) { throw new CaffStoreConflictException("User already registered"); } user = new User { UserName = registerUser.Email, Email = registerUser.Email, FirstName = registerUser.FirstName, LastName = registerUser.LastName, }; var result = await _userManager.CreateAsync(user, registerUser.Password); if (!result.Succeeded) { throw new CaffStoreBusinessException("Registration failed", result.Errors.Select(e => e.Description)); } }
public async Task <IActionResult> Register([FromBody] RegisterUserDto apiRequest) { var request = new GetRiderRequest { Email = apiRequest.Email }; var rider = new Rider { Email = apiRequest.Email, UserName = apiRequest.UserName }; var result = await _userManager.CreateAsync(rider, apiRequest.Password); if (result != IdentityResult.Success) { return(BadRequest()); } await _signInManager.SignInAsync(rider, false); return(Ok()); }
public ActionResult ChangePassword(ChangePasswordDto dto) { var id = getGuid(User.Identity.GetUserId()); if (dto.wantEditpassword) { var u = UserManager.ChangePassword(id, dto.oldPassword, dto.newPassword); if (u.Succeeded) { var user = _UserService.GetById(id); RegisterUserDto userDto = new RegisterUserDto(); userDto.PassWordExpired = false; var result = _UserService.Edit(userDto, id); return(RedirectToAction("index", "Home")); } else { ViewBag.error = "حدث خطأ تأكد من كلمة المرور الخاصة بك وكون الكلمة الجديدة من 6 حروف"; return(View(dto)); } } _UserService.editForAdm(id, dto.fullname, dto.UserName); return(RedirectToAction("index", "Home")); }
// RegisterUser <username> <password> <repeat-password> <email> public string Execute(string[] data) { var userDto = new RegisterUserDto() { Username = data[0], Password = data[1], RepeatPassword = data[2], Email = data[3] }; if (!IsValid(userDto)) { return(InvalidDetails); } if (userService.Exists(userDto.Username)) { return(String.Format(UsernameTaken, userDto.Username)); } if (!userDto.Password.Equals(userDto.RepeatPassword)) { return(PasswordsNotMatch); } try { userService.Register(userDto.Username, userDto.Password, userDto.Email); } catch (Exception ex) { return(ex.Message + ex.InnerException); } return(String.Format(SuccessMessge, userDto.Username)); }
public IHttpActionResult RegisterIndividualUser([FromBody] RegisterUserDto registerUserDto) { // Model Binding Validation if (!ModelState.IsValid) { return(BadRequest(GeneralErrorMessages.MODEL_STATE_ERROR)); } try { var userManager = new UserManager(); var response = userManager.CreateIndividualUser(registerUserDto); if (response.Error != null) { return(BadRequest(response.Error)); } // Sending HTTP response 201 Status return(Created("Individual user has been created: ", registerUserDto.UserAccountDto.Username)); } // Catch exceptions catch (Exception) { return(InternalServerError()); } }