public async Task <LoginResponse <AuthenticatedUserDTO> > LoginUser(PostUserDTO UserCredentials)
{
var user = await _userRepository.FindByEmail(UserCredentials.Email);
if (user == null)
{
var errorMessage = $"Password or login is incorrect";
Log.Error(errorMessage);
return(new LoginResponse <AuthenticatedUserDTO> {
Message = errorMessage, Success = false
});
}
if (!UserCredentials.Password.Equals(user.Password))
{
var errorMessage = $"Password or login is incorrect";
Log.Error(errorMessage);
return(new LoginResponse <AuthenticatedUserDTO> {
Message = errorMessage, Success = false
});
}
var token = GenerateJwtToken(user);
var authenticatedUserDTO = new AuthenticatedUserDTO()
{
Email = user.Email,
Token = token
};
return(new LoginResponse <AuthenticatedUserDTO> {
Data = authenticatedUserDTO
});
}
public async Task <IActionResult> Authenticate([FromBody] PostUserDTO userCredentials)
{
var repsonse = await _userService.AuthenticateUserAsync(userCredentials);
if (repsonse.Success == false)
{
return(BadRequest(repsonse.Message));
}
return(Ok(repsonse.Data));
}
public async Task <ServiceResponse <List <GetUserDTO> > > AddUser(PostUserDTO newUser)
{
ServiceResponse <List <GetUserDTO> > result = new ServiceResponse <List <GetUserDTO> >();
await _context.User.AddAsync(_mapper.Map <User>(newUser));
await _context.SaveChangesAsync();
result.Data = _context.User.Select(c => _mapper.Map <GetUserDTO>(c)).ToList();
return(result);
}
public async Task AddUser(PostUserDTO element)
{
var NewUser = _mapper.Map <User> (element);
if (NewUser == null)
{
throw new ArgumentNullException(nameof(NewUser));
}
_context.Users.Add(NewUser);
await _context.SaveChangesAsync();
}
public async Task <User> AddUser(PostUserDTO element)
{
var NewUser = _mapper.Map <User> (element);
if (NewUser == null)
{
throw new ArgumentNullException(nameof(NewUser));
}
NewUser.UserRole = "User";
NewUser.JWTtoken = null;
_context.Users.Add(NewUser);
await _context.SaveChangesAsync();
return(await Login(_mapper.Map <LoginDTO> (NewUser)));
}
public async Task <ServiceResponse <GetUserDTO> > CreateUser(PostUserDTO newUser)
{
ServiceResponse <GetUserDTO> response = new ServiceResponse <GetUserDTO>();
try{
var user = await _context.Users.AddAsync(_mapper.Map <User>(newUser));
await _context.SaveChangesAsync();
response.Data = _mapper.Map <GetUserDTO>(user.Entity);
}catch (Exception ex) {
response.Message = ex.Message;
response.Success = false;
response.ResultStatusCode = StatusCode.UnprocessableEntity;
}
return(response);
}
public async Task <ActionResult> Register(PostUserDTO postUserDTO)
{
postUserDTO.Username = postUserDTO.Username.ToLower();
if (await _repo.UserExists(postUserDTO.Username))
{
return(BadRequest("This user already exists"));
}
var userToCreate = new User
{
UserName = postUserDTO.Username
};
var createdUser = await _repo.Register(userToCreate, postUserDTO.Password);
return(StatusCode(201));
}
public async Task <ApiResponse> Post([FromBody] PostUserDTO arg)
{
try
{
var userId = await userService.CreateAsync(arg);
return(new ApiResponse(InfoMessages.UserCreatedByAdmin, userId, HttpStatusCode.OK.ToInt()));
}
catch (ValidationException ex)
{
throw new ApiException(ex.Errors, ex.StatusCode);
}
catch (CustomException ex)
{
throw new ApiException(ex, ex.StatusCode);
}
catch (Exception ex)
{
throw new ApiException(ex);
}
}
public async Task <GuidIdDTO> CreateAsync(PostUserDTO arg)
{
var user = mapper.Map <User>(arg);
try
{
var result = await userManager.CreateAsync(user, arg.Password);
if (result.Succeeded)
{
//as this method is only available for admins so below options are applied.
if (arg.CreateAsAdmin)
{
await userManager.AddToRoleAsync(user, Roles.Admin);
}
else
{
await userManager.AddToRoleAsync(user, Roles.Employee);
}
user.PhoneNumberConfirmed = true;
user.EmailConfirmed = true;
user.IsCompanyMember = true;
return(new GuidIdDTO()
{
Id = user.Id
});
}
else
{
throw new ValidationException(result.Errors);
}
}
catch (System.Exception ex)
{
throw;
}
}
public async Task <ServiceResponse <CreatedUserDTO> > CreateUserAsync(PostUserDTO userCredentials, params ERole[] userRoles)
{
var existingUser = await _userRepository.FindByEmailAsync(userCredentials.Email);
if (existingUser != null)
{
string errorMesage = $"User with Email: {existingUser.Email} already exists";
Log.Error(errorMesage);
return(new ServiceResponse <CreatedUserDTO> {
Message = errorMesage, Success = false
});
}
var user = _mapper.Map <User>(userCredentials);
user.Password = _passwordHasher.HashPassword(user.Password);
try
{
await _userRepository.AddAsync(user, userRoles);
await _db.SaveChangesAsync();
}catch (Exception e)
{
Log.Error($"{e.Message}-{e.InnerException?.Message}");
return(new ServiceResponse <CreatedUserDTO> {
Message = e.Message, Success = false
});
}
var createdUser = _mapper.Map <CreatedUserDTO>(await _userRepository.FindByEmailAsync(user.Email));
createdUser.Token = GenerateJwtToken(user);
return(new ServiceResponse <CreatedUserDTO> {
Data = createdUser
});
}
public async Task MapAndSaveUser(PostUserDTO RepoToDto, User element)
{
_mapper.Map(RepoToDto, element);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Add(PostUserDTO user)
{
await _userService.AddAsync(user);
return(Ok());
}
public async Task <IActionResult> CreateUser(PostUserDTO newUser)
{
ServiceResponse <GetUserDTO> response = await _userService.CreateUser(newUser);
return(response.ReturnResult());
}
public async Task <ActionResult> SignUp([FromBody] PostUserDTO logindetails)
{
return(Ok(await _login.AddUser(logindetails)));
}
public async Task <ActionResult> AddUser(PostUserDTO NewUser)
{
await _repository.AddUser(NewUser);
return(NoContent());
}
public Task AddAsync(PostUserDTO user)
{
return(_repository.AddAsync(user.AsEntity(Guid.NewGuid())));
}
public async Task <ServiceResponse <AuthenticatedUserDTO> > AuthenticateUserAsync(PostUserDTO UserCredentials)
{
var user = await _userRepository.FindByEmailAsync(UserCredentials.Email);
if (user == null)
{
var errorMessage = $"Password or login is incorrect";
Log.Error(errorMessage);
return(new ServiceResponse <AuthenticatedUserDTO> {
Message = errorMessage, Success = false
});
}
if (!_passwordHasher.PasswordMatches(UserCredentials.Password, user.Password))
{
var errorMessage = $"Password or login is incorrect";
Log.Error(errorMessage);
return(new ServiceResponse <AuthenticatedUserDTO> {
Message = errorMessage, Success = false
});
}
var token = GenerateJwtToken(user);
var authenticatedUserDTO = _mapper.Map <AuthenticatedUserDTO>(user);
authenticatedUserDTO.Token = token;
return(new ServiceResponse <AuthenticatedUserDTO> {
Data = authenticatedUserDTO
});
}
