Set minimal client/server app

build.sbt

@@ -12,21 +12,21 @@ val scalatagsVersion = "0.6.5"
 val autowireVersion = "0.2.6"
 val upickleVersion = "0.4.4"
 val rxVersion = "0.3.2"
-val scaladgetVersion = "0.9.4"
+val scaladgetVersion = "0.9.5"
 val scalajsDomVersion = "0.9.3"
 val jqueryVersion = "3.2.1"
 val Resolvers = Seq(Resolver.sonatypeRepo("snapshots"),
+  Resolver.sonatypeRepo("staging"),
   "Typesafe repository" at "http://repo.typesafe.com/typesafe/releases/"
 )
 
-lazy val shared = project.in(file("./shared")).settings(
+lazy val shared = project.in(file("shared")).settings(
   scalaVersion := ScalaVersion
 )
 
 lazy val client = project.in(file("client")) settings(
   version := Version,
   scalaVersion := ScalaVersion,
-  resolvers in ThisBuild ++= Resolvers,
   skip in packageJSDependencies := false,
   libraryDependencies ++= Seq(
     "com.lihaoyi" %%% "autowire" % autowireVersion,
@@ -44,7 +44,6 @@ lazy val server = project.in(file("server")) settings(
   name := Name,
   version := Version,
   scalaVersion := ScalaVersion,
-  resolvers ++= Resolvers,
   libraryDependencies ++= Seq(
     "com.lihaoyi" %% "autowire" % autowireVersion,
     "com.lihaoyi" %% "upickle" % upickleVersion,
@@ -63,33 +62,13 @@ lazy val bootstrap = project.in(file("target/bootstrap")) settings(
   version := Version,
   scalaVersion := ScalaVersion,
   go := {
-    val clientTarget = (fullOptJS in client in Compile).value
-    val clientResource = (resourceDirectory in client in Compile).value
-    val serverTarget = (target in server in Compile).value
+    val clientJS = (fullOptJS in client in Compile).value
 
-    copy(clientTarget, clientResource, new File(serverTarget, "webapp"))
-  }
-) dependsOn(client, server)
+    val serverReources = (resourceDirectory in server in Compile).value / "webapp"
+    val webappTarget = (classDirectory in server in Compile).value / "webapp"
 
-def copy(clientTarget: Attributed[File], resources: File, webappServerTarget: File) = {
-  clientTarget.map { ct =>
-    val depName = ct.getName.replace("opt.js", "jsdeps.min.js")
-    recursiveCopy(new File(resources, "webapp"), webappServerTarget)
-    recursiveCopy(ct, new File(webappServerTarget, "js/" + ct.getName))
-    recursiveCopy(new File(ct.getParent, depName), new File(webappServerTarget, "js/" + depName))
+    IO.copyDirectory(serverReources, webappTarget)
+    IO.copyFile(clientJS.data, webappTarget / "js/gate.js")
   }
-}
+) dependsOn(client, server)
 
-def recursiveCopy(from: File, to: File): Unit = {
-  if (from.isDirectory) {
-    to.mkdirs()
-    for {
-      f ← from.listFiles()
-    } recursiveCopy(f, new File(to, f.getName))
-  }
-  else if (!to.exists() || from.lastModified() > to.lastModified) {
-    println(s"Copy file $from to $to ")
-    from.getParentFile.mkdirs
-    IO.copyFile(from, to, preserveLastModified = true)
-  }
-}

client/src/main/scala/client/Gate.scala

+
+package client
+
+import org.scalajs.dom
+import scala.concurrent.Future
+import scala.scalajs.js.annotation._
+import scala.scalajs.concurrent.JSExecutionContext.Implicits.runNow
+import scaladget.api.{BootstrapTags => bs}
+import scaladget.stylesheet.all._
+import scalatags.JsDom.all._
+import shared.Api
+import autowire._
+
+
+@JSExportTopLevel(name = "client.Gate")
+@JSExportAll
+object Gate {
+
+  def run(): Unit = {
+
+    val loginDiv = div(
+      bs.input()(placeholder := "Login", color := "red"),
+      bs.input()(placeholder := "Password")
+    )
+
+    val logButton = button(btn_primary, "Run", onclick := {()=> Post[Api].login.call().foreach {l=>
+      println("Finished")
+    }})
+
+
+    dom.document.body.appendChild(
+      div(
+       // loginDiv,
+        logButton
+      ).render
+    )
+  }
+}
+
+object Post extends autowire.Client[String, upickle.default.Reader, upickle.default.Writer] {
+
+  override def doCall(req: Request): Future[String] = {
+    val url = req.path.mkString("/")
+    dom.ext.Ajax.post(
+      url = "http://localhost:8080/" + url,
+      data = upickle.default.write(req.args)
+    ).map {
+      _.responseText
+    }
+  }
+
+  def read[Result: upickle.default.Reader](p: String) = upickle.default.read[Result](p)
+
+  def write[Result: upickle.default.Writer](r: Result) = upickle.default.write(r)
+}

server/src/main/scala/ScalatraBootstrap.scala

-import openmole.gate.server._
-import org.scalatra._
-import javax.servlet.ServletContext
-
-
-class ScalatraBootstrap extends LifeCycle {
-
-  override def init(context: ServletContext) {
-
-    context.mount(new Servlet, "/*")
-  }
-}
\ No newline at end of file

server/src/main/scala/server/ApiImpl.scala

+package org.openmole.gate.server
+
+import shared._
+
+object ApiImpl extends Api {
+
+  def login: Unit = {
+    println("LOGIN")
+  }
+}

server/src/main/scala/server/Launcher.scala

+package server
+
+import javax.servlet.ServletContext
+
+import org.eclipse.jetty.server.Server
+import org.eclipse.jetty.webapp.WebAppContext
+import org.openmole.gate.server.Servlet
+import org.scalatra.LifeCycle
+import org.scalatra.servlet.ScalatraListener
+
+object Launcher extends App {
+  
+  val server = new Server(8080)
+  val context = new WebAppContext()
+
+  val webapp = getClass.getClassLoader.getResource("webapp").toExternalForm
+
+  context setContextPath "/"
+  context.setResourceBase(webapp)
+  context.setInitParameter(ScalatraListener.LifeCycleKey, classOf[GateBootstrap].getCanonicalName)
+  context.addEventListener(new ScalatraListener)
+  server.setHandler(context)
+
+  server.start
+  server.join
+
+}
+
+
+class GateBootstrap extends LifeCycle {
+  override def init(context: ServletContext) {
+    context.mount(new Servlet, "/*")
+  }
+}
\ No newline at end of file

server/src/main/scala/server/Servlet.scala

+package org.openmole.gate.server
+
+import org.scalatra._
+import scala.concurrent.duration._
+import scala.concurrent.Await
+import scalatags.Text.all._
+import scalatags.Text.{all => tags}
+import scala.concurrent.ExecutionContext.Implicits.global
+import shared._
+
+object AutowireServer extends autowire.Server[String, upickle.default.Reader, upickle.default.Writer] {
+  def read[Result: upickle.default.Reader](p: String) = upickle.default.read[Result](p)
+  def write[Result: upickle.default.Writer](r: Result) = upickle.default.write(r)
+}
+
+class Servlet extends ScalatraServlet {
+
+  val basePath = "shared"
+
+  get("/") {
+    contentType = "text/html"
+
+    tags.html(
+      tags.head(
+        tags.meta(tags.httpEquiv := "Content-Type", tags.content := "text/html; charset=UTF-8"),
+        tags.link(tags.rel := "stylesheet", tags.`type` := "text/css", href := "css/bootstrap.min.css"),
+        tags.script(tags.`type` := "text/javascript", tags.src := "js/gate.js")
+      ),
+      tags.body(
+        script("client.Gate.run();")
+      )
+    )
+  }
+
+  post(s"/$basePath/*") {
+    Await.result(AutowireServer.route[Api](ApiImpl)(
+      autowire.Core.Request(Seq(basePath) ++ multiParams("splat").head.split("/"),
+        upickle.default.read[Map[String, String]](request.body))
+    ), Duration.Inf)
+  }
+
+}

shared/Shared.scala

-package openmole.gate.shared
+package shared
 
 
 
 trait Api {
-  def uuid(): String = java.util.UUID.randomUUID.toString
+  def login(): Unit
 }
\ No newline at end of file