public HttpResponseMessage UpdateAccount()
{
var body = Request.Content.ReadAsStringAsync().Result;
UpdateAccountModel account =
JsonConvert.DeserializeObject <UpdateAccountModel>(Encrypt.DecryptRJ256(body,
Config.AESKey, Config.IV));
// TODO : à modifier
// Ajoutez ici votre logique de verification des donnees en base à partir de l'objet UpdateAccountModel
// Exemple de composition du modele à partir des donnees en base
ValidationResponseModel model = new ValidationResponseModel
{
IsValid = true,
CodeUtilisateur = account.CodeUtilisateur,
PartenaireID = Config.PartID
};
string json = Encrypt.EncryptRJ256(JsonConvert.SerializeObject(model), Config.AESKey, Config.IV);
string timeStampHeader = Timestamp.UnixTimestamp().ToString();
string concat = string.Concat(Config.PartID.ToString(), "+", timeStampHeader, "+", Config.CodeSecret);
HttpContext.Current.Response.AddHeader("X-TS", timeStampHeader);
HttpContext.Current.Response.AddHeader("X-PART", Config.PartID.ToString());
HttpContext.Current.Response.AddHeader("X-LPL", Hash.SHA1Hash(Encoding.UTF8.GetBytes(concat)));
var resp = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(json, Encoding.UTF8, "text/plain")
};
return(resp);
}
public async Task <bool> UpdateAccount(string id, UpdateAccountModel account)
{
_logger.Debug($"Updating account {id}");
var objectId = ObjectId.Parse(id);
if (account == null)
{
throw new Exception($"Account not provided for id={id}");
}
if (id != account.Id)
{
throw new Exception($"Id {id} is different from account's id {account.Id}");
}
var modificationUpdate = Builders <Account> .Update
.Set(x => x.Name, account.Name)
.Set(x => x.Description, account.Description)
.Set(x => x.Status, account.Status)
.Set(x => x.ModificationDate, DateTime.UtcNow);
var result = await MvcApplication.MongoDbAccountContext.Accounts.UpdateOneAsync(x => x._id == objectId, modificationUpdate);
_logger.Debug($" account {id} updated. isAcknownledged?: {result.IsAcknowledged}.");
return(result.IsAcknowledged);
}
public async Task <bool> UpdateAccount([FromBody] UpdateAccountModel model)
{
var result = false;
result = await Server.UpdateAccount(model.ID, model.Name, model.Description);
return(result);
}
public async Task <IActionResult> UpdateAccount(UpdateAccountModel model)
{
try
{
if (ModelState.IsValid)
{
var isEmailUpdated = false;
var user = await userManager.GetUserAsync(HttpContext.User);
if (!user.Email.Equals(model.Email, StringComparison.OrdinalIgnoreCase))
{
isEmailUpdated = true;
}
user.DisplayName = model.DisplayName;
user.Username = model.Username;
user.Photo = model.Photo;
user.Email = model.Email;
user.IsEmailConfirmed = isEmailUpdated ? false : user.IsEmailConfirmed;
var result = await userManager.UpdateAsync(user);
if (result.Succeeded)
{
if (isEmailUpdated)
{
// TODO send mail
}
return(Accepted(new
{
user.Id,
user.Username,
user.DisplayName,
user.Photo,
user.Email,
user.IsEmailConfirmed
}));
}
else
{
return(StatusCode(HttpStatusCode.BadRequest, result.Errors.Select(x => new
{
x.Code,
x.Description
})));
}
}
//return StatusCode(HttpStatusCode.BadRequest, "Invalid payloads");
return(InvalidModelResult());
}
catch (Exception ex)
{
return(ErrorResult(ex));
}
}
public JsonResult ChangePasswordVerify(UpdateAccountModel model)
{
string username = Session["userName"].ToString();
UpdateAccountModel uam = new UpdateAccountModel();
model.username = username;
string check = uam.ChangePassword(model);
return(Json(check, JsonRequestBehavior.AllowGet));
}
public IActionResult UpdateAccount()
{
var model = new UpdateAccountModel
{
DisplayName = _user.DisplayName,
EnableImport = _user.EnableImport
};
return(View(model));
}
public async Task <IActionResult> UpdateAccount(UpdateAccountModel update)
{
var user = await _userManager.FindByEmailAsync(User.Identity.Name);
user.DisplayName = update.DisplayName;
user.EnableImport = update.EnableImport;
await _userManager.UpdateAsync(user);
ShowStatusMessage(MessageTypeEnum.info, "User profile updated", "Profile");
return(RedirectToAction("UpdateAccount", "Account"));
}
public async Task <ActionResult> Edit(string id)
{
var account = await _accountService.GetAccountById(id);
var editAccountModel = new UpdateAccountModel
{
Id = account.Id,
Name = account.Name,
Description = account.Description,
Status = account.Status
};
return(View(editAccountModel));
}
public async Task <IActionResult> Update([FromBody] UpdateAccountModel model)
{
var login = User.Claims.First(x => x.Type == ClaimTypes.Name).Value;
var res = await this.userStorage.UpdateUser(new User()
{
FirstName = model.FirstName,
LastName = model.LastName,
Login = login
});
return(Ok(new ApiResponse()
{
Error = res.Error
}));
}
public async Task <IActionResult> UpdateAccountAsync(string id, [FromBody] UpdateAccountModel model)
{
if (GetUserId() != id || GetUserId() != model.UserId)
{
var forbidden = new ForbiddenResponse();
return(StatusCode(forbidden.Status, forbidden));
}
if (!ModelState.IsValid)
{
var result = await _updateAccountCommand.RunAsync(model);
return(StatusCode(result.Status, result.Payload));
}
return(new BadRequestObjectResult(new BadRequestResponse(ModelState)));
}
public async Task <ModelStateDictionary> UpdateAccountAsync(UpdateAccountModel model)
{
_logger.LogInformation($"Updating account for: {model.UserId}");
var modelState = new ModelStateDictionary();
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
_logger.LogError($"User not found: {model.UserId}");
modelState.AddModelError(USERID_PROPERTY, "User not found.");
return(modelState);
}
var firstName = model.FirstName.CapitalizeFirstLetter();
var surname = model.Surname.CapitalizeFirstLetter();
user.FirstName = firstName;
user.Surname = surname;
user.UserName = $"{firstName[0]}{surname}";
var accountUpdateResult = await _userManager.UpdateAsync(user);
if (!accountUpdateResult.Succeeded)
{
foreach (var error in accountUpdateResult.Errors)
{
switch (error.Code)
{
default:
modelState.AddModelError(FIRSTNAME_PROPERTY, error.Description);
modelState.AddModelError(SURNAME_PROPERTY, error.Description);
break;
}
}
_logger.LogError($"Error updating account for: {model.UserId}");
return(modelState);
}
var sendEmailResult = await _emailGateway.SendEmailAsync(
new UpdateAccountMessage(user.Email));
_logger.LogInformation($"Account Updated: {model.UserId}");
return(modelState);
}
public async Task <IActionResult> UpdateAccount(Guid id, [FromBody] UpdateAccountModel account, [FromHeader(Name = "Authorization")] string jwt)
{
try
{
var result = await _accountService.UpdateAccount(id, account, jwt);
if (result == null)
{
return(BadRequest("email invalid"));
}
return(Ok(result));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task UpdateAccount_NewAccountData_ReturnsAccountWithoutSensitiveData()
{
var id = Guid.NewGuid();
const string emailOld = "*****@*****.**";
const string emailNew = "*****@*****.**";
const string jwt = "";
var account = new Account
{
Id = id,
Email = emailOld,
isDelegate = true,
isDAppOwner = false
};
var updateModel = new UpdateAccountModel
{
Email = emailNew,
isDelegate = false,
isDAppOwner = true
};
var updatedAccount = new Account
{
Id = id,
Email = emailNew,
isDelegate = false,
isDAppOwner = true
};
_regexHelper.Setup(r => r.IsValidEmail(emailNew)).Returns(true);
_repository.Setup(x => x.Get(id)).ReturnsAsync(account);
_repository.Setup(x => x.Get(updateModel.Email));
_repository.Setup(x => x.Update(id, It.IsAny<Account>())).ReturnsAsync(updatedAccount);
_jwtIdClaimReaderHelper.Setup(x => x.getUserIdFromToken(jwt)).Returns(id);
var result = await _accountService.UpdateAccount(id, updateModel, jwt);
Assert.NotEqual(emailOld, result.Email);
Assert.False(result.isDelegate);
Assert.True(result.isDAppOwner);
}
public async Task <Account> UpdateAccount(Guid id, UpdateAccountModel model, string jwt)
{
if (!_regexHelper.IsValidEmail(model.Email))
{
throw new InvalidEmailException();
}
var account = await _repository.Get(id);
if (account == null)
{
throw new AccountNotFoundException();
}
var accountWithConflictingEmail = await _repository.Get(model.Email);
if (accountWithConflictingEmail != null && account.Email != accountWithConflictingEmail.Email)
{
throw new EmailAlreadyExistsException();
}
if (_jwtIdClaimReaderHelper.getUserIdFromToken(jwt) != account.Id)
{
throw new NotAuthenticatedException();
}
account.Email = model.Email;
account.isDelegate = model.isDelegate;
account.isDAppOwner = model.isDAppOwner;
var updatedAccount = await _repository.Update(id, account);
if (updatedAccount == null)
{
throw new AccountNotFoundException();
}
else
{
await _userMarketplacePublisher.PublishUpdateUser(updatedAccount);
return(updatedAccount.WithoutSensitiveData());
}
}
public async Task <ActionResult> Edit(string id, UpdateAccountModel account)
{
if (account == null)
{
throw new Exception($"Account not provided for id={id}");
}
if (id != account.Id)
{
throw new Exception($"Id {id} is different from account's id {account.Id}");
}
if (ModelState.IsValid)
{
var result = await _accountService.UpdateAccount(id, account);
return(RedirectToAction("Details", "Accounts", new { id }));
}
return(View(account));
}
public async Task <int> UpdateAsync(UpdateAccountModel accountModel)
{
Guard.IsNotNullOrEmpty(accountModel.Name, nameof(accountModel.Name));
var account = await _accountRepository
.GetByIdWithCurrencyAsync(accountModel.Id);
if (account == null)
{
throw new BudgetValidationException(
string.Format(ValidationMessages.Common.EntityDoesNotExist, nameof(account), accountModel.Id));
}
account.CurrencyId = accountModel.CurrencyId;
account.Name = accountModel.Name;
account.InitialBalance = accountModel.InitialBalance;
await _accountRepository.UpdateAsync(account);
return(account.Id);
}
public async Task <IActionResult> Update([FromBody] UpdateAccountModel model)
{
using (var client = clientHelper.GetServiceSecuredClient(User))
{
var getResponse = await client.PostAsync(this.routeTable.GetRoute(SvcRouteTable.UpdateAccount),
new StringContent(
JsonConvert.SerializeObject(new
{
FirstName = model.FirstName,
LastName = model.LastName,
}), Encoding.UTF8, ApplicationJson));
if (!getResponse.IsSuccessStatusCode)
{
return(new StatusCodeResult((int)getResponse.StatusCode));
}
var content = await getResponse.Content.ReadAsStringAsync();
return(Content(content, ApplicationJson));
}
}
public HttpResponseMessage Account(UpdateAccountModel model)
{
using (var repo = new AccountRepository(_systemDataContext))
{
var account = repo.Get(model.AccountId);
if (account == null)
{
return(Utils.Invalid("Unable to find account to update"));
}
account = model.Map();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(repo.Update(account).ToJson(), Encoding.UTF8, "application/json")
};
return(response);
}
}
public ActionResult UpdateAccountPost(UpdateAccountModel model)
{
var resp = _wfsUSerManager.SaveCustomer(new SaveWFSUserRequest()
{
UserInfo = model.UserInfo
});
if (resp.Status == Status.Success)
{
var uiresponse = resp.ToUIResult<UpdateAccountModel, WFSUser>(x => model, x => RenderPartialViewToString("UpdateAccount", x));
return Json(uiresponse);
}
else
{
var uiResp = resp.ToUIResult<UpdateAccountModel, WFSUser>(x => model, x =>
{
x.Merge(resp);
return RenderPartialViewToString("UpdateAccount", model);
});
return Json(uiResp);
}
}
public async Task <IActionResult> Update(UpdateAccountModel updateAccountModel) => Ok(await _accountService.UpdateAsync(updateAccountModel));
public ActionResult UpdateAccount()
{
var resp = _wfsUSerManager.GetWfsUserInfoById(new GetWfsUserInfoByIdRequest() { MembershipId = AuthenticatedMembershipId });
var m = new UpdateAccountModel()
{
UserInfo = resp.Value
};
m.Merge(resp);
return View(m);
}
public OkResult Update(int id, [FromBody] UpdateAccountModel res)
{
_accountService.Update(id, res.Email, res.FirstName, res.Name, res.Password);
return(Ok());
}
public ActionResult UpdatePassword(UpdateAccountModel model)
{
var user = Membership.GetUser(model.UserInfo.MembershipGuid);
var res = user.ChangePassword(model.OldPassword, model.Password);
if (res)
{
var uiresponse = new UIResponse<UpdateAccountModel>();
uiresponse.Subject = model;
uiresponse.Status = Status.Success;
return Json(uiresponse);
}
else
{
var uiresponse = new UIResponse<UpdateAccountModel>();
uiresponse.Subject = model;
uiresponse.Status = Status.Error;
return Json(uiresponse);
}
}
