public async Task <IActionResult> LoginAsync([FromBody] UserCredentialsResource userParam)
{
var userAuth = await _authService.Authenticate(userParam.Email, userParam.Password);
if (userAuth == null)
{
return(BadRequest(new { message = "Email or password is incorrect" }));
}
var userResource = _mapper.Map <User, UserResource>(userAuth);
return(Ok(userResource));
}
public async Task <IActionResult> LoginAsync([FromBody] UserCredentialsResource userCredentials)
{
var response = await _authenticationService.CreateAccessTokenAsync(userCredentials.Email, userCredentials.Password);
if (!response.Success)
{
return(BadRequest(response.Message));
}
var accessTokenResource = _mapper.Map <AccessToken, AccessTokenResource>(response.Token);
return(Ok(accessTokenResource));
//throw new FileNotFoundException();
}
public async Task <IActionResult> Login([FromBody] UserCredentialsResource credentialsResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrors()));
}
var credentials = Mapper.Map <UserCredentialsResource, UserCredentials>(credentialsResource);
var userLogged = await UserService.Login(credentials);
var resource = Mapper.Map <Response <LoggedUser>, Response <LoggedUserResource> >(userLogged);
return(HandleResult(resource));
}
public async Task <IActionResult> CreateUserAsync([FromBody] UserCredentialsResource userCredentials)
{
var user = _mapper.Map <UserCredentialsResource, User>(userCredentials);
var response = await _userService.CreateUserAsync(user, ERole.Common);
if (!response.Success)
{
return(BadRequest(response.Message));
}
var userResource = _mapper.Map <User, UserResource>(response.User);
return(Ok(userResource));
}
public async Task <IActionResult> LoginAsync([FromBody] UserCredentialsResource userCredentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var response = await _authenticationService.CreateAccessTokenAsync(userCredentials.Email, userCredentials.Password);
if (!response.Success)
{
return(BadRequest(response.Message));
}
return(Ok(response));
}
public async Task <IActionResult> LoginAsync([FromBody] UserCredentialsResource userCredentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var response = await _loginService.CreateAccessTokenAsync(userCredentials.Email, userCredentials.Password);
if (!response.Success)
{
return(BadRequest(response.Message));
}
var accessTokenResource = _mapper.Map <AccessToken, AccessTokenResource>(response.Token);
return(Ok(accessTokenResource));
}
public async Task <IActionResult> LoginAsync([FromBody] UserCredentialsResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var result = await _authenticationService.CreateAccessTokenAsync(resource.Username, resource.Password);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var accessTokenResource = _mapper.Map <AccessToken, AccessTokenResource>(result.AccessToken);
return(Ok(accessTokenResource));
}
public async Task <IActionResult> CreateNewUserAsync([FromBody] UserCredentialsResource userCredentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = mapper.Map <UserCredentialsResource, User>(userCredentials);
var response = await userService.CreateUserAsync(user, EType.Common);
if (!response.Success)
{
return(BadRequest(response.Message));
}
var userResource = mapper.Map <User, UserResource>(response.User);
return(Ok(userResource));
}
public async Task <IActionResult> LoginAsync([FromBody] UserCredentialsResource userResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var user = _mapper.Map <UserCredentialsResource, User>(userResource);
var result = await _loginService.UserAuthenticationAsync(user);
if (!result.Authenticated)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> CreateUserAsync([FromBody] UserCredentialsResource userCredentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _mapper.Map <UserCredentialsResource, User>(userCredentials);
var response = await _userService.CreateUserAsync(user);
if (!response.Success)
{
return(BadRequest(response.Message));
}
return(Ok(new { Messagee = response.Message, Success = response.Success }));
}
public async Task <IActionResult> PutAsync(string email, [FromBody] UserCredentialsResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var siparis = _mapper.Map <UserCredentialsResource, User>(resource);
var result = await _userService.UpdateAsync(email, siparis);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var siparisResource = _mapper.Map <User, UserResource>(result.User);
return(Ok(siparisResource));
}
public async Task <IActionResult> CreateUserAsync([FromBody] UserCredentialsResource userCredentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var response = await _userService.CreateUserAsync(userCredentials, ERole.Common);
if (!response.Success)
{
return(BadRequest(response.Message));
}
return(Ok(response));
}
public async Task <IActionResult> RegisterAsync([FromBody] UserCredentialsResource userCredentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _mapper.Map <UserCredentialsResource, User>(userCredentials);
var newUser = await _userService.CreateUserAsync(user, ERole.Common);
var response = await _authenticationService.CreateAccessTokenAsync(userCredentials.Email, userCredentials.Password);
if (!response.Success)
{
return(BadRequest(response.Message));
}
var accessTokenResource = _mapper.Map <AccessToken, AccessTokenResource>(response.Token);
return(Json(accessTokenResource.ToString()));
}
public async Task <IActionResult> CreateUserAsync([FromBody] UserCredentialsResource userCredentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _mapper.Map <UserCredentialsResource, Domain.Models.User>(userCredentials);
var response = await _userService.CreateUserAsync(user, ERole.Student);
if (!response.Success)
{
return(BadRequest(response.Message));
}
var userResource = _mapper.Map <Domain.Models.User, UserResource>(response.User);
return(Ok(userResource));
}
public async Task <IActionResult> CreateUserAsync([FromBody] UserCredentialsResource userCredentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var user = _mapper.Map <UserCredentialsResource, User>(userCredentials);
var result = await _userService.CreateUserAsync(user, ERole.Common);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var userResource = _mapper.Map <User, UserResource>(result.Resource);
return(Ok(userResource));
}
public async Task <CreateUserResponse> CreateUserAsync(UserCredentialsResource user, params ERole[] userRoles)
{
try
{
var existingUser = await _userRepository.FindByEmailAsync(user.Email);
if (existingUser != null)
{
return(new CreateUserResponse(false, "Email already in use.", null));
}
User newUser = new User
{
Email = user.Email,
Password = _passwordHasher.HashPassword(user.Password),
};
await _userRepository.AddAsync(newUser, userRoles);
await _unitOfWork.CompleteAsync();
newUser.Password = "";
return(new CreateUserResponse(true, null, newUser));
}
catch (Exception ex)
{
_logService.LogException($"An error occurred when creating user : { ex.Message}", "Create_User");
return(new CreateUserResponse(false, "Error creating user.", null));
}
}
