Adding some code.

Author: otobrglez

.gitignore

@@ -0,0 +1,33 @@
+# Some project specifics
+.env
+spark-warehouse/
+metastore_db/
+experimental/
+NOTES.md
+s3.*
+per_*/
+*.jar
+*.zip
+data/
+creds.*
+dump/
+hack/
+
+*.class
+*.log
+
+dist/*
+target/
+lib_managed/
+src_managed/
+project/boot/
+project/plugins/project/
+
+.history
+.cache
+.lib
+
+.scala_dependencies
+.worksheet
+
+!lib/*.jar

README.md

@@ -0,0 +1,28 @@
+# bencinmonitor / d2
+
+High-performance API for [bencinmonitor.si].
+
+## Docker
+
+> TODO: Add instructions here.
+
+
+## REST Endpoints
+
+### GET /stations
+
+Returns list of stations and prices.
+
+Supported `GET` parameters
+
+- `near`[`String`] - Address or location "name". `near` is geo-coded into coordinates then are then used as starting point.
+- `at`[`Double,Double`] - Coordinates ther are used for starting point.
+- `maxDistance`[`Int`] - Maximal distance in meters around `near` or `at`. Default is `10000` meters.
+- `limit`[`Int`] - Maximum number of records that API returns. Default is `10`.
+
+
+# Author
+
+- [Oto Brglez](https://github.com/otobrglez)
+
+[bencinmonitor.si]: http://bencinmonitor.si

activator.properties

@@ -0,0 +1 @@
+name=d2

app/controllers/StationController.scala

@@ -0,0 +1,95 @@
+package controllers
+
+import javax.inject._
+
+import models.Location
+import play.api._
+import play.api.mvc._
+import play.api.libs.json._
+import play.api.libs.json.Reads._
+// import play.api.libs.functional.syntax._
+import play.api.libs.ws._
+
+import scala.concurrent.{ExecutionContext, Future}
+import scala.concurrent.duration._
+import play.modules.reactivemongo._
+import reactivemongo.play.json.collection._
+import akka.actor.ActorSystem
+import akka.stream.ActorMaterializer
+import akka.stream.scaladsl._
+import akka.util.ByteString
+import reactivemongo.play.json._
+import reactivemongo.bson._
+import reactivemongo.bson.{BSONDocument, BSONDocumentReader}
+import reactivemongo.api.collections.bson.BSONCollection
+
+import models.Station
+import models.Station._
+
+@Singleton
+class StationController @Inject()(val reactiveMongoApi: ReactiveMongoApi, val ws: WSClient)(implicit exec: ExecutionContext) extends Controller with MongoController with ReactiveMongoComponents {
+  lazy val stations = database.map(_.collection("stations"))
+
+  def geocode(rawAddress: Option[String] = None, timeout: FiniteDuration = 2.seconds): Future[Seq[Double]] = {
+    if (rawAddress.isEmpty) return Future(Seq.empty[Double])
+
+    val wsRequest = ws.url(s"http://maps.googleapis.com/maps/api/geocode/json")
+      .withHeaders(ACCEPT -> "applicaton/json")
+      .withQueryString("sensor" -> "false")
+      .withQueryString("address" -> rawAddress.get)
+      .withRequestTimeout(timeout)
+
+    wsRequest.get().map { wsResponse =>
+      (wsResponse.json \ "status").as[String] match {
+        case "OK" =>
+          val location = (wsResponse.json \ "results") (0) \ "geometry" \ "location"
+          Seq[Double]((location \ "lng").as[Double], (location \ "lat").as[Double])
+        case _ => Seq.empty[Double]
+      }
+    }
+  }
+
+  def geocode_it(address: String) = Action.async {
+    for {location <- geocode(Some(address))} yield Ok(Json.toJson(BSONDocument("coordinates" -> location)))
+  }
+
+  def listStations(at: Seq[Double] = Seq.empty[Double], limit: Int, maxDistance: Int): Future[List[Station]] = {
+    stations.flatMap {
+      var query = BSONDocument("company" -> "petrol")
+
+      if (at.nonEmpty) {
+        query = query.add(BSONDocument("loc" -> BSONDocument("$near" -> BSONDocument(
+          "$geometry" -> BSONDocument("$type" -> "Point", "coordinates" -> at),
+          "$maxDistance" -> maxDistance)
+        )))
+      }
+
+      var projection = BSONDocument("key" -> 1, "address" -> 1, "loc" -> 1, "updated_at" -> 1, "scraped_url" -> 1)
+
+      projection = projection.add("prices" -> "1")
+
+      _.find(query, projection).cursor[Station]().collect[List](limit)
+    }
+  }
+
+  def index(near: Option[String] = None, at: Option[String], limit: Int, maxDistance: Int) = Action.async {
+    val now = System.nanoTime
+    val atLocation = at.fold(Seq.empty[Double])(_.split(",").map(_.toDouble))
+
+    val composition: Future[List[Station]] = if (near.isEmpty && atLocation.nonEmpty) {
+      listStations(atLocation, limit, maxDistance)
+    } else if (near.nonEmpty) {
+      geocode(near).flatMap(listStations(_, limit, maxDistance))
+    } else {
+      listStations(limit = limit, maxDistance = maxDistance)
+    }
+
+    composition.map { stations =>
+      Ok(Json.toJson(BSONDocument(
+        "stations" -> stations,
+        "status" -> "ok",
+        "executed_in" -> ((System.nanoTime - now).asInstanceOf[Double] / 1000000000)
+      )))
+    }
+  }
+}

app/extra/ExtraBSONHandlers.scala

@@ -0,0 +1,24 @@
+package extra
+
+import reactivemongo.bson._
+
+object ExtraBSONHandlers extends ExtraBSONHandlers
+
+trait ExtraBSONHandlers {
+  implicit def MapBSONReader[T](implicit reader: BSONReader[_ <: BSONValue, T]): BSONDocumentReader[Map[String, T]] =
+    new BSONDocumentReader[Map[String, T]] {
+      def read(doc: BSONDocument): Map[String, T] = {
+        doc.elements.collect {
+          case (key, value) => value.seeAsOpt[T](reader) map {
+            ov => (key, ov)
+          }
+        }.flatten.toMap
+      }
+    }
+
+  implicit def MapBSONWriter[T](implicit writer: BSONWriter[T, _ <: BSONValue]): BSONDocumentWriter[Map[String, T]] = new BSONDocumentWriter[Map[String, T]] {
+    def write(doc: Map[String, T]): BSONDocument = {
+      BSONDocument(doc.toTraversable map (t => (t._1.replace("-", "_"), writer.write(t._2))))
+    }
+  }
+}

app/models/Location.scala

@@ -0,0 +1,22 @@
+package models
+
+import play.api.libs.json.{Reads, __}
+import play.api.libs.functional.syntax._
+
+case class Location(locationType: String, coordinates: Seq[Double])
+
+object Location {
+
+  import reactivemongo.bson._
+
+  implicit val locationReads: Reads[Location] = (
+    (__ \ "type").read[String] and (__ \ "coordinates").read[Seq[Double]]
+    ) (Location.apply _)
+
+  implicit object LocationWriter extends BSONDocumentWriter[Location] {
+    def write(location: Location): BSONDocument = BSONDocument(
+      "type" -> location.locationType,
+      "coordinates" -> location.coordinates
+    )
+  }
+}

app/models/Station.scala

@@ -0,0 +1,37 @@
+package models
+
+import play.api.libs.json._
+import play.api.libs.json.Reads._
+import play.api.libs.functional.syntax._
+
+case class Station(key: String, address: String, location: Location, prices: Map[String, Double])
+
+object Station {
+
+  import reactivemongo.bson._
+  import extra.ExtraBSONHandlers._
+
+  implicit val locationWrites = Location.LocationWriter
+
+  implicit val stationReads: Reads[Station] = (
+    (__ \ "key").read[String] and
+      (__ \ "address").read[String] and
+      (__ \ "loc").read[Location] and
+      (__ \ "prices").read[Map[String, Double]]
+    ) (Station.apply _)
+
+  implicit object StationWriter extends BSONDocumentWriter[Station] {
+    def write(station: Station): BSONDocument = {
+      BSONDocument(
+        "key" -> station.key,
+        "address" -> station.address,
+        "loc" -> station.location,
+        "prices" -> station.prices.map(pair => BSONDocument(
+          "type" -> pair._1.replace("-", "_"), "price" -> pair._2)
+        )
+      )
+    }
+  }
+
+}
+

app/utils/Errors.scala

@@ -0,0 +1,17 @@
+package utils
+
+import play.api.data.validation.ValidationError
+import play.api.libs.json.JsPath
+
+object Errors {
+
+  /**
+    * Small utility to show the errors as a string
+    */
+  def show(errors: Seq[(JsPath, Seq[ValidationError])]): String = {
+    errors.map {
+      case (path, e) => path.toString() + " : " + e.map(_.toString).mkString(" ")
+    }.mkString("\n")
+  }
+
+}

