public void Deposit(double amount)
{
Transac = new Transaction();
Balance += amount;
Transac.MakeTransaction(true, amount, Balance);
TransactionHistory.Add(Transac);
}
async Task ExecuteLoadTransactionHistoryCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
TransactionHistory.Clear();
var transactions = await UserController.GetTransactionHistory();
foreach (var trans in transactions)
{
TransactionHistory.Add(trans);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public override void TransferIn(Transaction transaction)
{
Balance = Balance + transaction.Amount;
TransactionHistory.Add(transaction);
if (Balance >= 2000)
{
Owner.Status = CustomerStatus.PREMIER;
}
}
private async Task AddTransaction(double amount, string description)
{
var transaction = new Transaction(Id, amount, description);
TransactionHistory.Add(transaction);
_repository.Create(transaction);
await _repository.SaveAsync();
}
public bool TopUp(string name, string initiator, DateTime dateTime, double amount)
{
if (amount > 0)
{
count += amount;
TransactionHistory.Add(new Transaction(name, initiator, dateTime, amount, TransactionType.TopUp));
return(true);
}
else
{
return(false);
}
}
public bool Withdraw(string name, string initiator, DateTime dateTime, double amount)
{
if (amount <= count & amount > 0)
{
count -= amount;
TransactionHistory.Add(new Transaction(name, initiator, dateTime, amount, TransactionType.Withdraw));
return(true);
}
else
{
return(false);
}
}
//Takes withdrawal amount from user, updates balance, and then updates
//transaction history
private void Withdraw(double amountToTake)
{
//Can only withdraw if balance > 0
if (Balance >= amountToTake)
{
Balance -= amountToTake;
TransactionHistory.Add("Withdraw " + amountToTake);
}
else
{
Console.WriteLine("Balance Too Low");
}
}
public float MakeDeposit(float amount, string madeBy)
{
AccountTransaction t = new AccountTransaction();
t.Amount = amount;
t.TransactionDate = DateTime.Now;
t.transactionType = TransactionType.Deposit;
t.NewAccountBalance = CurrentBalance + amount;
CurrentBalance = t.NewAccountBalance;
TransactionHistory.Add(t);
return(CurrentBalance);
}
// overrride withdraw method to apply withdraw penalty
public override TransactionResult Withdraw(Transaction tran)
{
base.Withdraw(tran);
if (Owner.Status == CustomerStatus.REGULAR && Balance < PremierAmount)
{
// Apply withdraw penalty for regular customers
Balance -= WithdrawPenaltyAmount;
// create a new transaction for penalty
Transaction tranPenalty = new Transaction(WithdrawPenaltyAmount, TransactionType.PENALTY);
TransactionHistory.Add(tranPenalty); // add transaction penalty to history separately
}
return(TransactionResult.SUCCESS);
}
public override TransactionResult Deposit(Transaction amount)
{
Balance = Balance + amount.Amount;
TransactionHistory.Add(amount);
if (Balance >= PremiereAmount)
{
Owner.Status = CustomerStatus.PREMIER;
return(TransactionResult.SUCCESS);
}
else
{
Owner.Status = CustomerStatus.REGULAR;
return(TransactionResult.SUCCESS);
}
}
public override TransactionResult TransferOut(Transaction transaction)
{
if (transaction.Amount <= Balance)
{
Balance = Balance - transaction.Amount;
TransactionHistory.Add(transaction);
if (Balance < 2000)
{
Owner.Status = CustomerStatus.REGULAR;
}
return(TransactionResult.SUCCESS);
}
else
{
return(TransactionResult.INSUFFICIENT_FUND);
}
}
public float MakeWithdrawal(float amount, string madeBy)
{
AccountTransaction t = new AccountTransaction();
if (amount > CurrentBalance)
{
throw new Exception("This exceeds the current account balance of " + CurrentBalance.ToString("C") + ". The transaction has been cancelled.");
}
t.Amount = amount;
t.TransactionDate = DateTime.Now;
t.transactionType = TransactionType.Withdrawal;
t.NewAccountBalance = CurrentBalance - amount;
CurrentBalance = t.NewAccountBalance;
TransactionHistory.Add(t);
return(CurrentBalance);
}
public void Withdraw(double amount)
{
double transAmount = Balance - amount;
if (amount == 0)
{
throw new ArgumentOutOfRangeException("Amount to Wuthdraw", "Nothing to withdraw.");
}
else if (transAmount >= 0)
{
Transac = new Transaction();
Balance = transAmount;
Transac.MakeTransaction(false, amount, Balance);
TransactionHistory.Add(Transac);
}
else if (amount > Balance)
{
throw new ArgumentOutOfRangeException("Balance", "Amount to withdraw is greater than your remaing balance.");
}
}
} //inherit Account constructor instead of writing it over again,
//using the same customer (customer) parameter from base class
public override TransactionResult Withdraw(Transaction transaction)
{
if (transaction.Amount >= Balance)
{
return(TransactionResult.INSUFFICIENT_FUND);
}
else
{
if (Owner.Status == CustomerStatus.REGULAR && transaction.Amount > MaxWithdrawAmount)
{
return(TransactionResult.EXCEED_MAX_WITHDRAW_AMOUNT);
}
else
{
Balance = Balance - transaction.Amount;
TransactionHistory.Add(transaction);
return(TransactionResult.SUCCESS);
}
}
}
public override TransactionResult Withdraw(Transaction amount)
{
if (amount.Amount < Balance)
{
if (Balance < PremiereAmount)
{
Balance = Balance - WithdrawPenaltyAmount;
TransactionHistory.Add(new Transaction(WithdrawPenaltyAmount, TransactionType.PENALTY));
return(base.Withdraw(amount));
}
else
{
return(base.Withdraw(amount));
}
}
else
{
return(TransactionResult.INSUFFICIENT_FUND);
}
}
} //inherit Account constructor instead of writing it over again,
//using the same customer (customer) parameter from base class
public override TransactionResult Withdraw(Transaction transaction)
{
if (transaction.Amount >= Balance)
{
return(TransactionResult.INSUFFICIENT_FUND);
}
else
{
Balance = Balance - transaction.Amount;
TransactionHistory.Add(transaction);
if (Owner.Status == CustomerStatus.REGULAR)
{
Balance = Balance - WithdrawPenaltyAmount;
Transaction PENALTY = new Transaction(WithdrawPenaltyAmount, TransactionType.PENALTY);
TransactionHistory.Add(PENALTY);
}
if (Balance < 2000)
{
Owner.Status = CustomerStatus.REGULAR;
}
return(TransactionResult.SUCCESS);
}
}
public override TransactionResult Deposit(Transaction amount)
{
Balance = Balance + amount.Amount;
TransactionHistory.Add(amount);
return(TransactionResult.SUCCESS);
}
//Takes deposit amount from user, updates balance, and then updates
//transaction history
private void Deposit(double amountToAdd)
{
Balance += amountToAdd;
TransactionHistory.Add("Deposit " + amountToAdd);
}
