playfij! - Githubissues

package com.jpmorgan.spg.spray.fijimf

import akka.actor.{Actor, ActorRef, ActorSystem, Props}
import akka.event.Logging
import akka.io.IO
import akka.pattern.ask
import akka.util.Timeout
import spray.can.Http
import spray.http.HttpMethods._
import spray.http.MediaTypes._
import spray.http.{HttpRequest, HttpResponse, Uri}
import spray.routing._

import scala.concurrent.duration._
import scala.util.{Failure, Success, Try}
;

object Main {

  def main(args: Array[String]): Unit = {

    System.setProperty("http.proxyHost", "proxy.jpmchase.net")
    System.setProperty("http.proxyPort", "8080")

    implicit val system = ActorSystem("on-spray-can")
    //        val recorder = system.actorOf(Props[Recorder], "recorder-actor")
    val service = system.actorOf(Props(classOf[MainServiceActor]), "demo-service")
    implicit val timeout = Timeout(5.seconds)
    // start a new HTTP server on port 8080 with our service actor as the handler
    IO(Http) ? Http.Bind(service, interface = "localhost", port = 8080)
    val disc = system.actorOf(Props(classOf[DiscoveryActor]), "loadTeams")

    disc ! Teams

    // val discoveryActor = system.actorOf(Props(classOf[DiscoveryActor], recorder), "discovery-actor")
    //  system.scheduler.schedule(5.minutes, Duration(2, TimeUnit.MINUTES), discoveryActor, DiscoveryService("http://mcc-bond-drapp43.svr.us.jpmchase.net:1948/details?section=Core+Platform+Services%3A+Security+Server+v3j"))
  }
}

class MainServiceActor() extends Actor with HttpService {
  def actorRefFactory = context

  def receive = runRoute(rte)

  private val staticAssets: Route = pathPrefix("assets") {
    path("css" / PathMatchers.Segment) { filename =>
      get {
        respondWithMediaType(`text/css`) {
          getFromResource("css/" + filename, `text/css`)
        }
      }
    } ~ path("js" / PathMatchers.Segment) { filename =>
      get {
        respondWithMediaType(`application/javascript`) {
          getFromResource("js/" + filename, `application/javascript`)
        }
      }
    } ~ path("img" / PathMatchers.Segment) { filename =>
      get {
        respondWithMediaType(`image/png`) {
          getFromResource("img/" + filename, `image/png`)
        }
      }
    }
  }

  val rte =
    path("fijimf") {
      get {
        respondWithMediaType(`text/html`) {
          // XML is marshalled to `text/xml` by default, so we simply override here
          complete {
            <html>
              <body>
                <h1>Say hello to
                  <i>spray-routing</i>
                  on
                  <i>spray-can</i>
                  !</h1>
              </body>
            </html>
          }
        }
      }
    } ~ staticAssets
}

import org.ccil.cowan.tagsoup.jaxp.SAXFactoryImpl
import org.xml.sax.InputSource

import scala.xml._
import scala.xml.parsing.NoBindingFactoryAdapter

object HTML {
  val adapter = new NoBindingFactoryAdapter
  val parser = (new SAXFactoryImpl).newSAXParser()

  def load(source: InputSource) = adapter.loadXML(source, parser)

  def loadString(source: String) = load(Source.fromString(source))

}

class DiscoveryActor() extends Actor {
  val log = Logging(context.system, this)
  var instanceActors = Map.empty[String, ActorRef]

  val handleResponse: (Try[HttpResponse]) => Unit = {
    case Success(resp) => Try {
      HTML.loadString(resp.entity.data.asString)

    } match {
      case Success(htmlNode) =>

        val teamMap = (htmlNode \\ "td" \ "a").map(n => {
          val id = n.attribute("href").flatMap(_.headOption).map(_.text.replaceAll( """/team/index/\d+\?org_id=""", "").toInt)
          id -> n.text
        }).filter(_._1.isDefined).map(tup => tup._1.get -> tup._2)
        teamMap.foreach(n => println(n))
        val confMap = (htmlNode \\ "li" \ "a").filter(_.attribute("href").flatMap(_.headOption).exists(_.text.startsWith("javascript:changeConference"))).map(n=>{
          val id = n.attribute("href").flatMap(_.headOption).map(_.text.replace( "javascript:changeConference(","").replace(");","").toDouble.toInt)
          id -> n.text
        })
        confMap.foreach(n => println(n))

      case Failure(ex) =>
        log.warning("Failed parsing discovery service response")
        log.warning("Response was: " + resp.entity.data.toString)
    }
    case Failure(ex) => log.error("Failed to retrieve instances from Discovery Service")
  }

  override def receive: Receive = {
    case Teams =>
      implicit val timeout: Timeout = Timeout(15.seconds)
      implicit val system: ActorSystem = context.system
      import scala.concurrent.ExecutionContext.Implicits.global
      val response = (IO(Http) ? HttpRequest(GET, Uri("http://stats.ncaa.org/team/inst_team_list?academic_year=2015&conf_id=-1&division=1&sport_code=MBB"))).mapTo[HttpResponse]
      response.onComplete(handleResponse)
    case _ => log.warning("Unrecognized message")
  }

}

case object Teams
fijimf / fijbook2

playfij! #1