build.sbt

@@ -0,0 +1,26 @@
+name := """d2"""
+
+version := "1.0-SNAPSHOT"
+
+lazy val root = (project in file(".")).enablePlugins(PlayScala)
+
+scalaVersion := "2.11.8"
+
+// routesGenerator := InjectedRoutesGenerator
+
+libraryDependencies ++= Seq(
+  ws,
+  "org.reactivemongo" %% "play2-reactivemongo" % "0.11.14"
+)
+
+resolvers += "scalaz-bintray" at "http://dl.bintray.com/scalaz/releases"
+resolvers += "Sonatype Snapshots" at "https://oss.sonatype.org/content/repositories/snapshots/"
+
+scalacOptions in ThisBuild ++= Seq(
+  "-feature",
+  "-language:postfixOps",
+  "-Xfuture",
+  "-language:_",
+  "-deprecation",
+  "-unchecked"
+)

conf/application.conf

@@ -0,0 +1,10 @@
+mongodb.uri = "mongodb://0.0.0.0:27017/bm"
+
+play.modules.enabled += "play.modules.reactivemongo.ReactiveMongoModule"
+
+mongo-async-driver {
+  akka {
+    loglevel = WARNING
+  }
+}
+

conf/routes

@@ -0,0 +1,2 @@
+GET      /stations                  controllers.StationController.index(near: Option[String], at: Option[String], limit: Int ?= 10, maxDistance: Int ?= 10000)
+GET      /geocode                   controllers.StationController.geocode_it(address: String)

etc/mongod.conf

@@ -0,0 +1,9 @@
+# Store data in /usr/local/var/mongodb instead of the default /data/db
+dbpath = tmp/mongodb
+
+# Append logs to /usr/local/var/log/mongodb/mongo.log
+# logpath = tmp/mongo.log
+# logappend = true
+
+# Only accept local connections
+bind_ip = 127.0.0.1

project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.11

project/plugins.sbt

@@ -0,0 +1,3 @@
+// The Play plugin
+addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.5.1")
+