public virtual async Task <IHttpActionResult> UpdateAccountAsync(EditAccountRequest request)
{
var param = new UpdateAccountParam
{
CustomerId = ComposerContext.CustomerId,
Scope = ComposerContext.Scope,
PreferredLanguage = request.PreferredLanguage,
Email = request.Email,
FirstName = request.FirstName,
LastName = request.LastName,
CultureInfo = ComposerContext.CultureInfo,
};
var urlParam = new BaseUrlParameter {
CultureInfo = param.CultureInfo
};
var addressListUrl = MyAccountUrlProvider.GetAddressListUrl(urlParam);
var changePasswordUrl = MyAccountUrlProvider.GetChangePasswordUrl(urlParam);
var viewModel = await CustomerViewService.UpdateAccountAsync(param);
if (viewModel == null)
{
return(Unauthorized());
}
viewModel.AddressListUrl = addressListUrl;
viewModel.ChangePasswordUrl = changePasswordUrl;
return(Ok(viewModel));
}
public static void Execute(Guid id, EditAccountRequest request)
{
var commands = new List <DAL.Models.Player>();
request.Command.ForEach(x =>
{
var player = new DAL.Models.Player
{
MiddleName = x.MiddleName,
Name = x.Name,
Number = x.Number,
PlayerId = x.PlayerId,
Surname = x.Surname
};
commands.Add(player);
});
var account = new DAL.Models.EditAccountRequest
{
Command = commands,
Email = request.Email,
Photo = request.Photo,
Name = request.Name,
Phone = request.Phone
};
DbHelper.EditAccountInfo(id, account);
}
public async Task <OperationStatusInfo> UpdateAccount(object updatedAccount)
{
return(await Task.Run(() =>
{
OperationStatusInfo operationStatusInfo = new OperationStatusInfo(operationStatus: OperationStatus.Done);
string attachedObjectText = updatedAccount.ToString();
Account newAccount = JsonConvert.DeserializeObject <Account>(attachedObjectText);
EditAccountRequest editAccountRequest = new EditAccountRequest(newAccount.Id, newAccount.LastName, newAccount.FirstName, newAccount.SecondName, newAccount.Photo);
try
{
EditAccountResponse editAccountResponse = hubController.UseCaseFactory.CreateEditAccountUseCase().Execute(editAccountRequest);
AccountDTO accountDTO = hubController.TransformAccount(editAccountResponse.Account);
operationStatusInfo.AttachedObject = accountDTO;
operationStatusInfo.AttachedInfo = "Account is updated!";
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
operationStatusInfo.OperationStatus = OperationStatus.Cancelled;
operationStatusInfo.AttachedInfo = ex.Message;
}
return operationStatusInfo;
}));
}
public EditAccountPopup(EditAccountRequest request)
{
InitializeComponent();
_request = request;
this.AccountName = _request.CurrentAccountName;
this.DataContext = this;
SaveAccountCommand = new DelegateCommand<object>(this.SaveAccountExecute, this.CanSaveAccountExecute);
CancelCommand = new DelegateCommand<object>(this.CancelExecute);
this.PropertyChanged += this.OnPropertyChanged;
this.Validate();
}
public async Task <IActionResult> Create(EditAccountRequest request)
{
if (await _mediator.Send(new AccountExistsQuery(request.Username)))
{
ModelState.AddModelError("username", $"User '{request.Username}' already exist.");
return(Conflict(ModelState));
}
await _mediator.Send(new CreateAccountCommand(request));
return(Ok());
}
public ActionResult EditShippingAddress([FromBody] EditAccountRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var UserToEdit = new Users {
Email = request.Email, ShippingAddress = request.ShippingAddress
};
_userService.Edit(UserToEdit);
return(Ok(UserToEdit.ShippingAddress));
}
public async Task EditAsync(EditAccountRequest request)
{
try
{
var user = await _userManager.FindByNameAsync(request.Name);
//delete roles first
var roles = await _userManager.GetRolesAsync(user);
await _userManager.RemoveFromRolesAsync(user, roles);
if (request.Roles != null)
{
await request.Roles.ForEachAsync(async role =>
{
if (await _roleManager.RoleExistsAsync(role))
{
await _userManager.AddToRoleAsync(user, role);
}
});
}
//delete claims first
var claims = await _userManager.GetClaimsAsync(user);
await _userManager.RemoveClaimsAsync(user, claims);
if (request.Claims != null)
{
await request.Claims.ForEachAsync(async claim =>
{
await _userManager.AddClaimAsync(user, new Claim("feature", claim));
});
}
//delete resources first
ResetResources(request.Id);
if (request.Resources != null)
{
AssignResource(request.Id, request.Resources);
}
}
catch (Exception e)
{
throw e;
}
}
public void EditAccountUseCaseEqualTest()
{
EditAccountRequest editAccountRequest = new EditAccountRequest(id, lastName, firstName, secondName, photo);
IUnitOfWorkFactory unitOfWorkFactory = new UnitOfWorkFactory();
IUnitOfWork unitOfWork = unitOfWorkFactory.CreateUnitOfWork();
unitOfWork.GetAccountsFromDatabase();
IActivityFactory activityFactory = new ActivityFactory(unitOfWork, new ValidationRuleFactory());
IUseCaseFactory useCaseFactory = new UseCaseFactory(activityFactory);
EditAccountResponse editAccountResponse = useCaseFactory.CreateEditAccountUseCase().Execute(editAccountRequest);
Assert.AreEqual(editAccountResponse.Account.LastName, lastName);
Assert.AreEqual(editAccountResponse.Account.FirstName, firstName);
Assert.AreEqual(editAccountResponse.Account.SecondName, secondName);
}
public async Task <IActionResult> Edit(int?id, [Bind("Id,Name,Email,SelectedRoles,SelectedClaims, SelectedResources")] User user)
{
if (id != user.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var claims = await _claimService.ListAsync();
var roles = await _roleService.GetAsync();
var userDto = new EditAccountRequest
{
Id = user.Id,
Name = user.Name,
Email = user.Email,
Claims = user.SelectedClaims != null?claims.Where(c => user.SelectedClaims.Contains(c.Value)).Select(c => c.Value).ToList() : null,
Roles = user.SelectedRoles != null?roles.Where(c => user.SelectedRoles.Contains(c.Name)).Select(c => c.Name).ToList() : null,
Resources = user.SelectedResources
};
await _userService.EditAsync(userDto);
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(user.Id))
{
return(NotFound());
}
throw;
}
return(RedirectToAction("Index"));
}
return(View(user));
}
public void EditAccountUseCaseNotEqualTest()
{
Exception exception = null;
try
{
EditAccountRequest editAccountRequest = new EditAccountRequest(10, lastName, firstName, secondName, photo);
IUnitOfWorkFactory unitOfWorkFactory = new UnitOfWorkFactory();
IUnitOfWork unitOfWork = unitOfWorkFactory.CreateUnitOfWork();
unitOfWork.GetAccountsFromDatabase();
IActivityFactory activityFactory = new ActivityFactory(unitOfWork, new ValidationRuleFactory());
IUseCaseFactory useCaseFactory = new UseCaseFactory(activityFactory);
EditAccountResponse editAccountResponse = useCaseFactory.CreateEditAccountUseCase().Execute(editAccountRequest);
}
catch (Exception ex)
{
exception = ex;
}
Assert.AreEqual(exception.Message, "The account is not updated and not found!");
}
private void OnEditAccountRequest(EditAccountRequest request)
{
EditAccountPopup popup = new EditAccountPopup(request);
popup.Show();
}
public CreateAccountCommand(EditAccountRequest request)
{
Username = request.Username;
ClearPassword = request.Password;
}
private void EditAccountExecute(object dummyObject)
{
// Send EditAccountRequestEvent to create the EditAccount dialog
EditAccountRequest request =
new EditAccountRequest
{
AccountId = ((BrokerageAccountSummary)dummyObject).Id,
CurrentAccountName = ((BrokerageAccountSummary)dummyObject).Name,
ResponseHandler = EditAccountResponseHandler
};
_eventAggregator.GetEvent<EditAccountRequestEvent>().Publish(request);
}
public async Task Edit([FromBody] EditAccountRequest request) =>
await _accountManager.ChangeAccountValueAsync(request.UserName, request.AccountName,
request.CurrencyName, request.Value);
public void EditAccountInfo(EditAccountRequest request) => EditAccountInfoBLL.Execute(Guid.Parse(GetAccountId()), request);
