public async Task <ActionResult <DTOs.User> > PutAsync(int id, [FromBody] DTOs.User user)
{
try
{
if (id != user.Id)
{
return(BadRequest($"User id from url and body are not identical."));
}
if (await _userRepository.GetUserAsync(id) == null)
{
return(NotFound($"User with id '{id}' not found."));
}
// Validate user
var(statusCode, msg) = await ValidateUser(user, isCreation : false);
if (statusCode == StatusCodes.Status400BadRequest)
{
_logger.LogError(msg);
return(StatusCode(StatusCodes.Status400BadRequest, msg));
}
var userUpdated = await _userRepository.UpdateUserAsync(_mapper.Map <Models.User>(user));
var userDTO = _mapper.Map <DTOs.User>(userUpdated);
return(Ok(userDTO));
}
catch (Exception)
{
var msg = "Error occurred while updating data of database.";
_logger.LogError(msg);
return(StatusCode(StatusCodes.Status500InternalServerError, msg));
}
}
public async Task <IActionResult> Authenticate([FromBody] DTOs.User user)
{
var userRetrieved = await _userRepository.GetUserAsync(user.Username, user.Password);
if (userRetrieved == null)
{
return(BadRequest("Username or password is incorrect."));
}
// Generate jwt token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_configuration.GetSection("JwtSecret").Value);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, userRetrieved.Id.ToString()),
new Claim(ClaimTypes.Role, userRetrieved.Role)
}),
Expires = DateTime.UtcNow.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
userRetrieved.Token = tokenHandler.WriteToken(token);
userRetrieved.Password = "";
var userDTO = _mapper.Map <DTOs.User>(userRetrieved);
return(Ok(userDTO));
}
public async Task <ActionResult <DTOs.User> > PostAsync([FromBody] DTOs.User user)
{
try
{
if (user == null)
{
return(BadRequest($"User object from body is null."));
}
// Validate user
var(statusCode, msg) = await ValidateUser(user, isCreation : true);
if (statusCode == StatusCodes.Status400BadRequest)
{
_logger.LogError(msg);
return(StatusCode(StatusCodes.Status400BadRequest, msg));
}
// Create user
var createdUser = await _userRepository.AddUserAsync(_mapper.Map <Models.User>(user));
var userDTO = _mapper.Map <DTOs.User>(createdUser);
return(CreatedAtRoute("GetUser", new { id = userDTO.Id }, userDTO));
}
catch (Exception)
{
var msg = "Error occurred while creating new user into database.";
_logger.LogError(msg);
return(StatusCode(StatusCodes.Status500InternalServerError, msg));
}
}
public async Task <IActionResult> GetUser(string userId)
{
Mdls.User user = await userRepository.Get(userId);
DTOs.User userClient = mapper.Map <Mdls.User, DTOs.User>(user);
return(Ok(userClient));
}
public async Task <DTOs.User> GetMe()
{
string userId = authenticationCurrentContext.CurrentUser;
Mdls.User user = await userRepository.Get(userId);
DTOs.User userClient = mapper.Map <Mdls.User, DTOs.User>(user);
return(userClient);
}
private DTOs.User CreateDTO()
{
DTOs.User dtoUser = new DTOs.User
{
Name = "Foo Bar 3",
CardId = "1234567890123458",
Email = "*****@*****.**",
Password = "******"
};
return(dtoUser);
}
public bool CheckIfUserExists(DTOs.User user)
{
var exists = ValidateLogin(user.Username, user.Password);
if (!exists || user.Role == 0)
{
return(false);
}
else
{
return(_user.CheckIfUSerExists(user.Username));
}
}
public async Task <DTOs.User> GetUser(string userId)
{
if (cacheProvider.DoesKeyExist <DTOs.User>(userId))
{
DTOs.User user = cacheProvider.Get <DTOs.User>(userId);
return(user);
}
else
{
Mdls.User userdisplay = await userRepository.Get(userId);
DTOs.User user = mapper.Map <Mdls.User, DTOs.User>(userdisplay);
cacheProvider.Set <DTOs.User>(userId, user);
return(user);
}
}
public ActionResult Create([FromForm] DTOs.User u)
{
try
{
var user = new User
{
UserName = u.UserName
};
_userContext.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
private async Task <DTOs.GridElment> ResolveGridElement(Mdls.Milestone milestone, string ownerId)
{
bool IsLiked = await likeRepository.HasLike(milestone.id, ownerId);
DTOs.User user = await userCache.GetUser(milestone.UserId);
Models.enums.LikeType Like = IsLiked ? Models.enums.LikeType.ON : Models.enums.LikeType.OFF;
DTOs.GridElment ge = new DTOs.GridElment
{
Like = Like,
Milestone = milestone,
User = user,
Self = ownerId == milestone.UserId
};
return(ge);
}
public async Task <DTOs.GridElment> GetRecord(string milestoneId)
{
Mdls.Milestone milestone = await milestoneRepository.Get(milestoneId);
DTOs.User user = await userCache.GetUser(milestone.UserId);
bool IsLiked = await likeRepository.HasLike(milestone.id, milestone.UserId);
Models.enums.LikeType Like = IsLiked ? Models.enums.LikeType.ON : Models.enums.LikeType.OFF;
return(new DTOs.GridElment
{
Milestone = milestone,
User = user,
Like = Like,
Self = currentAuthenticationContext.CurrentUser == milestone.UserId
});
}
public async Task <IActionResult> GetUserDetail(string userId)
{
var user = await Repository.GetUserDetailAsync(userId);
if (user == null)
{
return(NotFound());
}
var userDto = new DTOs.User
{
UserUID = userId,
UserTag = user.UserTag,
FirstName = user.FirstName,
LastName = user.LastName,
PictureUrl = user.PictureUrl,
};
return(Ok(userDto));
}
private async Task <(int, string)> ValidateUser(DTOs.User user, bool isCreation)
{
// Username should be null
if (string.IsNullOrWhiteSpace(user.Username) || string.IsNullOrWhiteSpace(user.Password))
{
return(StatusCodes.Status400BadRequest, $"Username and password could be neither null nor whitespace.");
}
// Validate role
if (!(user.Role == Models.Role.Admin || user.Role == Models.Role.Friend || user.Role == Models.Role.Visitor))
{
return(StatusCodes.Status400BadRequest, $"User role should be 'Admin', 'Friend' or 'Visitor'.");
}
// Check user existence
var users = await _userRepository.GetUsersAsync();
var userRetrieved = users.FirstOrDefault(l => l.Username == user.Username);
if (userRetrieved == null)
{
return(200, null);
}
if (isCreation)
{
return(StatusCodes.Status400BadRequest, $"User '{user.Username}' already exists, cannot create.");
}
else
{
if (userRetrieved.Id != user.Id)
{
return(StatusCodes.Status400BadRequest, $"User '{user.Username}' already exists, cannot update.");
}
else
{
return(200, null);
}
}
}
public ActionResult Edit(int id, [FromForm] DTOs.User u)
{
try
{
var dbUser = _userContext.Find(typeof(User), id) as User;
if (dbUser == null)
{
return(NotFound());
}
else
{
dbUser.UserName = u.UserName;
_userContext.SaveChanges();
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public async Task <IActionResult> GetUserDetail()
{
string userId = User?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
var user = await Repository.GetUserDetailAsync(userId);
if (user == null)
{
return(NotFound());
}
var userDto = new DTOs.User
{
UserUID = userId,
UserTag = user.UserTag,
FirstName = user.FirstName,
LastName = user.LastName,
PictureUrl = user.PictureUrl,
};
return(Ok(userDto));
}
// PUT: api/User/5
public void Put(int id, [FromBody] DTOs.User user)
{
userrepository.UpdateUser(user, id);
}
// POST: api/User
public void Post([FromBody] DTOs.User user)
{
userrepository.CreateNewUser(user);
}
public void UserUpdate(DTOs.User user)
{
_users.Update(user);
}
