public void Withdraw_Execute_BalanceUpdatesOK()
{
WithdrawTransaction withdraw = new WithdrawTransaction(account, 100);
_ = withdraw.Execute();
Assert.Equal(0, account.Balance);
}
public void Withdraw_Executes_ExecutedIsTrue()
{
WithdrawTransaction withdraw = new WithdrawTransaction(account, 100);
_ = withdraw.Execute();
Assert.True(withdraw.Executed);
}
public void Withdraw_Execute_StatusComplete()
{
WithdrawTransaction withdraw = new WithdrawTransaction(account, 100);
_ = withdraw.Execute();
Assert.Equal("Complete", withdraw.Status);
}
private static void DoWithdraw(Bank fromBank)
{
Account fromAccount = FindAccount(fromBank);
if (fromAccount == null)
{
return;
}
decimal amount;
Console.Write("Please enter the amount to withdraw: ");
try
{
amount = Convert.ToDecimal(Console.ReadLine());
WithdrawTransaction withdraw = new WithdrawTransaction(fromAccount, amount);
Bank.ExecuteTransaction(withdraw);
}
catch (Exception e)
{
Console.WriteLine("Withdrawal error!");
Console.WriteLine(e.Message);
}
}
public void Withdraw_SetId_OK()
{
WithdrawTransaction withdraw = new WithdrawTransaction(account, 100);
withdraw.SetId(1);
Assert.Equal(1, withdraw.Id);
}
public TransactionDetailDto AsTransactionDetailDto(Transaction transaction)
{
TransactionDetailDto dto = new TransactionDetailDto();
switch (transaction.Type)
{
case "Deposit":
DepositTransaction deposit = transaction as DepositTransaction;
dto.ToAccountId = deposit.Account.Id;
break;
case "Withdraw":
WithdrawTransaction withdraw = transaction as WithdrawTransaction;
dto.FromAccountId = withdraw.Account.Id;
break;
case "Transfer":
TransferTransaction transfer = transaction as TransferTransaction;
dto.FromAccountId = transfer.From.Id;
dto.ToAccountId = transfer.To.Id;
break;
default:
break;
}
dto.Id = transaction.Id;
dto.Type = transaction.Type;
dto.Amount = transaction.Amount;
dto.DateStamp = transaction.DateStamp;
dto.Status = transaction.Status;
return(dto);
}
public TransferTransaction(Account sourceAccount, Account destinationAccount, double amount)
: base(destinationAccount, amount)
{
SetDescription("Transfer In");
_withdrawTransaction = new WithdrawTransaction(sourceAccount, amount);
_withdrawTransaction.SetDescription("Transfer Out");
}
private static void DoWithdraw(Bank fromBank)
{
Account toBank = FindAccount(fromBank);
if (toBank == null)
{
return;
}
String input;
decimal withdraw = 0;
Console.WriteLine("How much would you like to withdraw?: ");
input = Console.ReadLine();
withdraw = Convert.ToDecimal(input);
try
{
input = Console.ReadLine();
withdraw = Convert.ToDecimal(input);
}
catch (System.FormatException)
{
Console.WriteLine("Not a number");
}
WithdrawTransaction withdrawT = new WithdrawTransaction(toBank, withdraw);
fromBank.ExecuteTransaction(withdrawT);
withdrawT.Print();
}
private static void DoWithdraw(Bank toBank)
{
Decimal WithdrawAmount;
Account toAccount = FindAccount(toBank);
if (toAccount == null)
{
return;
}
try
{
Console.WriteLine("How much would you like to Withdraw? ");
WithdrawAmount = Convert.ToDecimal(Console.ReadLine());
}
catch
{
WithdrawAmount = 0;
}
WithdrawTransaction withdrawtransac = new WithdrawTransaction(toAccount, WithdrawAmount);
toBank.ExecuteTransaction(withdrawtransac);
withdrawtransac.Print();
}
private static void DoWithdraw(Bank toBank)
{
decimal amount;
do
{
try
{
Account toAccount = FindAccount(toBank);
if (toAccount == null)
{
return;
}
Console.WriteLine(" Enter amount to withdraw: ");
amount = Convert.ToDecimal(Console.ReadLine());
WithdrawTransaction withdraw = new WithdrawTransaction(toAccount, amount);
toBank.ExecuteTransaction(withdraw);
}
catch (System.Exception)
{
Console.Error.WriteLine(" You have entered an invalid value! ");
amount = -1;
}
} while(amount < 1);
}
public void Withdraw_Rollback_BalanceUpdatesOK()
{
WithdrawTransaction withdraw = new WithdrawTransaction(account, 100);
withdraw.Execute();
withdraw.Rollback();
Assert.Equal(100, account.Balance);
}
public TransferTransaction(Account fromAccount, Account targetAccount, double transactionAmount)
: base(targetAccount, transactionAmount)
{
Memo = "Transfer In";
withdrawTransacation = new WithdrawTransaction(fromAccount, transactionAmount);
withdrawTransacation.Memo = "Transfer Out";
}
public TransferTransaction(Account fromAccount, Account toAccount, decimal amount)
{
_fromAccount = fromAccount;
_toAccount = toAccount;
_amount = amount;
_theWithdraw = new WithdrawTransaction(fromAccount, amount);
_theDeposit = new DepositTransaction(toAccount, amount);
}
public void Withdraw_Rollback_OK()
{
WithdrawTransaction withdraw = new WithdrawTransaction(account, 100);
_ = withdraw.Execute();
_ = withdraw.Rollback();
Assert.True(withdraw.Reversed);
}
public Transaction NewWithdraw(Account account, decimal amount)
{
WithdrawTransaction withdraw = new WithdrawTransaction(account, amount);
CreateTransaction(withdraw);
Execute(withdraw);
_transactionRepository.Update(withdraw);
return(withdraw);
}
public async Task <JsonResult> WithdrawTransaction(WithdrawTransaction withdrawTransaction, string tenantUid)
{
var origin = TenantHelper.GetCurrentTenantUrl(contentService, tenantUid);
var token = Request.Cookies["token"].Value;
var response = (WithdrawTransactionResponseContent)await _transactionHistoryService.WithdrawTransaction(tenantUid, token, origin, withdrawTransaction);
return(Json(response));
}
public virtual TransactionResult withdraw(WithdrawTransaction withdrawTransaction)
{
if (withdrawTransaction.TransactionAmount > this.balance)
{
return TransactionResult.INSUFFICIENT_FUND;
}
balance -= withdrawTransaction.TransactionAmount;
transactionHistories.Add(withdrawTransaction);
return TransactionResult.SUCCESS;
}
public Transaction NewWithdraw(Account account, decimal amount)
{
Guard.Against.Null(account, "Account");
Guard.Against.Negative(amount, "Amount");
WithdrawTransaction withdraw = new WithdrawTransaction(account, amount);
CreateTransaction(withdraw);
Execute(withdraw);
return(withdraw);
}
public void Transfer_RollbackWithInsufficientFunds_ThrowsInsufficientFundsException()
{
TransferTransaction transfer = new TransferTransaction(from, to, 50);
_ = transfer.Execute();
WithdrawTransaction withdraw = new WithdrawTransaction(to, to.Balance);
withdraw.Execute();
Assert.Throws <InsufficientFundsException>(() => transfer.Rollback());
}
public void Deposit_Rollback_InsufficientFundsThrowsInsufficientFundsException()
{
DepositTransaction deposit = new DepositTransaction(account, 100);
_ = deposit.Execute();
WithdrawTransaction withdraw = new WithdrawTransaction(account, 150);
_ = withdraw.Execute();
Assert.Throws <InsufficientFundsException>(() => deposit.Rollback());
}
public async Task RecordWithdrawTransactionAsync(Guid bankingAccountId, decimal amount, CancellationToken cancellationToken = default(CancellationToken))
{
var account = await accountRepository.GetByIdAsync(bankingAccountId, cancellationToken);
if (account == null)
{
throw new AccountNotFoundException(bankingAccountId);
}
var withDrawTransaction = new WithdrawTransaction(account, amount);
transactionManager.AddTransaction(withDrawTransaction);
await transactionManager.ProcessTransactionsAsync();
}
public async Task <IResponseContent> WithdrawTransaction(string tenantUid, string token, string origin, WithdrawTransaction withdrawTransaction)
{
var customerGuid = DecodeJwt(token).CustomerGuid;
withdrawTransaction.CustomerGuid = customerGuid;
var response = await SubmitPostAsync(URL_API_WITHDRAW_TRANSACTION, origin, withdrawTransaction, token, tenantUid);
var responseContent = AssertResponseContent <WithdrawTransactionResponseContent>(response);
return(responseContent);
}
public static void ExecuteTransaction(WithdrawTransaction transaction)
{
transaction.Execute();
transaction.Print();
}
public void ExecuteTransaction(WithdrawTransaction transaction)
{
transaction.Execute();
}
public void Withdraw_Create_NotNull()
{
WithdrawTransaction withdraw = new WithdrawTransaction(account, 100);
Assert.NotNull(withdraw);
}
private void ExecuteTransaction(WithdrawTransaction WithdrawTransaction)
{
WithdrawTransaction.Execute();
}
public void Withdraw_Type_IsWithdraw()
{
WithdrawTransaction withdraw = new WithdrawTransaction(account, 100);
Assert.Equal("Withdraw", withdraw.Type);
}
public void Withdraw_CreateWithPositiveAmount_CreatesOKWithPendingStatus()
{
WithdrawTransaction withdraw = new WithdrawTransaction(account, 100);
Assert.Equal("Pending", withdraw.Status);
}
