public async Task <ServiceResponse <GetAccountDto> > UpdateAccount(UpdateAccountDto accountDto, int userId)
{
var serviceResponse = new ServiceResponse <GetAccountDto>();
var savedAccount = await userManager.FindByIdAsync(userId.ToString());
if (savedAccount is null)
{
serviceResponse.Message = $"Failed to update user with id {userId}: Account not found";
serviceResponse.Successful = false;
serviceResponse.StatusCode = StatusCodes.Status400BadRequest;
}
else
{
savedAccount.UserName = accountDto.Name;
savedAccount.Email = accountDto.Email;
savedAccount.PhoneNumber = accountDto.PhoneNumber;
var result = await userManager.UpdateAsync(savedAccount);
serviceResponse = await GetAccountById(userId);
if (result.Succeeded && serviceResponse.Successful)
{
serviceResponse.Message = $"User with id {userId} was updated";
}
else
{
serviceResponse.Message = GetErrorsString(result.Errors, $"Failed to update user with id { userId }! ");
serviceResponse.Successful = false;
serviceResponse.StatusCode = StatusCodes.Status400BadRequest;
}
}
return(serviceResponse);
}
public IActionResult UpdateAccountIdentification([FromBody] UpdateAccountDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
if (dto.licenseId != null && dto.licenseId != "")
{
if (_accountService.validateLicense(dto.licenseId))
{
return(StatusCode(StatusCodes.Status403Forbidden, "DMV"));
}
if (_accountService.validateFraudLicense(dto.licenseId))
{
return(StatusCode(StatusCodes.Status403Forbidden, "Fraud"));
}
}
_accountService.UpdateAccountIdentificationDetails(dto);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest("Update Failed" + ex.Message));
}
}
public HttpResponseMessage UpdateAccount([FromBody] UpdateAccountDto updateAccountDto)
{
return(Request.ExecuteProtectedAndWrapResult <UpdateAccountDto, AccountModel>(
dto => AccountService.Update(dto),
ModelState, updateAccountDto
));
}
//======================================= UPDATE =======================================//
private static bool InvalidPollsterKey(UpdateAccountDto createAccountDto, UpgradeKey key, string eMail)
{
string dtoKey = createAccountDto.Key;
if (dtoKey == null)
{
return(false);
}
return(key == null || key.EMail != eMail && key.EMail.Length > 0);
}
public async Task <IActionResult> UpdateOtherAccount(UpdateAccountDto updateAccountDto)
{
ServiceResponse <Account> accountResponse = await _register.UpdateOtherAccount(updateAccountDto);
var response = new Response <Account>(accountResponse);
return(accountResponse.Code switch
{
HttpStatusCode.UnprocessableEntity => UnprocessableEntity(response),
HttpStatusCode.NotFound => NotFound(response),
_ => Ok(response)
});
public virtual async Task <AccountDto> UpdateAccountAsync(int accountId, UpdateAccountDto accountDto)
{
var account = await Utils.GetAccountAsync(_db, accountId);
try
{
var errors = new List <ValidationResult>();
Utils.ValidateDto(accountDto, errors);
Utils.ThrowAggregateExceptionOnValidationErrors(errors);
account.Name = !string.IsNullOrEmpty(accountDto.AccountName)
? accountDto.AccountName
: account.Name;
account.AccountTypeId = accountDto.AccountTypeId != default
? accountDto.AccountTypeId
: account.AccountTypeId;
account.ArchetypeId = accountDto.ArchetypeId != default
? accountDto.ArchetypeId
: account.ArchetypeId;
account.SalesforceAccountId = !string.IsNullOrEmpty(accountDto.SalesforceAccountId)
? accountDto.SalesforceAccountId
: account.SalesforceAccountId;
account.SalesforceAccountManager = !string.IsNullOrEmpty(accountDto.SalesforceAccountManager)
? accountDto.SalesforceAccountManager
: account.SalesforceAccountManager;
account.SalesforceAccountNumber = !string.IsNullOrEmpty(accountDto.SalesforceAccountNumber)
? accountDto.SalesforceAccountNumber
: account.SalesforceAccountNumber;
account.SalesforceAccountUrl = !string.IsNullOrEmpty(accountDto.SalesforceAccountUrl)
? accountDto.SalesforceAccountUrl
: account.SalesforceAccountUrl;
account.ContractNumber = !string.IsNullOrEmpty(accountDto.ContractNumber)
? accountDto.ContractNumber
: account.ContractNumber;
_db.Entry(account).State = EntityState.Modified;
await _db.SaveChangesAsync();
return(_mapper.Map <AccountDto>(account));
}
catch (DbException e)
{
throw new PersistenceException($"An error occurred while updating Account ({nameof(accountId)}={accountId}, {nameof(accountDto)}={JsonConvert.SerializeObject(accountDto)})", e);
}
}
public async Task <ServiceResponse <Account> > UpdateOtherAccount(UpdateAccountDto updateAccountDto)
{
if (updateAccountDto.EMail == null)
{
return(new ServiceResponse <Account>()
.Failure(NoEmailProvided, HttpStatusCode.UnprocessableEntity));
}
var response = await UpdateAccount(updateAccountDto);
return(response.Data == null
? response
: response.Success(_mapper.Map <Account>(response.Data), SuccessfulUpdateStr));
}
public async Task <ServiceResponse <Account> > UpdateMyAccount(UpdateAccountDto updateAccountDto,
HttpContext context)
{
var response = await UpdateAccount(updateAccountDto);
if (response.Data == null)
{
return(response);
}
await UpdateCurrentIdentity(context, response.Data);
return(response.Success(_mapper.Map <Account>(response.Data), SuccessfulUpdateStr));
}
public async Task <bool> UpdateAccount(int id, UpdateAccountDto accountDto)
{
var account = _dbContext.Accounts.FirstOrDefault(x => x.AccountId == id);
if (account == null)
{
return(false);
}
account.Name = accountDto.Name;
await _dbContext.SaveChangesAsync();
return(true);
}
public void UpdateAccountIdentificationDetails(UpdateAccountDto dto)
{
Account account = _repositoryFactory.AccountRepository.GetAccountById(dto.id);
if (dto.licenseId != null && dto.licenseId != "")
{
ImageFile drivingLicense = JsonConvert.DeserializeObject <ImageFile>(dto.drivingLicense.ToString());
account.drivingLicense = Convert.FromBase64String(drivingLicense.value);
}
if (dto.additionalIdentification != null)
{
ImageFile additionalIdentification = JsonConvert.DeserializeObject <ImageFile>(dto.additionalIdentification.ToString());
account.additionalIdentification = Convert.FromBase64String(additionalIdentification.value);
}
_repositoryFactory.AccountRepository.Update(account);
}
public AccountModel Update(UpdateAccountDto dto)
{
return(ProtectedExecute <UpdateAccountDto, AccountModel>(accountDto =>
{
SessionService.CheckSession(accountDto.Session);
if (accountDto.Id != accountDto.Session.UserId)
{
throw new ForbiddenException("Account owner");
}
accountDto.Password = Hasher.GetHash(accountDto.Password);
AccountModel model = Mapper.Map <UpdateAccountDto, AccountModel>(accountDto);
return AccountRepo.Update(model.Id, model);
}, dto));
}
public IActionResult UpdateAccount([FromBody] UpdateAccountDto dto)
{
if (string.IsNullOrEmpty(dto.Password))
{
return(BadRequest("Password cannot be empty"));
}
if (dto.Password.Length < 5)
{
return(BadRequest("Password need to be 5 characters or longer"));
}
var account = _accountService.GetAccount(User.FindFirst("name").Value);
_accountService.UpdateAccount(_mapper.Map(dto, account));
return(Ok("Account updated"));
}
public async Task <IActionResult> UpdateAccountById([ModelBinder(BinderType = typeof(JsonModelBinder))][Required][FromForm(Name = "userdata")] UpdateAccountDto updateAccountDto,
[FromRoute] int userId)
{
if (User.Claims.First(c => c.Type == ClaimTypes.NameIdentifier)?.Value == userId.ToString())
{
var serviceResponse = await accountService.UpdateAccount(updateAccountDto, userId);
var controllerResponse = mapper.Map <ServiceResponse <GetAccountDto>, ControllerResponse <GetAccountDto> >(serviceResponse);
return(StatusCode(serviceResponse.StatusCode, controllerResponse));
}
else
{
return(Unauthorized(new ControllerResponse()
{
Message = "You cannot update details of other users!", Successful = false
}));
}
}
public ActionResult UpdateAccount(int id, UpdateAccountDto accountDto)
{
var existingAccount = repository.GetAccount(id);
if (existingAccount is null)
{
return(NotFound());
}
Models.Account updatedAccount = existingAccount with
{
AccountId = accountDto.AccountId,
FirstName = accountDto.FirstName,
LastName = accountDto.LastName
};
repository.UpdateAccount(updatedAccount);
return(NoContent());
}
public async Task <ApiResult> AccountUpdate(UpdateAccountDto input)
{
using var tran = await unitofWork.BeginTransactionAsync();
var account = await accountRepository.GetAsync(input.ID);
if (account == null)
{
throw new ApplicationServiceException("所选用户不存在!");
}
account.UpdateNicknameOrPassword(input.NickName, input.Password);
account.SetRoles(input.Roles);
account.User.CreateOrUpdateUser(input.User?.UserName, "", input.User?.Address, input.User?.Tel, input.User?.Gender == null ? UserGender.Unknown : (UserGender)input.User?.Gender, input.User?.BirthDay);
accountRepository.Update(account);
if (await new RoleValidityCheckSpecification(roleRepository).IsSatisfiedBy(account))
{
await unitofWork.CommitAsync(tran);
}
await BuildLoginCache(account);
return(ApiResult.Ok("用户信息更新成功"));
}
public async Task <ActionResult> Update(UpdateAccountDto updateAccountDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(x => x.Errors)));
}
var user = await GetAuthenticatedUserAccount();
if (user == null)
{
return(NotFound(new { Message = "User account not found" }));
}
if (!string.IsNullOrEmpty(updateAccountDto.Email) &&
user.Email != updateAccountDto.Email &&
await _userManager.Users.FirstOrDefaultAsync(u => u.Email == updateAccountDto.Email) == null)
{
user.EmailConfirmed = false;
user.Email = updateAccountDto.Email;
var mailToken = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationUrl = Url.Link("ConfirmEmail", new { token = mailToken, email = user.Email });
await _mailService.SendMailAsync(
user.Email,
"Agree - Confirmation",
$"<html><body>Hello, {user.DisplayName}#{user.Tag.ToString().PadLeft(4, '0')}. Please click <a href=\"{confirmationUrl}\">HERE</a> to confirm your new email.</body></html>");
}
if (!string.IsNullOrEmpty(updateAccountDto.UserName) &&
user.DisplayName != updateAccountDto.UserName)
{
var userWithSameTagAndName = await _userManager.Users.FirstOrDefaultAsync(
u => u.DisplayName == updateAccountDto.UserName &&
u.Tag == user.Tag);
if (userWithSameTagAndName == null)
{
user.DisplayName = updateAccountDto.UserName;
}
}
if (user.Tag != updateAccountDto.Tag)
{
var userWithSameTagAndName = await _userManager.Users.FirstOrDefaultAsync(
u => u.DisplayName == user.DisplayName &&
u.Tag == updateAccountDto.Tag);
if (userWithSameTagAndName == null)
{
user.Tag = updateAccountDto.Tag;
if (!string.IsNullOrEmpty(updateAccountDto.UserName) &&
user.DisplayName != updateAccountDto.UserName)
{
userWithSameTagAndName = await _userManager.Users.FirstOrDefaultAsync(
u => u.DisplayName == updateAccountDto.UserName &&
u.Tag == user.Tag);
if (userWithSameTagAndName == null)
{
user.DisplayName = updateAccountDto.UserName;
}
}
}
}
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(BadRequest(new { result.Errors }));
}
var userViewModel = _mapper.Map <ApplicationUserViewModel>(user);
Response.Cookies.Append("agreeallow_accesstoken", await _tokenService.GenerateToken(user.Email), new CookieOptions
{
HttpOnly = true,
SameSite = SameSiteMode.Strict
});
return(Ok(new UserResponse(userViewModel)));
}
public async Task <ActionResult <AccountDto> > UpdateAccount([FromRoute] int id, [FromBody] UpdateAccountDto accountDto)
{
if (!ModelState.IsValid)
{
BadRequest(ModelState);
}
var account = await _accountService.UpdateAccount(id, accountDto);
if (!account)
{
return(NotFound());
}
return(Ok());
}
private static (bool, bool) GetConditions(UpdateAccountDto dto) => (dto.Tags != null, dto.Key != null);
protected override void UpdateEntity(UpdateAccountDto updateItemDto, SharedAccount entity)
{
entity.Update(updateItemDto.FirstName, updateItemDto.LastName, updateItemDto.Email);
}
protected override async Task <GetAccountDto> ExecuteAsync(UpdateAccountCommand request, CancellationToken ct)
{
UpdateAccountDto accountDto = _mapper.Map <UpdateAccountDto>(request);
return(await _accountService.UpdateAsync(accountDto, ct));
}
public async Task <IActionResult> DepositAndWidthdraw(Guid userId, Guid accountId, [FromBody] UpdateAccountDto model, bool deposit = true)
{
if (!await _accountRepo.AccountExists(userId, accountId)) //check account exist
{
return(BadRequest("Account does not exits"));
}
lock (_lockAccount) //user lock or RabbitMQ
{
var accountFromDb = _accountRepo.GetEntities(x => true).SingleOrDefaultAsync(x => x.Id == accountId).Result;
var editAccountDto = _mapper.Map <EditAccountDto>(accountFromDb);
if (deposit)
{
editAccountDto.CurrentBalance += model.CurrentBalance;
}
else
{
editAccountDto.CurrentBalance -= model.CurrentBalance;
}
if (editAccountDto.CurrentBalance > 0)
{
var result = _accountRepo.EditByDTOAsync(editAccountDto).GetAwaiter().GetResult();
if (result)
{
_logger.LogInformation($"Deposit Success");
return(Ok("Update success"));
}
}
return(BadRequest($"Cannot Withdraw or deposit"));
}
}
//[AuthorizeRbac("accounts:write")]
public async Task <IActionResult> UpdateAccount(int accountId, UpdateAccountDto accountDto)
{
return(Ok(await _updateAccount.UpdateAccountAsync(accountId, accountDto)));
}
