public MockUserDal MockGetDetail(UserForDetailDto result)
{
Setup(x => x.GetDetail(It.IsAny <User>()))
.Returns(result);
return(this);
}
public static UserForDetailDto MapUserToUserForDetailDto(Person person)
{
var usersToReturn = new UserForDetailDto();
usersToReturn.Id = person.Id;
usersToReturn.Username = person.Username;
usersToReturn.Gender = person.Gender;
usersToReturn.Age = CalculateAge(person.DateOfBirth);
usersToReturn.KnownAs = person.KnownAs;
usersToReturn.Created = person.Created;
usersToReturn.LastActive = person.LastActive;
usersToReturn.Introduction = person.Introduction;
usersToReturn.LookingFor = person.LookingFor;
usersToReturn.Interests = person.Interests;
usersToReturn.City = person.City;
usersToReturn.Country = person.Country;
usersToReturn.PhotoUrl = person.Photos != null?person.Photos.FirstOrDefault(x => x.IsMain).Url : default;
if (person.Photos != null)
{
usersToReturn.Photos = MapPhotos(person.Photos);
}
return(usersToReturn);
}
public async Task <IActionResult> UpdateUser(int id, [FromBody] UserForDetailDto userForUpdate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var userFromRepo = await _repo.GetUser(id);
if (userFromRepo == null)
{
return(NotFound($"Could not find user with an ID of {id}"));
}
if (currentUserId != userFromRepo.Id)
{
return(Unauthorized());
}
_mapper.Map(userForUpdate, userFromRepo);
if (await _repo.SaveAll())
{
return(NoContent());
}
throw new Exception($"Updating user {id} failed on save");
}
public async Task <IActionResult> UpdateUser(int id, [FromBody] UserForDetailDto userForDetailedDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var user = await _userService.GetByIdAsync(id);
if (user == null)
{
return(NotFound($"Could not find user with an ID of {id}"));
}
if (currentUserId != user.Id)
{
return(Unauthorized());
}
//_mapper.Map(userForDetailedDto, user);
_userService.Update(userForDetailedDto);
return(NoContent());
}
public static void SetValues(UserForDetailDto userForDetailDto)
{
UserId = userForDetailDto.User.Id;
FullName = userForDetailDto.FullName;
Username = userForDetailDto.User.Username;
Email = userForDetailDto.User.Email;
DepartmentId = userForDetailDto.User.DepartmentId;
DepartmentName = userForDetailDto.DepartmentName;
}
public void Update(UserForDetailDto userForDetail)
{
User user = _userRepository.GetById(userForDetail.Id);
user.FirstName = userForDetail.FirstName;
user.LastName = userForDetail.LastName;
user.UserName = userForDetail.UserName;
user.IdGMapAddress = userForDetail.IdGMapAddress;
user.DateOfBirth = userForDetail.DateOfBirth;
//_mapper.Map<User>(userForDetail);
Update(user);
//_userRepository.Update(user);
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
if (await _authRepository.UserExists(userForRegisterDto.Username))
{
return(BadRequest("Username already exists"));
}
User user = _mapper.Map <User>(userForRegisterDto);
var createdUser = await _authRepository.Register(user, userForRegisterDto.Password);
UserForDetailDto userToReturn = _mapper.Map <UserForDetailDto>(createdUser);
return(CreatedAtRoute("GetUser", new { controller = "Users", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> GetUser(string key, string field)
{
//var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
User user;
if (field.Equals("name"))
{
user = await _repo.GetFirstAsync(woak => woak.Username.Equals(key));
}
else
{
user = await _repo.GetFirstAsync(woak => woak.Id == Convert.ToInt32(key));
}
UserForDetailDto userDto = _mapper.Map <UserForDetailDto>(user);
return(Ok(new { userDto = userDto }));
}
public async Task <IActionResult> Login([FromBody] UserLoginDto model)
{
var userFromRepo = await this._authService.Login(model.UserName, model.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
var claims = new[] {
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Name),
};
var key = new SymmetricSecurityKey(Encoding.UTF8
.GetBytes(_configuration.GetSection("AppSettings:SecretKey").Value));
SigningCredentials creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256Signature);
SecurityTokenDescriptor tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds,
};
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
SecurityToken token = tokenHandler.CreateToken(tokenDescriptor);
UserForDetailDto userToReturn = _mapper.Map <UserForDetailDto>(userFromRepo);
string tokenReturn = tokenHandler.WriteToken(token);
string userSerialize = JsonConvert.SerializeObject(userToReturn);
var jsonSerializerSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
return(Ok(JsonConvert.SerializeObject(new {
token = tokenReturn,
user = userToReturn
}, jsonSerializerSettings)));
}
public async Task <IActionResult> UpdateUser(UserForDetailDto userForUpdateDto)
{
User updatedUser = await _repo.GetByIDAsync(userForUpdateDto.Id);
_mapper.Map(userForUpdateDto, updatedUser);
byte[] passwordHash, passwordSalt;
CreatePasswordHash(userForUpdateDto.Password, out passwordHash, out passwordSalt);
updatedUser.PasswordHash = passwordHash;
updatedUser.PasswordSalt = passwordSalt;
var user = await _repo.UpdateAsync(updatedUser);
if (user == -1)
{
throw new Exception($"Updating user {userForUpdateDto.Id} failed on save");
}
else
{
return(Ok(userForUpdateDto.Id));
}
}
public Task <bool> Update(UserForDetailDto model)
{
throw new System.NotImplementedException();
}
