public async Task <IActionResult> Register([FromBody] RegisterResource resource) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = CreateNewUser(resource); var result = await userManager.CreateAsync(user, resource.Password); if (!result.Succeeded) { return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState))); } if (result.Succeeded) { await userManager.AddToRoleAsync(user, resource.Role); CreateAccount(resource.Role, user.Id); await unitOfWork.CompleteAsync(); //await userManager.AddToRoleAsync(user, adminRole.Name); // var student = new IdentityRole("Student"); // await roleManager.CreateAsync(student); // await roleManager.AddClaimAsync(student, new Claim("student", "true")); // Add to role // await userManager.AddToRoleAsync(user, "Customer"); } return(Ok(new { Id = user.Id, Username = user.UserName })); }
public async Task <IActionResult> Register(RegisterResource model) { try { if (!ModelState.IsValid) { return(BadRequest()); } var user = new ApplicationUser { UserName = model.UserName }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await _signInManager.SignInAsync(user, false); await _userManager.AddToRoleAsync(user, "Admin"); return(Ok()); } AddErrors(result); } catch (Exception e) { return(BadRequest("Somwthing Gone Wrong")); } return(BadRequest()); }
public async Task <IActionResult> RegisterUser([FromForm] RegisterResource resource) { var login = await _userRepository.GetUserByLoginAsync(resource.Login); if (login != null) { return(BadRequest($"Login {resource.Login} already exists")); } var email = await _userRepository.GetUserByEmailAsync(resource.Email); if (email != null) { return(BadRequest($"Email {resource.Email} already exists")); } var hash = _hashService.HashPassword(resource.Password); var register = await _registerUserService.RegisterUser(resource, hash); if (register) { return(Ok("Account has been created")); } return(BadRequest("There was an unexpected error while creating account")); }
public async Task <IActionResult> setRegStudent(RegisterResource register) { var res = await ITeacher.getStudent(register.id); res.IsReg = register.isReg; int x = updateDetails(); #warning Add track on who registered student TeacherController=>serRegStudent() //============notification============= var noti = new StudentNotification(); noti.StudentId = register.id; noti.OtherId = register.otherId; noti.OtherType = "T"; noti.Viwed = false; noti.NotiDate = DateTime.Now.ToString(); if (register.isReg == true) { noti.NotiMessage = "You have been registered"; } else { noti.NotiMessage = "You have been un-registered"; } ITeacher.AdderAsync(noti); ITeacher.Saver(); return(Ok(x)); }
public async Task <IActionResult> PasswordChange(RegisterResource resource) { try { if (!ModelState.IsValid) { return(BadRequest()); } var userId = User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier)?.Value; var user = _userManager.Users.FirstOrDefault(x => x.Id == userId); var result = await _userManager.ChangePasswordAsync(user, resource.Password, resource.ConfirmPassword); if (result.Succeeded) { return(Ok()); } return(BadRequest(result.Errors)); } catch (Exception e) { return(BadRequest()); } }
public async Task <object> Register([FromBody] User user) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var newUser = new User { UserName = user.UserName, Email = user.Email }; var result = await _userManager.CreateAsync(newUser, user.PasswordHash); if (result.Succeeded) { // await _signInManager.SignInAsync(newUser, false); var registerResource = new RegisterResource { Token = _jwtTokenGenerator.GenerateJwtToken(user.UserName, newUser) }; return(registerResource); } foreach (var responseError in result.Errors) { ModelState.AddModelError("errors", responseError.Description); } return(BadRequest(ModelState)); }
public async Task <IActionResult> Register([FromBody] RegisterResource model) { // Validate input fields if (!ModelState.IsValid) { return(BadRequest(ModelState)); } // Mapping the input to model class var currentUser = _mapper.Map <RegisterResource, ApplicationUser>(model); // In this application, UserName itseft is Email currentUser.UserName = model.Email; // Create a new User by User's info and password var createResult = await _userManager.CreateAsync(currentUser, model.Password); // Add roles to the User var roleResult = await _userManager.AddToRoleAsync(currentUser, ApplicationConstants.RoleName.User); var claimResult = await _userManager.AddClaimAsync(currentUser, new Claim(ApplicationConstants.ClaimName.User, "true")); // Add claims as well // Everything is fine, return 200 and log if (createResult.Succeeded && roleResult.Succeeded && claimResult.Succeeded) { _logger.LogInformation(LoggingEvents.Success, "User with email " + model.Email + " created"); return(Ok()); } // Failed at some point, return 400 and the errors return(BadRequest(createResult)); }
public async Task <IActionResult> Register([FromBody] RegisterResource registerResource) { var result = await _authService.RegisterAsync(registerResource); if (!result.Succeeded) { return(BadRequest(result.ErrorMessage)); } return(Ok(result.Data)); }
public async Task <IActionResult> Register([FromBody] RegisterResource registerResource) { var user = _mapper.Map <ApplicationUser>(registerResource); var result = await _authService.RegisterAsync(user, registerResource.Password); if (!result.Succeeded) { return(BadRequest(_response.Error(result.Message))); } return(Ok(_response.Ok(result.Message))); }
public IActionResult CreateUser([FromBody] RegisterResource register) { var user = _mapper.Map <User>(register); try { _userService.Create(user, register.password); return(Ok()); } catch (AppException ex) { return(BadRequest(new { message = ex.Message })); } }
public virtual async Task <IActionResult> Register([FromBody] RegisterResource registerResource) { var register = this.Mapper.Map <Register>(registerResource); var result = await this.authService.Register(register); var resultResource = this.Mapper.Map <RegisterResultResource>(result); if (resultResource.Errors.Any()) { return(this.BadRequest(resultResource.Errors)); } return(this.Ok(resultResource.User)); }
public async Task <Player> Register([FromBody] RegisterResource regsiter) { var player = await _service.RegisterPlayer( regsiter.Fullname, regsiter.Email, regsiter.Phone, regsiter.Age, regsiter.Gender, regsiter.Username, regsiter.Password ); return(player); }
public async Task <IActionResult> Register(RegisterResource resource) { if (await repo.FirstOrDefault(u => u.Email == resource.Email || u.Name == resource.Name) != null) { return(BadRequest("User with that email or name already exists")); } var user = mapper.Map <User>(resource); var registeredUser = await authService.Register(user, resource.Password); var userToReturn = mapper.Map <UserResource>(registeredUser); return(CreatedAtRoute("GetUser", new { controller = "Users", id = registeredUser.Id }, userToReturn)); }
public async Task <bool> RegisterUser(RegisterResource registerResource, string hashPassword) { User user = new User() { Email = registerResource.Email, IsActive = true, Login = registerResource.Login, Name = registerResource.Name, Surname = registerResource.Surname, Password = hashPassword }; await _userRepository.AddUser(user); return(true); }
public async Task <ActionResult> Register([FromBody] RegisterResource register) { if (_context.Users.Any(x => x.Email == register.Email)) { return(Conflict(new { message = "This Email alredy exists" })); } var user = _mapper.Map <RegisterResource, User>(register); await _context.Users.AddAsync(user); await _context.SaveChangesAsync(); return(Ok(user)); }
private AppUser CreateNewUser(RegisterResource resource) { var contact = new Contact { FirstName = resource.FirstName, FatherName = resource.FatherName, GrandFatherName = resource.GrandFatherName, DepartmentId = resource.DepartmentId, }; return(new AppUser { Contact = contact, Email = resource.Email, UserName = resource.Email, SecurityStamp = Guid.NewGuid().ToString() }); }
public async Task <GenericResponse <StatusResponse> > RegisterAsync(RegisterResource registerResource) { var user = await _userManager.FindByEmailAsync(registerResource.Email); if (user != null) { return new GenericResponse <StatusResponse> { Succeeded = false, ErrorMessage = "The user account already exist!" } } ; user = new ApplicationUser { FirstName = registerResource.FirstName, LastName = registerResource.LastName, PhoneNumber = registerResource.PhoneNumber, Email = registerResource.Email, UserName = registerResource.Email, }; var result = await _userManager.CreateAsync(user, registerResource.Password); if (!result.Succeeded) { return new GenericResponse <StatusResponse> { Succeeded = false, ErrorMessage = string.Join(", ", result.Errors.Select(x => x.Description)) } } ; await SendEmailConfirmationLink(user); return(new GenericResponse <StatusResponse> { Succeeded = true, Data = new StatusResponse { Status = $"Registration Successful, check your {user.Email} for link to confirm your email" } }); }
public async Task <IActionResult> Register(RegisterResource model) { try { if (!ModelState.IsValid) { return(BadRequest()); } var user = new ApplicationUser { FirstName = model.FirstName, LastName = model.LastName, Email = model.Email, DateCreated = DateTime.Now, UserName = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { var userInDb = GetUser(user.Email); // await _signInManager.SignInAsync(user, false); var authData = new AuthDataResource { Token = await GenerateJwtToken(userInDb), UserId = userInDb.Id, ExpireTime = DateTime.Now.AddHours(Convert.ToDouble(_configuration["JwtExpireHours"])), FirstName = userInDb.FirstName, LastName = userInDb.LastName }; return(Ok(authData)); } AddErrors(result); } catch (Exception e) { return(BadRequest("Somwthing Gone Wrong")); } return(BadRequest()); }
public async Task<IActionResult> Register([FromBody]RegisterResource registerResource) { if (!ModelState.IsValid) return BadRequest(ModelState); var emailExist = await _userManager.FindByEmailAsync(registerResource.Email); if (emailExist != null) return BadRequest("Email already in use."); var user = new ApplicationUser { UserName = registerResource.Email, Email = registerResource.Email, FirstName = registerResource.FirstName, LastName = registerResource.LastName, Country = registerResource.Country, Address = registerResource.Address, State = registerResource.State, PhoneNumber = registerResource.PhoneNumber }; var result = await _userManager.CreateAsync(user, registerResource.Password); if (result.Succeeded) { var roleAddresult = await _userManager.AddToRoleAsync(user, "Passenger"); if (roleAddresult.Succeeded) { return Ok(user); } return BadRequest("User created successfully but Role can not be created. Errors are: " + roleAddresult.Errors.ToString()); } var sb = new StringBuilder(); foreach (var error in result.Errors) { sb.Append(error.Description); sb.Append("\n"); } return BadRequest(sb.ToString()); }
public async Task <IActionResult> SignUp([FromBody] RegisterResource credentials) { if (ModelState.IsValid) { var user = new User() { UserName = credentials.Username, Email = credentials.Email }; var result = await _userManager.CreateAsync(user, credentials.Password); if (result.Succeeded) { return(Ok(await GetTokenResponse(user.UserName, true))); } return(BadRequest(new ApiResponse(result))); } return(BadRequest(new ApiResponse(ModelState))); }
public async Task <string> RegisterAsync(RegisterResource registerResource) { var user = await _userManager.FindByEmailAsync(registerResource.Email); if (user != null) { return("The user account already exist!"); } if (!await _roleManager.RoleExistsAsync(registerResource.Role)) { return("The role does not exist!"); } user = new AppUser { FirstName = registerResource.FirstName, LastName = registerResource.LastName, Email = registerResource.Email, UserName = registerResource.Email }; var result = await _userManager.CreateAsync(user, registerResource.Password); if (!result.Succeeded) { return(string.Join(" ", result.Errors.Select(x => x.Description))); } result = await _userManager.AddToRoleAsync(user, registerResource.Role); if (!result.Succeeded) { return(string.Join(" ", result.Errors.Select(x => x.Description))); } return("register successful"); }
public async Task <object> Register(RegisterResource resource, IFormFile file) { if (!ModelState.IsValid) { log.Error(BadRequest((ModelState))); return(BadRequest(ModelState)); } var awsServiceclientSettings = new AwsServiceClientSettings(file, _awsAppSettings.BucketName, _awsAppSettings.SubFolderW9, _awsAppSettings.BucketLocation, _awsAppSettings.PublicDomain); var documentUrl = ""; if (file != null) { if (file.Length > _photoAppSettings.MaxBytes) { log.Error("Maximum file size exceeded"); return(BadRequest("Maximum file size exceeded")); } else { if (!_photoAppSettings.IsSupported(file.FileName)) { log.Error("Invalid file type"); return(BadRequest("Invalid file type")); } else { documentUrl = await _awsServiceClient.UploadAsync(awsServiceclientSettings); log.Info(documentUrl); } } } var userExist = await _userManager.FindByEmailAsync(resource.Email); log.Info(userExist); if (userExist != null) { log.Error("Email already is in use."); return(BadRequest("Email already is in use.")); } var user = new ApplicationUser { UserName = resource.Email, Email = resource.Email, FirstName = resource.FirstName, LastName = resource.LastName, Country = resource.Country, Address = resource.Address, State = resource.State, PhoneNumber = resource.PhoneNumber, BusinessName = resource.BusinessName, RoutingNumber = resource.RoutingNumber, AccountNumber = resource.AccountNumber, TaxId = resource.TaxId, OriginatingPartyName = resource.OriginatingPartyName, ReceivingPartyName = resource.ReceivingPartyName, BankName = resource.BankName, W9 = "" }; var result = await _userManager.CreateAsync(user, resource.Password); log.Info(result); if (result.Succeeded) { var roleAdd = await _userManager.AddToRoleAsync(user, resource.RoleName); log.Info(roleAdd); if (roleAdd.Succeeded) { user = await _userManager.FindByEmailAsync(resource.Email); log.Info(user); return(new LoginResourceResponse { User = user, Roles = new[] { resource.RoleName }, Token = GenerateJwtToken(user.Email, user) }); } log.Error("Error during adding role to the user."); return(BadRequest("Error during adding role to the user.")); } log.Error("Error during user creation."); return(BadRequest("Error during user creation.")); }
public RedirectToActionResult Register([FromBody] RegisterResource paramBody) { return(RedirectToActionPreserveMethod("CreateUser", "Users")); }