refactor and implemented transfer between customer accounts

src/main/scala/com/abc/Account.scala

@@ -1,44 +1,71 @@
 package com.abc
 
-import scala.collection.mutable.ListBuffer
+import com.abc.AccountTypes._
 
-object Account {
-  final val CHECKING: Int = 0
-  final val SAVINGS: Int = 1
-  final val MAXI_SAVINGS: Int = 2
-}
-
-class Account(val accountType: Int, var transactions: ListBuffer[Transaction] = ListBuffer()) {
+sealed trait Account {
+  protected val transactions = new Transactions
 
   def deposit(amount: Double) {
-    if (amount <= 0)
-      throw new IllegalArgumentException("amount must be greater than zero")
-    else
-      transactions += Transaction(amount)
+    checkPositive(amount)
+    transactions += Transaction(amount)
   }
 
   def withdraw(amount: Double) {
-    if (amount <= 0)
-      throw new IllegalArgumentException("amount must be greater than zero")
+    checkPositive(amount)
+    transactions += Transaction(-amount)
+  }
+
+  private def checkPositive(amount : Double) =
+    assert(amount > 0, "amount must be greater than zero")
+
+  def sumTransactions : Double =
+    transactions.sum
+
+  def interestEarned: Double
+
+  def getStatement: String
+}
+
+class CheckingAccount extends Account {
+  override def interestEarned: Double =
+    sumTransactions * 0.001
+
+  override def getStatement: String =
+    "Checking Account\n" + transactions.getSummary
+}
+
+class SavingsAccount extends Account {
+  override def interestEarned: Double = {
+    val amount = sumTransactions
+    if (amount <= 1000)
+      amount * 0.001
     else
-      transactions += Transaction(-amount)
+      1 + (amount - 1000) * 0.002
   }
 
-  def interestEarned: Double = {
-    val amount: Double = sumTransactions()
-    accountType match {
-      case Account.SAVINGS =>
-        if (amount <= 1000) amount * 0.001
-        else 1 + (amount - 1000) * 0.002
-      case Account.MAXI_SAVINGS =>
-        if (amount <= 1000) return amount * 0.02
-        if (amount <= 2000) return 20 + (amount - 1000) * 0.05
-        70 + (amount - 2000) * 0.1
-      case _ =>
-        amount * 0.001
-    }
+  override def getStatement: String =
+    "Savings Account\n" + transactions.getSummary
+}
+
+class MaxiSavingsAccount extends Account {
+  override def interestEarned: Double = {
+    val amount = sumTransactions
+    if (amount <= 1000)
+      amount * 0.02
+    else if (amount <= 2000)
+      20 + (amount - 1000) * 0.05
+    else
+      70 + (amount - 2000) * 0.1
   }
 
-  def sumTransactions(checkAllTransactions: Boolean = true): Double = transactions.map(_.amount).sum
+  override def getStatement: String =
+    "Maxi Savings Account\n" + transactions.getSummary
+}
 
+object Account {
+  def apply(accountType : AccountType) : Account = accountType match {
+    case Checking => new CheckingAccount
+    case Savings => new SavingsAccount
+    case MaxiSavings => new MaxiSavingsAccount
+  }
 }

src/main/scala/com/abc/AccountTypes.scala

@@ -0,0 +1,8 @@
+package com.abc
+
+object AccountTypes {
+  sealed trait AccountType
+  case object Checking extends AccountType
+  case object Savings extends AccountType
+  case object MaxiSavings extends AccountType
+}

src/main/scala/com/abc/Bank.scala

@@ -3,42 +3,24 @@ package com.abc
 import scala.collection.mutable.ListBuffer
 
 class Bank {
-  var customers = new ListBuffer[Customer]
+  private val customers = new ListBuffer[Customer]
 
-  def addCustomer(customer: Customer) {
+  def addCustomer(customer: Customer) : Unit =
     customers += customer
-  }
 
-  def customerSummary: String = {
-    var summary: String = "Customer Summary"
-    for (customer <- customers)
-      summary = summary + "\n - " + customer.name + " (" + format(customer.numberOfAccounts, "account") + ")"
-    summary
-  }
+  def customerSummary: String =
+    "Customer Summary\n" + customers.map(customerSummaryRow).mkString("\n")
 
-  private def format(number: Int, word: String): String = {
-    number + " " + (if (number == 1) word else word + "s")
-  }
-
-  def totalInterestPaid: Double = {
-    var total: Double = 0
-    for (c <- customers) total += c.totalInterestEarned
-    return total
-  }
+  private def customerSummaryRow(customer : Customer) =
+    s" - ${customer.name} (${pluralise(customer.numberOfAccounts, "account")})"
 
-  def getFirstCustomer: String = {
-    try {
-      customers = null
-      customers(0).name
-    }
-    catch {
-      case e: Exception => {
-        e.printStackTrace
-        return "Error"
-      }
-    }
+  private def pluralise(number: Int, word: String): String = number match {
+    case 1 => s"$number $word"
+    case _ => s"$number ${word}s"
   }
 
+  def totalInterestPaid: Double =
+    customers.map(_.totalInterestEarned).sum
 }
 
 

src/main/scala/com/abc/Customer.scala

@@ -1,54 +1,41 @@
 package com.abc
 
+import com.abc.AccountTypes.AccountType
+import com.abc.Formatting._
 import scala.collection.mutable.ListBuffer
 
-class Customer(val name: String, var accounts: ListBuffer[Account] = ListBuffer()) {
+class Customer(val name: String) {
 
-  def openAccount(account: Account): Customer = {
+  private val accounts: ListBuffer[Account] = ListBuffer()
+
+  def openAccount(accountType: AccountType): Account = {
+    val account = Account(accountType)
     accounts += account
-    this
+    account
   }
 
-  def numberOfAccounts: Int = accounts.size
-
-  def totalInterestEarned: Double = accounts.map(_.interestEarned).sum
+  def numberOfAccounts: Int =
+    accounts.size
 
-  /**
-   * This method gets a statement
-   */
-  def getStatement: String = {
-    //JIRA-123 Change by Joe Bloggs 29/7/1988 start
-    var statement: String = null //reset statement to null here
-    //JIRA-123 Change by Joe Bloggs 29/7/1988 end
-    val totalAcrossAllAccounts = accounts.map(_.sumTransactions()).sum
-    statement = f"Statement for $name\n" +
-      accounts.map(statementForAccount).mkString("\n", "\n\n", "\n") +
-      s"\nTotal In All Accounts ${toDollars(totalAcrossAllAccounts)}"
-    statement
-  }
+  def totalInterestEarned: Double =
+    accounts.map(_.interestEarned).sum
 
-  private def statementForAccount(a: Account): String = {
-    val accountType = a.accountType match {
-      case Account.CHECKING =>
-        "Checking Account\n"
-      case Account.SAVINGS =>
-        "Savings Account\n"
-      case Account.MAXI_SAVINGS =>
-        "Maxi Savings Account\n"
-    }
-    val transactionSummary = a.transactions.map(t => withdrawalOrDepositText(t) + " " + toDollars(t.amount.abs))
-      .mkString("  ", "\n  ", "\n")
-    val totalSummary = s"Total ${toDollars(a.transactions.map(_.amount).sum)}"
-    accountType + transactionSummary + totalSummary
+  def transfer(from: Account, to: Account, amount: Double) = {
+    if (!accounts.contains(from))
+      throw new IllegalArgumentException("Customer must own 'from' account")
+    if (!accounts.contains(to))
+      throw new IllegalArgumentException("Customer must own 'to' account")
+    from.withdraw(amount)
+    to.deposit(amount)
   }
 
-  private def withdrawalOrDepositText(t: Transaction) =
-    t.amount match {
-      case a if a < 0 => "withdrawal"
-      case a if a > 0 => "deposit"
-      case _ => "N/A"
-    }
+  def getStatement: String = {
+    val totalAcrossAllAccounts = accounts.map(_.sumTransactions).sum
 
-  private def toDollars(number: Double): String = f"$$$number%.2f"
+    s"""Statement for $name
+       |${accounts.map(_.getStatement).mkString("\n", "\n\n", "\n")}
+       |Total In All Accounts ${toDollars(totalAcrossAllAccounts)}""".stripMargin
+  }
 }
 
+

src/main/scala/com/abc/Formatting.scala

@@ -0,0 +1,6 @@
+package com.abc
+
+object Formatting {
+  def toDollars(number: Double): String =
+    f"$$$number%.2f"
+}

src/main/scala/com/abc/Transaction.scala

@@ -1,6 +1,15 @@
 package com.abc
 
-case class Transaction(var amount: Double) {
-  val transactionDate = DateProvider.getInstance.now
+import com.abc.Formatting._
+
+case class Transaction(amount: Double) {
+  def getSummary : String =
+    s"$withdrawalOrDepositText ${toDollars(amount.abs)}"
+
+  private def withdrawalOrDepositText = amount match {
+    case a if a < 0 => "withdrawal"
+    case a if a > 0 => "deposit"
+    case _ => "N/A"
+  }
 }
 

src/main/scala/com/abc/Transactions.scala

@@ -0,0 +1,22 @@
+package com.abc
+
+import com.abc.Formatting._
+
+import scala.collection.mutable.ListBuffer
+
+class Transactions {
+  private val transactions: ListBuffer[Transaction] = ListBuffer()
+
+  def +=(transaction: Transaction) =
+    transactions += transaction
+
+  def sum: Double =
+    transactions.map(_.amount).sum
+
+  def getSummary: String = {
+    val transactionSummary = transactions.map(_.getSummary)
+      .mkString("  ", "\n  ", "\n")
+    val totalSummary = s"Total ${toDollars(transactions.map(_.amount).sum)}"
+    transactionSummary + totalSummary
+  }
+}