public async Task <IActionResult> PutUserAsync([FromRoute] long id, [FromBody] PutUserViewModel putUser)
{
if (!ModelState.IsValid)
{
return(new ObjectResult(new ApiDataResult {
Error = PutUserResultType.Wrong, Data = new { ModelState }
})
{
StatusCode = StatusCodes.Status422UnprocessableEntity
});
}
if (id != putUser.Id)
{
return(BadRequest(new ApiResult {
Error = PutUserResultType.Wrong
}));
}
var result = await _userService.PutUserAsync(putUser);
switch (result.Error)
{
case PutUserResultType.Forbiddance:
return(new ObjectResult(result)
{
StatusCode = StatusCodes.Status403Forbidden
});
case PutUserResultType.ConcurrencyException:
return(BadRequest(result));
case PutUserResultType.UserNotFound:
return(NotFound(result));
case PutUserResultType.Repeat:
return(BadRequest(result));
case PutUserResultType.Wrong:
return(new ObjectResult(result)
{
StatusCode = StatusCodes.Status422UnprocessableEntity
});
case PutUserResultType.Error:
return(BadRequest(result));
case PutUserResultType.Ok:
return(Ok(result));
default:
throw new ArgumentOutOfRangeException();
}
}
public ActionResult <User> Put(long id, [FromBody] PutUserViewModel model)
{
try
{
var user = UserApplicationService.Update(id, model.email, model.password);
return(user);
}
catch (Exception ex)
{
return(UnprocessableEntity(ex));
}
}
public bool Put(PutUserViewModel putUserViewModel)
{
if (putUserViewModel.Id == Guid.Empty)
{
throw new Exception("ID is invalid");
}
User _user = this.userRepository.Find(x => x.Id == putUserViewModel.Id && !x.IsDeleted);
if (_user == null)
{
throw new Exception("User not found");
}
_user = mapper.Map <User>(putUserViewModel);
return(this.userRepository.Update(_user));;
}
public async Task <ApiResult> PutUserAsync(PutUserViewModel putUser)
{
var user = await _context.Users.Include(u => u.Role).SingleOrDefaultAsync(u => u.Id == putUser.Id);
if (user == null)
{
return new PutUserResult {
Error = PutUserResultType.UserNotFound
}
}
;
if (user.Role.Type == RoleType.Teacher)
{
var count = (await _context.Teachers.Include(t => t.Contests).Where(t => t.UserId == user.Id)
.SingleOrDefaultAsync()).Contests.Count;
if (count > 0)
{
return(new PutUserResult {
Error = PutUserResultType.Forbiddance
});
}
}
if (putUser.Password != null)
{
putUser.Password = GetRandomPassword();
user.PasswordHash = _passwordHasher.HashPassword(user, putUser.Password);
}
else
{
if (user.LoginName != putUser.LoginName)
{
var uu = await _context.Users.SingleOrDefaultAsync(u => u.LoginName == putUser.LoginName);
if (uu != null)
{
return(new PutStudentResult {
Error = PutUserResultType.Repeat
});
}
}
user.LoginName = putUser.LoginName;
user.UserName = putUser.UserName;
try
{
var role = await _authService.GetRoleFromRoleTypeAsync(Enum.Parse <RoleType>(putUser.RoleType.ToString()));
if (role == null)
{
return new PutUserResult {
Error = PutUserResultType.Wrong
}
}
;
if (user.Role.Type == RoleType.Teacher && role.Type != RoleType.Teacher)
{
var teacher = await _context.Teachers.Include(t => t.Contests).Where(t => t.UserId == user.Id)
.SingleOrDefaultAsync();
if (teacher.Contests.Count > 0)
{
return(new PutUserResult {
Error = PutUserResultType.Forbiddance
});
}
_context.Teachers.Remove(teacher);
await _context.SaveChangesAsync();
}
else if (user.Role.Type != RoleType.Teacher && role.Type == RoleType.Teacher)
{
var teacher = new TeacherModel {
UserId = user.Id
};
await _context.Teachers.AddAsync(teacher);
await _context.SaveChangesAsync();
}
else
{
user.RoleId = role.Id;
}
}
catch (Exception)
{
return(new PutUserResult {
Error = PutUserResultType.Wrong
});
}
}
_context.Entry(user).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
return(new PutUserResult {
Error = PutUserResultType.Ok, Data = putUser
});
}
catch (DbUpdateConcurrencyException)
{
return(new PutUserResult {
Error = PutUserResultType.ConcurrencyException
});
}
}
