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;
}
