bitcoin-atm

Data.scala

(5745B)

 package inc.pyc.chimera
 
 import Implicits._
 import lycia._
 import inc.pyc._
 import currency._
 import bitcoin._
 import System._
 import org.joda.time._
 import format._
 
 /**
  * Data that can be transfered across 
  * state transitions.
  */
 trait Data
 
 /**
  * Null.
  */
 case object NullData extends Data
 
 /**
  * A valid bitcoin address.
  * 
  * @param data bitcoin address
  */
 case class BitcoinAddress(data: String) extends Data
 
 /**
  * Data to check for history audit.
  * 
  * @param address bitcoin address
  * @param userInfo registered user information
  */
 case class AuditData(
     address: BitcoinAddress, 
     userInfo: UserInfo = UserInfo()) extends Data {
   
   def withPhoneNumber(phone: Phone) = {
     copy(userInfo = userInfo.withPhoneNumber(phone))
   }
   
   def addresses: List[String] = 
     address.data :: userInfo
     	.addresses.filterNot(_ == address.data)
 }
 
 /**
  * Carries enough data to create a local (incomplete) 
  * transaction at the current price.
  * 
  * @param audit audit data
  * @param limit amount the user can spend
  * @param price buy price
  */
 case class CreatorTx(
     audit: AuditData, 
     limit: LeftToSpend, 
     price: Price) extends Data
 
 /**
  * An incomplete transaction.
  * 
  * @param address user's bitcoin address
  * @param price price per bitcoin at the time of transaction
  * @param currency currency of the bills used
  * @param currencySymbol symbol of currency
  * @param bills sequence of bills inserted into the machine
  * @param limit buy limit for this transaction
  * @param userInfo information about registered user
  * @param total sum of the bills inserted
  * @param bitcoins calculated total of bitcoins that will be sold
  * @param buyPrice agreed final price per bitcoin with fee included
  */
 case class IncompleteTx(
     address: String, 
     price: Price,
     currency: Currency,
     currencySymbol: String,
     bills: List[Int],
     limit: Int,
     userInfo: UserInfo,
     total: Int,
     bitcoins: Double,
     buyPrice: Double) extends Data {
   
   /** Last time the transaction was updated. */
   val date = new DateTime
   
   def prettyTotal = currency.symbol + total
   
   def prettyDate = {
     val fmt = DateTimeFormat forPattern "MMMM dd, yyyy"
     fmt print date
   }
   
   def prettyTime = {
     val fmt = DateTimeFormat forPattern "hh:mm a z"
     fmt print date
   }
   
   /**
    * Adds a bill and returns an updated IncompleteTx
    * @param bill bill to add
    */
   def insertBill(bill: Currency#Value): IncompleteTx = {
     val bills = this.bills :+ bill.id
     copy(
         bills = bills, 
         total = bills.sum, 
         bitcoins = (bills.sum / price.priceWithPercentage) roundBitcoin)
   } 
   
   /**
    * Increases the purchase limit.
    * ie. If purchase limit is $1,000 and it needs to be set to $3,000,
    * but $50 is the spending limit in the current transaction, then purchase
    * limit is set to $3,000 and spending limit is set to $2,050.
    */
   def setLimit(newLimit: Int): IncompleteTx = {
     val oldPurchaseLimit = userInfo.purchaseLimit getOrElse Lycia.buyLimit
     copy(
         limit = newLimit - oldPurchaseLimit + limit, 
         userInfo = userInfo.copy(purchaseLimit = Some(newLimit)))
   }
   
   /**
    * Updates the user info and modifies the purchase 
    * limit and spending limit accordingly.
    */
   def withUserInfo(info: UserInfo): IncompleteTx = {
     val newUserLimit = info.purchaseLimit getOrElse Lycia.buyLimit
     val newTx = setLimit(newUserLimit)
     newTx.copy(userInfo = info)
   }
   
   def withPhoneNumber(phone: Phone): IncompleteTx = {    
     copy(userInfo = userInfo.withPhoneNumber(phone))
   }
 }
 
 case object IncompleteTx {
   def apply(
     address: String, 
     price: Price,
     currency: Currency, 
     bills: List[Int],
     limit: Int,
     userInfo: UserInfo): IncompleteTx = IncompleteTx(
         address,
         price,
         currency,
         currency.symbol,
         bills,
         limit,
         userInfo,
         bills.sum,
         (bills.sum / price.priceWithPercentage) roundBitcoin,
         price.priceWithPercentage)
 }
 
 /**
  * A completed transaction.
  * 
  * @param address buyer's bitcoin address
  * @param date date transaction was completed
  * @param txid blockchain transaction ID
  * @param price price per bitcoin at the time of transaction
  * @param currency currency of the bills used
  * @param bills sequence of bills inserted into the machine
  * @param chimera machine name of where transaction occurred
  * @param ticker bitcoin price ticker service
  */
 case class CompleteTx(
     address: String,
     date: DateTime,
     txid: String, 
     price: Price,
     total: Int,
     bitcoins: Double,
     currency: Currency,
     currencySymbol: String,
     bills: List[Int],
     chimera: String,
     ticker: BitcoinService.Value,
     prettyDate: String,
     prettyTime: String) extends Data {
   
   def dateISO8601 = {
     val fmt = ISODateTimeFormat.basicDateTime
     fmt print date
   }
   
   def prettyTotal = currencySymbol + total
 }
 
 object CompleteTx {
   def apply(tx: IncompleteTx, txid: String): CompleteTx = {
     val date = new DateTime
     
     CompleteTx(
         tx.address, 
         date, 
         txid, 
         tx.price,
         tx.total,
         tx.bitcoins,
         tx.currency,
         tx.currencySymbol,
         tx.bills, 
         Settings(system).name, 
         Lycia.servicePriceTicker,
         prettyDate(date),
         prettyTime(date))
   }
         
   def prettyDate(date: DateTime) = {
     val fmt = DateTimeFormat forPattern "MMMM dd, yyyy"
     fmt print date
   }
   
   def prettyTime(date: DateTime) = {
     val fmt = DateTimeFormat forPattern "hh:mm a z"
     fmt print date
   }
 }
 
 /**
  * Reason why it is in the current state.
  * @param reason reason
  */
 case class Reason(data: String) extends Data