public void Transfer(AccountTransfer transferAccount)
{
var command = new CreateTransferCommand(transferAccount.FromAccount, transferAccount.ToAccount,
transferAccount.TransferAmount);
_bus.SendCommand(command);
}
public void TransferFunds(AccountTransfer accountTransfer)
{
CreateTransferCommand createTransfer = new CreateTransferCommand(accountTransfer.AccountSource,
accountTransfer.AccountTarget, accountTransfer.TransferAmount);
_eventBus.SendCommand(createTransfer);
}
public async Task <IEnumerable <Account> > Handle(CreateTransferCommand request, CancellationToken cancellationToken)
{
await _accountRepository.Transfer(request.From, request.To, request.Amount);
_eventBus.PublishEvent(new TransferCompletedEvent(request.From, request.To, request.Amount));
return(await _accountRepository.GetAccounts());
}
public async Task Succeed_With_Valid_Request(
CreateAccountCommand createToAccountCommand,
CreateAccountCommand createFromAccountCommand,
CreateCreditCommand createCreditCommand,
TestServer server)
{
var client = server.CreateClient();
var initialToAccount = await client.PostAsJsonAsync <CreateAccountCommand, AccountModel>("api/accounts", createToAccountCommand);
var initialFromAccount = await client.PostAsJsonAsync <CreateAccountCommand, AccountModel>("api/accounts", createFromAccountCommand);
var funds = await client.PostAsJsonAsync <FundsModel, FundsModel>($"api/accounts/{initialFromAccount.AccountId}/credits", createCreditCommand.Funds);
initialFromAccount.Balance = funds.Amount;
var createTransferCommand = new CreateTransferCommand()
{
Funds = createCreditCommand.Funds,
ReceivingAccountId = initialToAccount.AccountId,
SendingAccountId = initialFromAccount.AccountId
};
await client.PostAsJsonAsync <CreateTransferCommand, FundsModel>($"api/accounts/transfers", createTransferCommand);
var resultToAccount = await client.GetAsync <AccountModel>($"api/accounts/{initialToAccount.AccountId}");
var resultFromAccount = await client.GetAsync <AccountModel>($"api/accounts/{initialFromAccount.AccountId}");
Assert.True(resultFromAccount.Balance ==
initialFromAccount.Balance - createCreditCommand.Funds.Amount);
Assert.True(resultToAccount.Balance ==
initialToAccount.Balance + createCreditCommand.Funds.Amount);
}
public void TransferFunds(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(accountTransfer.FromAccount, accountTransfer.ToAccount, accountTransfer.TransferAmount
);
_bus.SendCommand(createTransferCommand);
}
public void Transfer(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(accountTransfer.SourceAccount,
accountTransfer.TargetAccount, accountTransfer.TransferAmount);
_bus.SendCommand(createTransferCommand);
}
public void CreateTransfer(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(accountTransfer.FromAccount,
accountTransfer.ToAccount, accountTransfer.TransferAmount);
_eventBus.SendCommand(createTransferCommand);
}
public async Task TransferFunds(AccountTransferModel accountTransferModel)
{
var createTransferCommand = new CreateTransferCommand(accountTransferModel.ToAccount,
accountTransferModel.FromAccount, accountTransferModel.TransferAmount);
await _bus.SendCommand(createTransferCommand);
}
public async Task <IActionResult> Transfer(CreateTransferCommand query)
{
if (!ModelState.IsValid)
{
return(View(await _mediator.Send(new GetAccountTransferDataQuery {
CustomerId = query.CustomerId
})));
}
else
{
try
{
await _mediator.Send(query);
TempData["successMessage"] = "Transfer sent successfully";
return(RedirectToAction("Transfer", new { customerId = query.CustomerId }));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(await _mediator.Send(new GetAccountTransferDataQuery {
CustomerId = query.CustomerId
})));
}
}
}
public void Transfer(TransferAmmount transferAmmount)
{
var createTransferCommand = new CreateTransferCommand(
transferAmmount.FromAccount, transferAmmount.TOAccount, transferAmmount.Balence);
bus.SandCommand(createTransferCommand);
}
public void Transfer(TransferAmmount ta)
{
// command create -- domain e command class ache
var createTransferCommand = new CreateTransferCommand(ta.FromAccount, ta.TOAccount, ta.Balence);
// use bus send command
_bus.SandCommand(createTransferCommand);
}
public async Task TransferAsync(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(
accountTransfer.SourceAccountId,
accountTransfer.TargetAccountId,
accountTransfer.Amount);
await eventBus.SendCommandAsync(createTransferCommand);
}
public void Transfer(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(
accountTransfer.FromAccount,
accountTransfer.ToAccount,
accountTransfer.TransferAccount
);
}
void IAccountService.Transfer(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(
accountTransfer.FromAccount,
accountTransfer.ToAccount,
accountTransfer.TransferAmount);
_bus.SendCommand(createTransferCommand);
}
public void Transfer(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(
accountTransfer.AccountSource,
accountTransfer.AccountTarget,
accountTransfer.TranferAmount);
_eventBus.SendCommand(createTransferCommand);
}
public void TransferToMQ(TestTransfer testRecModel)
{
var createTransferCommand = new CreateTransferCommand(
testRecModel.FirstName,
testRecModel.SurName
);
_bus.SendCommand(createTransferCommand);
}
public void Transfer(AccTransfer _AccTransfer)
{//from to am
var _CreateTransferCommand = new CreateTransferCommand(
_AccTransfer.FromAccount,
_AccTransfer.ToAccoun,
_AccTransfer.TransferAmoun);
_bus.SendCommand(_CreateTransferCommand);
}
public void Transfer(AccountTransferViewModel accountTransferViewModel)
{
var createTransferCommand = new CreateTransferCommand(
accountTransferViewModel.FromAccount,
accountTransferViewModel.ToAccount,
accountTransferViewModel.TransferAmount
);
_bus.SendCommand(createTransferCommand);
}
public void Transfer(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(
accountTransfer.AccountFrom,
accountTransfer.AccountTo,
accountTransfer.TransferAmount
);
_bus.SendCommand(createTransferCommand);
}
public async Task Transfer(AccountTransfer transfer)
{
var createTransferCommand = new CreateTransferCommand(
transfer.FromAccount,
transfer.ToAccount,
transfer.Amount
);
await _bus.SendCommand(createTransferCommand);
}
public void Transfer(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(
from: accountTransfer.FromAccount,
to: accountTransfer.ToAccount,
amount: accountTransfer.TransferAmount
);
_bus.SendCommand(createTransferCommand);
}
public void Transfer(AccountTransfer accountRequest)
{
var createTransferCommand = new CreateTransferCommand(
from: accountRequest.FromAccount,
to: accountRequest.ToAccount,
ammount: accountRequest.TransferAmmount
);
_eventBus.SendCommand(createTransferCommand);
}
public async Task <IEnumerable <Account> > Transfer(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(
accountTransfer.FromAccount,
accountTransfer.ToAccount,
accountTransfer.TransferAmount
);
return(await _eventBus.SendCommand <CreateTransferCommand, IEnumerable <Account> >(createTransferCommand));
}
public async void CreateTransfer(ChangeBalanceTransaction transaction)
{
// create command
var command = new CreateTransferCommand()
{
Amount = transaction.Amount, FromAccount = transaction.FromAccount, ToAccount = transaction.ToAccount
};
// publish it to the event bus
await _bus.SendCommand(command); // ? if i didnt use an await we can have an error in dif thred and it will not be displayed
}
public void Transfer(AccountTransfer accountTransfer)
{
var createTransferCommnad = new CreateTransferCommand(
accountTransfer.FromAccount,
accountTransfer.ToAccount,
accountTransfer.TransferAmount
);
var gg = _bus.SendCommand(createTransferCommnad);
}
public void Transfer(AccountTransfer accountTransfer)
{
var TransferCommand = new CreateTransferCommand(
accountTransfer.FromAccount,
accountTransfer.ToAccount,
accountTransfer.TransferAmount
);
this._bus.SendCommand(TransferCommand);
}
public void Transfer(AccountTransferDto accountTransferDto)
{
var createTransferCommand = new CreateTransferCommand(
accountTransferDto.FromAccount,
accountTransferDto.ToAccount,
accountTransferDto.TransferAmount
);
_bus.SendCommand(createTransferCommand);
}
public void TransferFunds(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(
accountTransfer.AccountSource,
accountTransfer.AccountTarget,
accountTransfer.TransferAmount
);
//So beautiful
_bus.SendCommand(createTransferCommand);
}
public void Transfer(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(
accountTransfer.FromAccount,
accountTransfer.ToAccount,
accountTransfer.TransferAmount
);
//There is MY CreateTransferCommand and now we use the Bus to send the command to our TransferCommandHandler.
_bus.SendCommand(createTransferCommand);
}
public async Task Transfer(AccountTransfer accountTransfer)
{
var createTransferCommand = new CreateTransferCommand(accountTransfer.FromAccount, accountTransfer.ToAccount, accountTransfer.TransferAmount);
bool successfull = await _eventBus.SendCommand(createTransferCommand);
if (!successfull)
{
//Log error
}
}
