public async Task <SingleResult <AccountPublicDto> > UpdateUser(AccountUpdateDto model)
{
var result = new SingleResult <AccountPublicDto>();
var user = await _userManager.Users.Include(x => x.ReservedBooks).FirstOrDefaultAsync(x => x.Id == model.Id);
if (user != null)
{
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Sex = model.Sex;
user.Birthday = model.Birthday;
user.PhoneNumber = model.PhoneNumber;
var updateResult = await _userManager.UpdateAsync(user);
if (updateResult.Succeeded)
{
result.IsSuccessful = true;
result.Data = _mapper.Map <ApplicationUser, AccountPublicDto>(user);
}
else
{
result.Message = updateResult.Errors.Select(x => x.Description).Join(";");
}
}
else
{
result.Message = "User was not found";
}
return(result);
}
public ActionResult <AccountDto> UpdateAccount(int id, [FromBody] AccountUpdateDto accountUpdateDto)
{
if (accountUpdateDto == null)
{
return(BadRequest());
}
var existingAccountItem = _accountRepository.GetSingle(id);
if (existingAccountItem == null)
{
return(NotFound());
}
_mapper.Map(accountUpdateDto, existingAccountItem);
_accountRepository.Update(id, existingAccountItem);
if (!_accountRepository.Save())
{
throw new Exception("Updating a accountitem failed on save.");
}
return(Ok(_mapper.Map <AccountDto>(existingAccountItem)));
}
public IActionResult UpdateAccount(Guid id, [FromBody] AccountUpdateDto accountUpdateDto)
{
try
{
if (accountUpdateDto == null)
{
return(BadRequest("accountUpdateDto is null"));
}
if (!ModelState.IsValid)
{
return(BadRequest("accountUpdateDto is not valid"));
}
var account = _repository.Account.GetAccountById(id);
if (account == null)
{
return(NotFound($"Entity is not found by id: {id}"));
}
_mapper.Map(accountUpdateDto, account);
_repository.Account.UpdateAccount(account);
_repository.Commit();
return(NoContent());
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(500, "Internal Server Error"));
}
}
public ActionResult <AccountDto> PartiallyUpdateAccount(int id, [FromBody] JsonPatchDocument <AccountUpdateDto> patchDoc)
{
if (patchDoc == null)
{
return(BadRequest());
}
AccountEntity existingEntity = _accountRepository.GetSingle(id);
if (existingEntity == null)
{
return(NotFound());
}
AccountUpdateDto accountUpdateDto = _mapper.Map <AccountUpdateDto>(existingEntity);
patchDoc.ApplyTo(accountUpdateDto);
TryValidateModel(accountUpdateDto);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_mapper.Map(accountUpdateDto, existingEntity);
AccountEntity updated = _accountRepository.Update(id, existingEntity);
if (!_accountRepository.Save())
{
throw new Exception("Updating a accountitem failed on save.");
}
return(Ok(_mapper.Map <AccountDto>(updated)));
}
public async Task <IActionResult> UpdateAccount(Guid resourceId,
[FromBody] AccountUpdateDto accountUpdateDto)
{
var updatedAccountResult = await _accountService.Update(resourceId, accountUpdateDto);
switch (updatedAccountResult)
{
case FailedLockableResult <AccountDetailsOutDto> failedLockableResult:
return(StatusCode(StatusCodes.Status500InternalServerError, failedLockableResult.Error));
case LockedLockableResult <AccountDetailsOutDto> _:
return(BadRequest(BadRequestOutDto.AccountLockedByAnotherUser));
case NotLockedLockableResult <AccountDetailsOutDto> _:
return(BadRequest(BadRequestOutDto.AccountNotLocked));
case NotFoundLockableResult <AccountDetailsOutDto> _:
return(StatusCode(StatusCodes.Status404NotFound));
case SuccessfulLockableResult <AccountDetailsOutDto> successfulLockableResult:
return(Ok(successfulLockableResult.Value));
default:
return(StatusCode(StatusCodes.Status500InternalServerError, new ArgumentOutOfRangeException(nameof(updatedAccountResult))));
}
}
public ActionResult <AccountDto> CreateAccount([FromBody] AccountUpdateDto accountUpdateDto)
{
var accountStatus = AccountStatus.GetByAccountStatusID(_dbContext, accountUpdateDto.AccountStatusID);
if (ThrowNotFound(accountStatus, "Account Status", accountUpdateDto.AccountStatusID, out var actionResult))
{
return(actionResult);
}
var updatedUserDto = Account.CreateAccountEntity(_dbContext, accountUpdateDto, _rioConfiguration.VerificationKeyChars);
return(Ok(updatedUserDto));
}
public async Task <ActionResult> UpdateUser(AccountUpdateDto accountUpdateDto)
{
var user = await _accountService.GetUserByUsernameAsync(User.GetUsername());
_mapper.Map(accountUpdateDto, user);
_accountService.Update(user);
if (await _accountService.SaveAllAsync())
{
return(NoContent());
}
return(BadRequest("Fail to update user"));
}
public async Task <IActionResult> Put(string id, [FromBody] AccountUpdateDto updateUserDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var account = await _repo.GetAccount(id);
if (account == null)
{
return(NotFound());
}
var currentUserId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
if (currentUserId != id)
{
return(Unauthorized());
}
if (await _repo.UserNameExists(updateUserDto.UserName, id))
{
return(BadRequest("そのユーザーネームは既に使用されています"));
}
if (await _repo.EmailExists(updateUserDto.Email, id))
{
return(BadRequest("そのEメールは既に登録されています"));
}
_mapper.Map(updateUserDto, account);
try{
await _repo.UpdateAccount(account);
var returnUser = _mapper.Map <AccountForReturnDto>(account);
return(Ok(returnUser));
}
catch (Exception ex) {
return(BadRequest(ex.Message));
}
// if(await _repo.UpdateAppUser(appUser)){
// var returnUser = _mapper.Map<AppUserForReturnDto>(appUser);
// return Ok(returnUser);
// }
// else{
// return BadRequest("Something went wrong when updating AppUser");
// }
}
public async Task <IActionResult> UpdateUser([FromBody] AccountUpdateDto model)
{
if (!ModelState.IsValid)
{
var badResult = new OperationResult();
badResult.Message = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage));
return(new OkObjectResult(badResult));
}
var result = await _accountService.UpdateUser(model);
return(new OkObjectResult(result));
}
public ActionResult <AccountReadDto> Update(AccountUpdateDto accountCreateDto)
{
Account account = _accountRepository.Get(accountCreateDto.Id);
if (account == null)
{
return(BadRequest("Account with that id doesn't exist."));
}
account = _mapper.Map(accountCreateDto, account);
_accountRepository.Update(account);
_logger.Log("Update Account");
return(Ok(account));
}
public async Task <ActionResult> UpdateAccountAsync(int id, AccountUpdateDto accountUpdateDto)
{
var check = await _accountService.GetAccountByIdAsync(id);
var accountSelected = await _accountService.GetAccountByIdAsync(id);
if (accountSelected == null || !accountSelected.MatKhau.Equals(accountUpdateDto.MatKhauCu))
{
return(NotFound());
}
_mapper.Map(accountUpdateDto, accountSelected);
await _accountService.UpdateAccountAsync(accountSelected);
return(NoContent());
}
public ActionResult <AccountReadDto> UpdateAccount(int id, AccountUpdateDto dto)
{
var oldAcc = _repository.Find(id);
if (oldAcc == null)
{
return(NotFound());
}
if (_repository.Set().Where(x => x.ID != id).Any(x => x.UserName == dto.UserName))
{
return(BadRequest()); // Could use retouching
}
_mapper.Map(dto, oldAcc);
_repository.Save();
return(NoContent());// Ok(oldAcc);
}
public static AccountDto CreateAccountEntity(RioDbContext dbContext, AccountUpdateDto accountUpdateDto,
string rioConfigurationVerificationKeyChars)
{
var account = new Account()
{
AccountStatusID = accountUpdateDto.AccountStatusID,
Notes = accountUpdateDto.Notes,
AccountName = accountUpdateDto.AccountName,
UpdateDate = DateTime.UtcNow,
CreateDate = DateTime.UtcNow,
InactivateDate = accountUpdateDto.AccountStatusID == (int)AccountStatusEnum.Inactive
? DateTime.UtcNow
: (DateTime?)null,
AccountVerificationKey = accountUpdateDto.AccountStatusID == (int)AccountStatusEnum.Inactive ? null : GenerateAndVerifyAccountVerificationKey(rioConfigurationVerificationKeyChars, GetCurrentAccountVerificationKeys(dbContext))
};
dbContext.Account.Add(account);
dbContext.SaveChanges();
dbContext.Entry(account).Reload();
return(GetByAccountID(dbContext, account.AccountID));
}
public static AccountDto UpdateAccountEntity(RioDbContext dbContext, int accountID,
AccountUpdateDto accountUpdateDto, string rioConfigurationVerificationKeyChars)
{
var account = dbContext.Account
.Include(x => x.AccountStatus)
.Single(x => x.AccountID == accountID);
account.AccountStatusID = accountUpdateDto.AccountStatusID;
account.InactivateDate = accountUpdateDto.AccountStatusID == (int)AccountStatusEnum.Inactive
? DateTime.UtcNow
: (DateTime?)null;
account.AccountVerificationKey = accountUpdateDto.AccountStatusID == (int)AccountStatusEnum.Inactive
? null
: account.AccountVerificationKey ??
(GenerateAndVerifyAccountVerificationKey(rioConfigurationVerificationKeyChars,
GetCurrentAccountVerificationKeys(dbContext)));
account.AccountName = accountUpdateDto.AccountName;
account.UpdateDate = DateTime.UtcNow;
dbContext.SaveChanges();
dbContext.Entry(account).Reload();
return(GetByAccountID(dbContext, accountID));
}
private void Load(ApplicationUser user)
{
Input = _mapper.Map <AccountUpdateDto>(user);
}
public async Task <LockableResult <AccountDetailsOutDto> > Update(Guid resourceId,
AccountUpdateDto accountUpdateDto)
{
var foundAccountResult = await GetEntity(resourceId);
AccountDetailEntity foundAccount;
switch (foundAccountResult)
{
case FailedTypedResult <AccountDetailEntity> failedTypedResult:
return(new FailedLockableResult <AccountDetailsOutDto>(failedTypedResult.Error));
case NotFoundTypedResult <AccountDetailEntity> _:
return(new NotFoundLockableResult <AccountDetailsOutDto>());
case SuccessfulTypedResult <AccountDetailEntity> successfulTypedResult:
foundAccount = successfulTypedResult.Value;
break;
default:
return(new FailedLockableResult <AccountDetailsOutDto>(
new ArgumentOutOfRangeException(nameof(foundAccountResult))));
}
if (foundAccount.Lock == null)
{
return(new NotLockedLockableResult <AccountDetailsOutDto>());
}
if (foundAccount.Lock.Secret != accountUpdateDto.LockSecret)
{
return(new LockedLockableResult <AccountDetailsOutDto>());
}
var updates = new List <UpdateDefinition <AccountDetailEntity> >();
if (!string.IsNullOrWhiteSpace(accountUpdateDto.Name))
{
updates.Add(Builders <AccountDetailEntity> .Update.Set(ade => ade.Name, accountUpdateDto.Name));
}
if (!string.IsNullOrWhiteSpace(accountUpdateDto.Msisdn))
{
updates.Add(Builders <AccountDetailEntity> .Update.Set(ade => ade.Msisdn, accountUpdateDto.Msisdn));
}
if (accountUpdateDto.Status != null)
{
updates.Add(Builders <AccountDetailEntity> .Update.Set(ade => ade.Status, accountUpdateDto.Status));
}
if (!updates.Any())
{
return(new SuccessfulLockableResult <AccountDetailsOutDto>(await this.Get(resourceId)));
}
// Set Last Modified Date
updates.Add(Builders <AccountDetailEntity> .Update.Set(ade => ade.LastModifiedDate, DateTimeOffset.UtcNow));
var updatedAccount = await _accounts.FindOneAndUpdateAsync <AccountDetailEntity>(
f => f.ResourceId == resourceId && f.Lock != null && f.Lock.Secret == accountUpdateDto.LockSecret,
Builders <AccountDetailEntity> .Update.Combine(updates),
GetEntityAfterUpdateOption <AccountDetailEntity>());
if (updatedAccount != null)
{
return(new SuccessfulLockableResult <AccountDetailsOutDto>(
AccountDetailsOutDto.EntityToOutDto(updatedAccount)));
}
else
{
return(new FailedLockableResult <AccountDetailsOutDto>(
new Exception("Lock status changed unexpectedly. No update.")));
}
}
