public async Task <IActionResult> Register([FromBody] RegisteredUserDto newRegisteredUser) { if (!ModelState.IsValid) { return(BadRequest()); } if (newRegisteredUser == null) { return(BadRequest()); } newRegisteredUser.Username = newRegisteredUser.Username.ToLower(); if (await _repos.UserExists(newRegisteredUser.Username)) { return(BadRequest("User already exists")); } var newUser = new User() { Username = newRegisteredUser.Username }; var createdUser = await _repos.Register(newUser, newRegisteredUser.Password); return(StatusCode(201)); }
public BaseResultDto AddUserInformation(RegisteredUserDto registeredUserDto) { RegisteredUserEntity registeredUserEntity = _userMapping.RegisteredUserDto2RegisteredUserEntity(registeredUserDto); BaseResultEntity baseResultEntity = _userService.AddUserInformation(registeredUserEntity); BaseResultDto baseResultDto = _baseResultMapping.Entity2Dto(baseResultEntity); return(baseResultDto); }
public async Task <IActionResult> Register([FromBody] RegisterUserDto request) { string?userId = null; string?userToken = null; if (request.CreateUser) { userId = Guid.NewGuid().ToString(); var update = request.ToUpdate(); var user = await userStore.UpsertAsync(App.Id, userId, update, HttpContext.RequestAborted); if (request.Topics?.Any() == true) { var command = new Subscribe { TopicSettings = new NotificationSettings { [Providers.WebPush] = new NotificationSetting { Send = NotificationSend.Send } } }; if (!string.IsNullOrEmpty(request.EmailAddress)) { command.TopicSettings[Providers.Email] = new NotificationSetting { Send = NotificationSend.Send }; } foreach (var topic in request.Topics) { var topicId = new TopicId(topic); await subscriptionStore.UpsertAsync(App.Id, userId, topicId, command, HttpContext.RequestAborted); } } userToken = user.ApiKey; } var response = new RegisteredUserDto { PublicKey = webPushService.PublicKey, UserId = userId, UserToken = userToken }; return(Ok(response)); }
public RegisteredUserEntity RegisteredUserDto2RegisteredUserEntity(RegisteredUserDto registeredUserDto) { return(new RegisteredUserEntity { Name = registeredUserDto.Name, CompanyName = registeredUserDto.CompanyName, EmailAddress = registeredUserDto.EmailAddress, MobileNumber = registeredUserDto.MobileNumber, ProductType = registeredUserDto.ProductType, DatabaseType = registeredUserDto.DatabaseType, ProductCode = registeredUserDto.ProductCode, Database = registeredUserDto.Database, }); }
public async Task <IActionResult> Login(LoginDto loginDto) { var user = await _repo.Login(loginDto.Name.ToLower(), loginDto.Password); if (user == null) { return(Unauthorized("user authentication failed")); } var userToReturn = new RegisteredUserDto() { Name = user.Name, Role = user.Role }; return(Ok(userToReturn)); }
public async Task <IActionResult> Register(RegisteredUserDto registeredUserDto) { //if(!ModelState.IsValid) validation as well as [Frombody] attribute handled by APIController attribute registeredUserDto.Username = registeredUserDto.Username.Trim().ToLower(); if (await _repo.UserExists(registeredUserDto.Username)) { return(BadRequest("User already exists")); } var userToCreate = _mapper.Map <User>(registeredUserDto); var createdUser = await _repo.Register(userToCreate, registeredUserDto.Password); var userToReturn = _mapper.Map <UserForDetailedDto>(createdUser); return(CreatedAtRoute("GetUser", new { controller = "users", id = userToReturn.Id }, userToReturn)); }
public JsonResult Registration(RegisteredUserDto registeredUser) { BaseResultDto baseResultDto; try { baseResultDto = _userAf.AddUserInformation(registeredUser); } catch (Exception ex) { _logger.LogError((int)EventLevel.Error, ex, ex.Message); baseResultDto = new BaseResultDto { Message = StaticResource.InternalServerMessage }; } return(Json(baseResultDto)); }
public async Task <IActionResult> Register(RegisterDto registerDto) { registerDto.Name = registerDto.Name.ToLower(); var role = "user"; if (registerDto.AdminCode != null && registerDto.IsAdmin == true) { if (registerDto.AdminCode == _config.GetSection("AppSettings:AdminCode").Value) { role = "admin"; } else { return(Unauthorized("Admin confirmation unsuccessful")); } } if (await _repo.UserExists(registerDto.Name)) { return(BadRequest("Username already exists")); } var userToRegister = new User() { Name = registerDto.Name, Role = role }; var createdUser = await _repo.Register(userToRegister, registerDto.Password); var createdUserToReturn = new RegisteredUserDto() { Name = createdUser.Name, Role = createdUser.Role }; return(Ok(createdUserToReturn)); }
public async Task <UserRegistrationResponse> Register(UserRegistrationRequest request) { var(passwordHash, passwordSalt) = _passwordHashService.Generate(request.Password); var password = new Password(passwordHash, passwordSalt); var user = new User( request.Email, request.Name, password, request.DateOfBirth, _mapper.Map <GenderDto, Gender>(request.Gender), _clock.GetCurrentInstant() ); _dbContext.Users.Add(user); await _dbContext.SaveChangesAsync(); var registeredUserDto = new RegisteredUserDto(user.Id); return(new UserRegistrationResponse(registeredUserDto, _tokenService.Generate(user))); }
public async Task <ActionResult <RegisteredUserDto> > RegisterUser([FromBody] UserRegisterDto userRegisterDto) { Data.Domain.Entity.User registeredButNotConfirmedUser = null; try { registeredButNotConfirmedUser = await _userService.RegisterAsync(userRegisterDto.Username, userRegisterDto.Email, userRegisterDto.Password); } catch (ArgumentException ex) { _logger.LogError($"failed register ${userRegisterDto.Email}: {ex.Message}"); return(BadRequest()); } var registeredUserDto = new RegisteredUserDto() { Username = registeredButNotConfirmedUser.Username, ConfirmToken = registeredButNotConfirmedUser.ConfirmToken }; return(Ok(registeredUserDto)); }
public UserRegistrationResponse(RegisteredUserDto user, string accessToken) { User = user; AccessToken = accessToken; }