pyc-website

AtmSnip.scala

(4319B)

 package inc.pyc
 package snippet
 
 import lib._
 import config._
 import model._
 import field._
 import xml._
 import net.liftweb._
 import common._
 import json._
 import JsonDSL._
 import util._
 import Helpers._
 import http._
 import js._
 import JsCmds._
 import SHtml._
 import JE.JsVar
 import net.liftmodules.mongoauth.MongoAuth
 import dispatch._, Defaults._
 import net.liftmodules.extras.SnippetHelper
 
 
 class AtmApplication extends AngularSnippet {
   
   def roundTrips: List[RoundTripInfo] = List("submit" -> submit _)
     
   def submit(model: JValue): JValue = {
     val rec = AtmApplication.createRecord
     rec.setFieldsFromJValue(model)
     
     rec.validate match {
       case Nil =>
         rec.save(false)
         notifyByEmail(rec)
         
         NgAlert.success(Text(S ? "atm_app_received" format rec.name.get))
       case errors =>
         NgAlert.danger(Text(S ? "Invalid_submission"), errors)
     }
   }
   
   /** 
    *  Notify us of the new applicant by email, 
    *  so we can begin reviewing immediately.
    */
   def notifyByEmail(rec: model.AtmApplication): Unit = {
     import Mailer._
     val msgTxt =
       s"""
         Business Asking for a Bitcoin ATM!
         Name: ${rec.name.get}
         Website: ${rec.website.get}
         Address: 
         ${rec.address.get}
         ${rec.city.get}, ${rec.state.get}
         Email: ${rec.email.get}
         Phone: ${rec.phone.get}
         Best Time: ${rec.bestTime.get}
       """
         
     sendMail(
       From(MongoAuth.systemFancyEmail),
       Subject("PYC: Business wants a Bitcoin ATM"),
       To(Emails.atmBusiness),
       PlainMailBodyType(msgTxt)
     )
   }
 }
 
 
 class FindAtm extends AngularSnippet with Logger {
   
   var location: Option[SearchedLocation] = None
   
   def roundTrips: List[RoundTripInfo] = List(
       "submit" -> submit _, 
       "notifyEmail" -> notifyEmail _,
       "init" -> init _)
   
   /** Distance to check for nearby ATMs */
   val distance = 100 // kilometers (~62 miles)
   
   def submit(model: JValue): JValue =
     for {
       JString(address) <- model \ "address"
     } yield 
       Geocode.geolocation(address)() match {
         case Right(geo) => 
           
           location = Some(SearchedLocation.findByName(address) openOr {
             SearchedLocation.createRecord
           }) map {
             _.name(address).loc(geo).save()
           }
           
           val atms = Atm.nearby(geo, distance)
           
           if(atms.isEmpty) 
             NgAlert.danger(("loc" -> 
             	("latitude" -> geo.lat) ~ 
             	("longitude" -> geo.lng)
             ))
           else
             NgAlert.success(JArray(atms.zipWithIndex map {
               case (rec, i) =>
                 rec.asJValue merge
                 	("id" -> (i+1)) ~
                 	("showWindow" -> (i==0))
             }))
 
         case Left(err) =>
           
           //TODO notify me
           NgAlert.danger
       }
     
   def notifyEmail(model: JValue): JValue =
     for (JString(e) <- model \ "email") 
       yield location map {
         loc => 
           val email = e.toLowerCase.trim
     	  loc.emails.add(email).update
 
     	  NgAlert.success(Text(S ? "atm_notify"))
       } getOrElse JNull
 
     
   /* Set featured ATM on map */
   def init(o: JValue): JValue = {
     
     //* Don't show any windows by default (for now)
     FeaturedAtm.atm.asJValue merge 
     ("id" -> 1) ~ 
     ("showWindow" -> false)
     //*/
 
     
     
     val all = Atm.findAll
     val featured = all.filter(_.name.get == FeaturedAtm.name)
     val rest = all.filterNot(_.name.get == FeaturedAtm.name)
     val combined = featured ++ rest
     
     val atms = combined.zipWithIndex map {
       case (rec, i) =>
         val featured = rec.name.get == FeaturedAtm.name
 
         rec.asJValue merge
           ("id" -> (i + 1)) ~
           ("showWindow" -> featured)
     }
     
     JArray(atms)
   }
 }
 
 
 
 sealed trait AtmSnip extends SnippetHelper with Logger {
   protected def atm: Box[Atm]
   
   protected def serve(snip: Atm => JValue): JValue = 
     for (atm <- atm ?~ "Bitcoin ATM not found") yield snip(atm)
 }
 
 class AtmProfile extends AtmSnip with AngularSnippet {
   
   override def atm = Site.atmProfileLoc.currentValue
   
   def roundTrips: List[RoundTripInfo] = List("init" -> init _)
   
   def init(o: JValue): JValue = serve {
     atm => atm.asJValue
   }
 }