public async Task <ActionResult <AuthenticatedUser> > Register([FromBody] RegisterCredentials credentials) { var isAdded = await _users.AddUserAsync(credentials); if (isAdded) { var user = await _authenticateService.Authenticate(new LoginCredentials() { Email = credentials.Email, Password = credentials.Password }); if (user != null) { var transaction = await _transactions.CreateTransactionAsync(null, user.Id, REGISTRATION_BONUS, DateTime.Now); if (transaction != null) { var result = await _transactions.CommitTransactionAsync(transaction); if (result != null) { return(Ok(user)); } } } return(BadRequest(new { message = "Registration failed" })); } else { return(BadRequest(new { message = "User already registered" })); } }
public async Task <IActionResult> Register([FromBody] RegisterCredentials userDetails) { if (!ModelState.IsValid || userDetails == null) { return(new BadRequestObjectResult(new { Message = "User Registration Failed" })); } var identityUser = new ApplicationUser() { UserName = userDetails.username, Email = userDetails.Email }; var result = await userManager.CreateAsync(identityUser, userDetails.Password); if (!result.Succeeded) { var dictionary = new ModelStateDictionary(); foreach (IdentityError error in result.Errors) { dictionary.AddModelError(error.Code, error.Description); } return(new BadRequestObjectResult(new { Message = "User Registration Failed", Errors = dictionary })); } return(Ok(new { Message = "User Reigstration Successful" })); }
public async Task <string> Register(RegisterCredentials registerCredentials) { var userExists = await _userManager.FindByEmailAsync(registerCredentials.Email); if (userExists != null) { throw new UserAlreadyExistsException("User already exists"); } User user = new User() { UserName = registerCredentials.Username, Email = registerCredentials.Email, SecurityStamp = Guid.NewGuid().ToString(), }; var result = await _userManager.CreateAsync(user, registerCredentials.Password); if (!result.Succeeded) { throw new UnexpectedException("Unexpected user registration fail"); } var userRoles = await _userManager.GetRolesAsync(user); var token = _jwtService.GenerateJwtToken(user, userRoles); return(token); }
public async Task <IActionResult> RegisterAccount([FromBody] RegisterCredentials credentials) { if (!credentials.Password.Equals(credentials.RePassword)) { return(BadRequest(new List <IdentityError>() { new IdentityError() { Description = "Passwords are not the same!" } })); } var user = new CustomIdentityUser() { First = credentials.First, Last = credentials.Last, UserName = credentials.Email, Email = credentials.Email }; var result = await userManager.CreateAsync(user, credentials.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } await signInManager.SignInAsync(user, false); return(Ok(CreateToken(user))); }
public IHttpActionResult Post(RegisterCredentials registerCredentials) { if (registerCredentials != null) { try { DebugLog.Logar(registerCredentials.Id.ToString()); Funcionario funcionario = db.Funcionarios.Where(x => x.Id == registerCredentials.Id && x.Senha == registerCredentials.Senha).Include(f => f.Cargo).FirstOrDefault(); if (funcionario == null) { return(Json("invalido")); } return(Json(funcionario)); } catch (Exception e) { DebugLog.Logar(e.Message); DebugLog.Logar(e.StackTrace); return(Json("Erro ao cadastrar solicitação!")); } } return(Ok("registerCredentials Null")); }
public string Register(RegisterCredentials credentials) { if (repo.Register(credentials)) { return(repo.GenerateToken(credentials.Username)); } throw new FaultException("User already exist!"); }
public async Task <IActionResult> Register([FromBody] RegisterCredentials credentials) { if (ModelState.IsValid) { return(await _accountsService.Register(credentials)); } return(Error("Unexpected error")); }
public void RegistrarUsuario(RegisterCredentials credentials) { String user = credentials.Nombre + " " + credentials.Apellidos; DateTime fecha = DateTime.Now; String rol = "cliente"; UsuarioDTO u = new UsuarioDTO(credentials.Password, user, credentials.Nombre, credentials.Apellidos, credentials.Email, rol, fecha); this.context.Usuario.Add(u); this.context.SaveChanges(); }
public async Task <OneOf <Ok, LoginOccupied> > Handle(RegisterCommand request, CancellationToken cancellationToken) { var credentials = new RegisterCredentials( request.RegisterDTO.Login, request.RegisterDTO.Password, request.RegisterDTO.Username ); var serviceResponse = await _usersService.RegisterUser(credentials); return(serviceResponse); }
public async Task <Response <LoggedUser> > Register(RegisterCredentials credentials, string userRole) { var existingUser = await userManager.FindByEmailAsync(credentials.Email); if (existingUser != null) { return(Response <LoggedUser> .Failure(ResponseResult.BadRequestStructure, $"Użytkownik o adresie e-mail: {credentials.Email} już istnieje!")); } var existingRole = await roleManager.RoleExistsAsync(userRole); if (!existingRole) { return(Response <LoggedUser> .Failure(ResponseResult.ResourceDoesntExist, $"Rola: {userRole} nie istnieje w systemie!")); } var user = new AppUser { FirstName = credentials.FirstName, LastName = credentials.LastName, UserName = $"{credentials.FirstName}{credentials.LastName}{Guid.NewGuid().ToString()}", Email = credentials.Email, Tags = new Collection <Tag>(), TodoSets = new Collection <TodoSet>(), }; var result = await userManager.CreateAsync(user, credentials.Password); if (!result.Succeeded) { return(Response <LoggedUser> .Failure(ResponseResult.InternalError, "Nie udało się utworzyć nowego użytkownika")); } await userManager.AddToRoleAsync(user, userRole); await userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, userRole)); var logged = new LoggedUser { Id = user.Id, FirstName = user.FirstName, LastName = user.LastName, UserName = user.UserName, PhoneNumber = user.PhoneNumber, Email = user.Email, Token = webTokenGenerator.CreateToken(user, userRole) }; return(Response <LoggedUser> .Success(ResponseResult.DataObtained, logged)); }
public async Task <OneOf <Ok, LoginOccupied> > RegisterUser(RegisterCredentials userRegister) { if (await _usersRepository.LoginOccupied(userRegister.Login)) { return(new LoginOccupied()); } var user = new User(userRegister.Login, userRegister.Password, userRegister.Username); _usersRepository.Add(user); await _usersRepository.SaveChangesAsync(); return(new Ok()); }
public HttpResponseMessage Post(RegisterCredentials credentials) { if (!ModelState.IsValid) { return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage))); } try { this.repo.RegistrarUsuario(credentials); return(Request.CreateResponse(HttpStatusCode.OK, "Todo perfecto! Pruebe a loguearse.")); } catch (Exception ex) { return(Request.CreateResponse(HttpStatusCode.BadRequest, ex)); } }
public async Task <IActionResult> Register([FromBody] RegisterCredentials registerCredentials) { try { var token = await _authenticationService.Register(registerCredentials); return(Ok(token)); } catch (Exception error) when(error is UserAlreadyExistsException) { return(Conflict(error.Message)); } catch (Exception error) when(error is UnexpectedException) { return(StatusCode(StatusCodes.Status500InternalServerError, error.Message)); } }
public async Task <ActionResult <LoginResponse> > Register(RegisterCredentials registerCredentials) { try { var loginResponse = await _userService.RegisterAsync(registerCredentials); if (loginResponse == null) { return(BadRequest("Error during registration")); } return(loginResponse); } catch (ArgumentException ex) { return(BadRequest(ex.Message)); } }
public async Task <IActionResult> Register(RegisterCredentials register) { var user = new AppUser { UserName = register.UserName, FirstName = register.FirstName, LastName = register.LastName, Email = register.Email }; var result = await _userManager.CreateAsync(user, register.Password); if (result.Succeeded) { return(Ok(user)); } return(BadRequest(result.Errors)); }
public bool Register(RegisterCredentials credentials) { var user = context.Products.SingleOrDefault(x => x.Username == credentials.Username); if (user == null) { var newUser = new AppUser() { IsAuth = true, Name = credentials.Name, PasswordHash = credentials.Password, Username = credentials.Username, Account = new UserAccount() }; context.Products.Add(newUser); context.SaveChanges(); return(true); } return(false); }
public static void Register() { if (token == null) { string username, password, name; Console.Write("Name:"); name = Console.ReadLine(); Console.Write("Username:"******"Password[4 chars]:"); password = Console.ReadLine(); if (String.IsNullOrEmpty(username) || String.IsNullOrEmpty(password) || String.IsNullOrEmpty(name)) { return; } if (password.Length != 4) { Console.WriteLine("--> Password lenght must be 4 <--"); } try { RegisterCredentials cred = new RegisterCredentials(name, username, password); token = authService.Register(cred); Console.WriteLine($"--> Logged In! <--"); } catch (FaultException ex) { token = null; Console.WriteLine($"--> {ex.Message} <--"); } } else { Console.WriteLine("--> Already Logged In! <--"); } }
public async Task <IActionResult> Register([FromBody] RegisterCredentials credentials) { if (ModelState.IsValid) { var user = new IdentityUser { UserName = credentials.Email, Email = credentials.Email }; var result = await _userManager .CreateAsync(user, credentials.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } await _signInManager.SignInAsync(user, isPersistent : false); return(Ok("User Created.")); } return(BadRequest()); }
public ActionResult Register(RegisterCredentials model) { if (!UserProvider.ValidateLogin(model.Login)) ModelState.AddModelError("Login", "Логин не соответствует требованиям"); if (!UserProvider.ValidateEmail(model.Email)) ModelState.AddModelError("Email", "Email не соответствует требованиям"); if (!UserProvider.ValidatePassword(model.Password)) ModelState.AddModelError("Password", "Пароль не соответствует требованиям"); if (string.Compare(model.Password, model.RePassword) != 0) ModelState.AddModelError("RePassword", "Пароли не совпадают"); if (!ModelState.IsValid) { model.Password = string.Empty; model.RePassword = string.Empty; return View(model); } MembershipCreateStatus status; string Password = model.Password; Membership.Provider.CreateUser(model.Login, model.Password, model.Email, string.Empty, string.Empty, false, null, out status); switch (status) { case MembershipCreateStatus.InvalidEmail: ModelState.AddModelError("Email", "Email не соответствует требованиям"); break; case MembershipCreateStatus.DuplicateEmail: ModelState.AddModelError("Email", "Такой email уже зарегистрирован"); break; case MembershipCreateStatus.InvalidUserName: ModelState.AddModelError("Login", "Логин не соответствует требованиям"); break; case MembershipCreateStatus.DuplicateUserName: ModelState.AddModelError("Login", "Такой логин уже зарегистрирован"); break; case MembershipCreateStatus.Success: { SendActivationEmail(model.Email, Password); Common.SetSessionMessage(Session, "Вы успешно зарегистрировались на сайте. На Ваш email выслано письмо с инструкциями по активации Вашей учётной записи.", "Регистрация"); return RedirectToAction("Result", "Home"); } default: Common.SetSessionMessage(Session, "Ошибка регистрации нового пользователя: "+status.ToString(), "Регистрация"); return RedirectToAction("Result", "Home"); } return View(model); }
private string ValidateRecoveryCredentials(RegisterCredentials u) { string sql = @"select UserId from cycli_riders where UserName=@username and Email=@email and (AccountStatus='Active' or AccountStatus='Reset')"; // Check against the database SQLiteDatabase db = new SQLiteDatabase(); string userId = db.ExecuteScalar(sql, "@username", u.username, "@email", u.email); if (!string.IsNullOrEmpty(userId)) { string hash = PasswordHash.CreateHash(u.password); string code = Guid.NewGuid().ToString(); sql = @"update cycli_riders set activationcode=@a, AccountStatus='Reset', password=@p where userid=@u and AccountStatus='Active'"; if (db.ExecuteNonQuery(sql, "@a", code,"@p", hash, "@u", userId) > 0) { Emailer.SendRecoveryConfirmation(u.username, userId, code, u.email); } } db.Close(); return userId; }