Scala Ajax类代码示例

//设置package包名称以及导入依赖的类
import scala.scalajs.js
import scala.scalajs.js.Dynamic.global
import org.scalajs.dom
import scalatags.JsDom.all._
import shared.SharedMessages
import org.scalajs.dom.ext.Ajax
import scala.concurrent.ExecutionContext

object Hellp extends js.JSApp {

  def main(): Unit = {
    if (!js.isUndefined(global.window.console)) {
      global.console.log("Welcome to your Play application's JavaScript!");
    }
    addItems
  }

  def addItems = {
    import scala.concurrent.ExecutionContext.Implicits.global
    dom.document
      .getElementById("scalajsclientDiv")
      .appendChild(ul(id := "itemList")(li("ScalaJS shouts out: ", em(SharedMessages.itWorks))).render)

    timeAt("UTC")
    timeAt("ECT")

  }

  def timeAt(tz: String)(implicit ec: ExecutionContext) = {
    Ajax.get("/api/timeAt/" + tz).onSuccess {
      case xhr =>
        dom.document
          .getElementById("itemList").appendChild(li(s"Time service (timeAt $tz): ", em(xhr.responseText)).render)
    }
  }

} 

//设置package包名称以及导入依赖的类
package common

import upickle._

import org.scalajs.dom.XMLHttpRequest
import org.scalajs.dom.ext.Ajax
import shared._

class ExtAjax(ajax: Ajax.type) {

  def postAsForm(url: String,
           data: String = "",
           timeout: Int = 0,
           headers: Map[String, String] = Map.empty,
           withCredentials: Boolean = false) = {
    val contentType = ("Content-Type" -> "application/x-www-form-urlencoded")
    apply("POST", url, data, timeout, headers + contentType, withCredentials)
  }

  def postAsJson(url: String,
                 data: String = "",
                 timeout: Int = 0,
                 headers: Map[String, String] = Map.empty,
                 withCredentials: Boolean = false) = {
    val contentType = ("Content-Type" -> "application/json")
    apply("POST", url, data, timeout, headers + contentType, withCredentials)
  }

  def apply(method: String,
            url: String,
            data: String = "",
            timeout: Int = 0,
            headers: Map[String, String] = Map.empty,
            withCredentials: Boolean = false) = {
    val ajaxReq = ("X-Requested-With" -> "XMLHttpRequest")
    ajax.apply(method, url, data, timeout, headers + ajaxReq, withCredentials, "")
  }

}

class ExtXMLHttpRequest(req: XMLHttpRequest) {

//  def responseAs[T](implicit readWrite: ReadWriter[T]): T = read[T](req.responseText)

  def ok = req.status == 200

}

object ExtAjax {

  implicit def wrapperForAjax(ajax: Ajax.type) = new ExtAjax(ajax)

  implicit def wrapperForXMLHttpRequest(req: XMLHttpRequest) = new ExtXMLHttpRequest(req)

} 

//设置package包名称以及导入依赖的类
package client.services

import shared.dto.pickler.PicklerState._
import client.services.components.BooResourceComponent
import org.scalajs.dom.ext.Ajax
import org.scalajs.dom.ext.Ajax.InputData

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.scalajs.js.typedarray.{ArrayBuffer, TypedArrayBuffer}

trait AjaxBooResourceWired extends BooResourceComponent {

  override lazy val booResource: BooResource = new AjaxService

  class AjaxService extends BooResource {
    def get[A](url: String)(implicit u: Pickler[A]): Future[A] = {
      Ajax
        .get(url, responseType = "arraybuffer")
        .map { r =>
          val arrayBuffer = r.response.asInstanceOf[ArrayBuffer]
          val typedBuffer = TypedArrayBuffer.wrap(arrayBuffer)
          Unpickle[A].fromBytes(typedBuffer)
        }
    }

    def post[A, B](url: String, request: A)(implicit a: Pickler[A], b: Pickler[B]): Future[B] = {
      Ajax
        .post(
          url,
          responseType = "arraybuffer",
          headers = Map("Content-Type" -> "application/octet-stream"),
          data = InputData.byteBuffer2ajax(Pickle.intoBytes(request))
        )
        .map { r =>
          val arrayBuffer = r.response.asInstanceOf[ArrayBuffer]
          val typedBuffer = TypedArrayBuffer.wrap(arrayBuffer)
          Unpickle[B].fromBytes(typedBuffer)
        }
    }
  }
} 

//设置package包名称以及导入依赖的类
package uk.co.turingatemyhamster.shoppinglist.webClient.services

import org.scalajs.dom.ext.Ajax
import upickle.default._

import scala.concurrent.{ExecutionContext, Future}

trait AjaxClient {
  def post[Request : Writer, Response : Reader](path: String, req: Request): Future[Response]
  def get[Response : Reader](path: String): Future[Response]
}

object AjaxClient {
  def atBaseUrl(baseUrl: String)(implicit executionContext: ExecutionContext): AjaxClient = new AjaxClient {
    override def post[Request : Writer, Response : Reader](path: String, req: Request): Future[Response] =
      Ajax.post(
        url = baseUrl + path,
        data = write(req),
        headers = Map(
          "Content-type" -> "application/json"
        ),
        responseType = "json"
      ).map { res =>
        readJs[Response](upickle.json.readJs(res.response))
      }

    override def get[Response : Reader](path: String): Future[Response] =
      Ajax.get(
        url = baseUrl + path,
        headers = Map(
          "Content-type" -> "application/json"
        ),
        responseType = "json"
      ).map { res =>
        readJs[Response](upickle.json.readJs(res.response))
      }
  }
} 

//设置package包名称以及导入依赖的类
package scalajsreact.template.models
import org.scalajs.dom.ext.Ajax
import org.scalajs.dom.ext.Ajax.InputData
import scala.scalajs.js

case class TodoItem(id: Int, title: String, completed: Boolean)

object TodoItem {
  def fromJson(jsonArray: js.Array[js.Dynamic]): List[TodoItem] = {
    jsonArray.map(jsonObject =>
      TodoItem(jsonObject.id.toString.toInt, jsonObject.title.toString, jsonObject.completed.toString.toBoolean)
    ).toList
  }

  def get(
    url: String = "http://jsonplaceholder.typicode.com",
    data: Option[InputData] = None,
    timeout: Int = 0,
    headers: Map[String, String] = Map(
      "Accept" -> "application/json",
      "Content-Type" -> "application/json"
    ),
    withCredentials: Boolean = false,
    responseType: Option[String] = Some("")
  ) = Ajax.get(url + "/todos", data.orNull, timeout, headers, withCredentials, responseType.getOrElse(""))
} 

//设置package包名称以及导入依赖的类
package se.lu.nateko.cp.doi.gui

import scala.concurrent.Future
import org.scalajs.dom.ext.Ajax
import scalajs.concurrent.JSExecutionContext.Implicits.queue
import se.lu.nateko.cp.doi.Pickling._
import se.lu.nateko.cp.doi.Doi
import se.lu.nateko.cp.doi.DoiMeta
import org.scalajs.dom.ext.AjaxException
import org.scalajs.dom.raw.XMLHttpRequest

object Backend {

	def getPrefix: Future[String] = Ajax
		.get("/api/doiprefix")
		.recoverWith(recovery("fetch DOI prefix"))
		.map(_.responseText)

	def getDoiList: Future[Seq[Doi]] = Ajax
		.get("/api/list")
		.recoverWith(recovery("fetch DOI list"))
		.map(req => upickle.default.read[Seq[Doi]](req.responseText))

	def checkIfExists(doi: Doi): Future[Boolean] = Ajax
		.get(s"/api/$doi/exists")
		.recoverWith(recovery("check for DOI existence"))
		.map(_.responseText.toBoolean)

	def getTarget(doi: Doi): Future[Option[String]] = Ajax
		.get(s"/api/$doi/target")
		.recoverWith(recovery("fetch DOI target URL"))
		.map(req => upickle.default.read[Option[String]](req.responseText))

	def getMeta(doi: Doi): Future[DoiMeta] = Ajax
		.get(s"/api/$doi/metadata")
		.recoverWith(recovery("fetch DOI metadata"))
		.map(req => upickle.default.read[DoiMeta](req.responseText))

	def getInfo(doi: Doi): Future[DoiInfo] = Backend.getMeta(doi)
		.zip(Backend.getTarget(doi))
		.map{
			case (meta, target) => DoiInfo(meta, target, true)
		}

	def updateUrl(doi: Doi, url: String) = Ajax
		.post(s"/api/$doi/target", url)
		.recoverWith(recovery("update the target URL"))

	def updateMeta(meta: DoiMeta) = Ajax
		.post("/api/metadata", upickle.default.write(meta))
		.recoverWith(recovery("update DOI metadata"))

	private def recovery(hint: String): PartialFunction[Throwable, Future[XMLHttpRequest]] = {
		case AjaxException(xhr) =>
			val msg = if(xhr.responseText.isEmpty)
				s"Got HTTP status ${xhr.status} when trying to $hint"
			else s"Error when trying to $hint:\n" + xhr.responseText

			Future.failed(new Exception(msg))
	}
} 

//设置package包名称以及导入依赖的类
package simple

import org.scalajs.dom
import org.scalajs.dom.ext.{Ajax, KeyCode}
import org.scalajs.dom.html
import org.scalajs.dom.raw.Node

import scala.scalajs.concurrent.JSExecutionContext.Implicits.runNow
import scala.scalajs.js.annotation.JSExport
import scalatags.JsDom.all._

@JSExport
object Client extends {

  @JSExport
  def main(container: html.Div): Node = {

    val inputBox = input.render
    val outputBox = ul.render

    def update() = Ajax.post("/mongo/data", inputBox.value).foreach { xhr =>
      val data = upickle.default.read[Seq[String]](xhr.responseText)
      outputBox.innerHTML = ""
      for (entry <- data) {
        outputBox.appendChild(
          li(b(entry)).render
        )
      }
    }

    inputBox.onkeyup = (e: dom.KeyboardEvent) => if (e.keyCode == KeyCode.Enter) update()
    inputBox.size = 100

    update()

    container.appendChild(
      div(
        h1("Oak"),
        div(b("Query: "), inputBox),
        outputBox
      ).render
    )
  }
} 

//设置package包名称以及导入依赖的类
package webapp

import org.scalajs.dom.ext.Ajax
import upickle.default.read

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future

object ApiController {
	//val HOST: String = "http://localhost:9000" //For local testes
	val HOST: String = "/api" //For deployment
	val jsonHeaders: Map[String, String] = Map("content-type" -> "application/json")

	def fetchDeal(): Future[Deal] = Ajax.get(HOST + "/deal").flatMap(xhr => xhr.status match {
		case 200 => parseDealResponse(xhr.responseText)
		case _ => throw new RuntimeException(s"Error on HTTP connection on ${"GET " + HOST + "/deal"}: error code $xhr.status")
	})

	def fetchDish(dishId: Int): Future[Dish] = Ajax.get(HOST + "/dishes/" + dishId).flatMap(xhr => xhr.status match {
		case 200 => parseDishResponse(xhr.responseText)
		case _ => throw new RuntimeException(s"Error on HTTP connection on ${"GET " + HOST + "/dishes/" + dishId}: error code $xhr.status")
	})

	def fetchLeaderboard(): Future[Seq[Dish]] = Ajax.get(HOST + "/leaderboard").flatMap(xhr => xhr.status match {
		case 200 => parseDishesResponse(xhr.responseText)
		case _ => throw new RuntimeException(s"Error on HTTP connection on ${"GET " + HOST + "/leaderboard"}: error code $xhr.status")
	})

	def parseDishesResponse(dishJson: String): Future[Seq[Dish]] = {
		val dao = read[Seq[DishDAO]](dishJson)
		Future.successful(dao.map(d => Dish(d.title, d.image, d.keywords, d.score)))
	}

	def parseDishResponse(dishJson: String): Future[Dish] = {
		val dao = read[DishDAO](dishJson)
		Future.successful(Dish(dao.title, dao.image, dao.keywords, dao.score))
	}

	def parseDealResponse(dealJson: String): Future[Deal] = {
		val dao = read[DealWrapperDAO](dealJson)
		fetchDish(dao.deal.left).flatMap(left =>
			fetchDish(dao.deal.right).map(right =>
				Deal(dao.deal.uid, left, right)
			)
		)
	}

	def postChoice(choice: String, dealUid: String): Future[Unit] =
		Ajax.post(HOST + "/deal/" + dealUid, s"""{"side":"$choice"}""", 1000, jsonHeaders).map(xhr => xhr.status match {
			case 200 => Future.successful()
			case _ => throw new RuntimeException(s"Error on HTTP connection on ${"POST " + HOST + "/deal/" + dealUid}: error code $xhr.status")
		})
} 

//设置package包名称以及导入依赖的类
package autosteamgifts

import org.scalajs.dom.ext.Ajax
import org.scalajs.dom.raw.{Blob, URL}
import org.scalajs.dom.window.console
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.util.Failure

trait Notification {
  protected def imageUrlToBlobIconUrl(imageUrl: Option[String]): Future[Option[String]] = {
    val blobUrlFutOpt = imageUrl map { url =>
      Ajax.get(url, responseType = "blob") andThen {
        case Failure(ex) => console.error("Failure to request blob of", url)
      } map { xhr =>
        val blob = xhr.response match { case blob: Blob => blob }
        URL.createObjectURL(blob)
      }
    }

    val blobUrlOptFut = sequence(blobUrlFutOpt)
    blobUrlOptFut
  }

  private def sequence[T](option: Option[Future[T]]): Future[Option[T]] = {
    option match {
      case Some(future) => future map { Some(_) }
      case None => Future.successful(None)
    }
  }
} 

//设置package包名称以及导入依赖的类
package me.mmcoulombe.aad

import diode.{Effect, NoAction}
import me.mmcoulombe.add.json.JsonSupport
import me.mmcoulombe.add.models.RSSFeed
import org.scalajs.dom.ext.{Ajax, AjaxException}
import play.api.libs.json.Json

import scala.concurrent.ExecutionContext.Implicits.global


  def fetchFeeds(): Effect = {
    Effect(
      Ajax.get(FEED_URL)
        .map(xhr => Right(xhr.responseText))
        .recover{ case e: AjaxException => Left(new Error(e.xhr.responseText))}
        .map(
            _.map(str => Json.parse(str).as[List[RSSFeed]])
            .fold(_ => NoAction, feeds => SaveFeeds(feeds))
        )
    )
  }
} 

//设置package包名称以及导入依赖的类
package kidstravel.client.services

import org.scalajs.dom.ext.Ajax
import upickle.default._

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.Try

case class FlickrImage(id: String, farm: Int, server: String, secret: String) {
  lazy val url = s"https://farm$farm.staticflickr.com/$server/${id}_${secret}_z.jpg"
}

case class FlickrResponseContent(photo: List[FlickrImage])

case class FlickrResponse(photos: FlickrResponseContent)

object FlickrService {

  val endpoint = "https://api.flickr.com/services/rest/"
  val apiKey = "5990f1cb36590c021fe1c450771b17ef"
  //val apiSecret = "a84fc9fd1d461bf9"

  import kidstravel.client.util.UrlBuilder._

  //def search(keyword: String): Future[FlickrImage] = Future {  FlickrImage("1", 1, "1", "1") }

  def search(keyword: String): Future[FlickrImage] = {
    val url = endpoint &
      ("method" -> "flickr.photos.search") &
      ("format" -> "json") &
      ("nojsoncallback" -> "1") &
      ("api_key" -> apiKey) &
      ("text" -> keyword)
    Ajax.get(url).map { xhr =>
      try {
        read[FlickrResponse](xhr.responseText).photos.photo.head
      } catch {
        case t @ upickle.Invalid.Data(js, msg) =>
          println(s"JSON: $js\nMsg: $msg")
          throw t
      }
    }
  }

} 

//设置package包名称以及导入依赖的类
package co.enear.spotifywebapp

import org.scalajs.dom.ext.Ajax

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.scalajs.js.{JSON, URIUtils}

object SpotifyAPI {

  def fetchArtist(name: String): Future[Option[Artist]] = {
    Ajax.get(artistSearchURL(name)) map { xhr =>
      val searchResults = JSON.parse(xhr.responseText).asInstanceOf[SearchResults]
      searchResults.artists.items.headOption
    }
  }

  def fetchAlbums(artistId: String): Future[Seq[Album]] = {
    Ajax.get(albumsURL(artistId)) map { xhr =>
      val albumListing = JSON.parse(xhr.responseText).asInstanceOf[ItemListing[Album]]
      albumListing.items
    }
  }

  def fetchTracks(albumId: String): Future[Seq[Track]] = {
    Ajax.get(tracksURL(albumId)) map { xhr =>
      val trackListing = JSON.parse(xhr.responseText).asInstanceOf[ItemListing[Track]]
      trackListing.items
    }
  }

  def artistSearchURL(name: String) = s"https://api.spotify.com/v1/search?type=artist&q=${URIUtils.encodeURIComponent(name)}"
  def albumsURL(artistId: String) =   s"https://api.spotify.com/v1/artists/$artistId/albums?limit=50&market=PT&album_type=album"
  def tracksURL(albumId: String) =    s"https://api.spotify.com/v1/albums/$albumId/tracks?limit=50"
} 

//设置package包名称以及导入依赖的类
package pages

import japgolly.scalajs.react._
import japgolly.scalajs.react.vdom.prefix_<^._

import scalacss.Defaults._
import scalacss.ScalaCssReact._
import org.scalajs.dom.ext.Ajax
import scala.concurrent.ExecutionContext
import shared.models.Table1
import upickle.default._
import org.scalajs.dom

object HomePage {

  case class State(rows: Option[Seq[Table1]] = None)

  class Backend(scope: BackendScope[Unit, State]) {

    def loadRows = Callback {
      import scala.concurrent.ExecutionContext.Implicits.global
      Ajax.get("/listTable1").onSuccess {
        case xhr =>
          val result = read[Seq[Table1]](xhr.responseText)
          //calling runNow because of running inside ajax call
          scope.modState(_.copy(rows = Some(result))).runNow
      }
    }

    def render(state: State) = {
      println(s"Rendering $state")
      state.rows match {
        case None =>
          <.div(^.id := "home-content",
                css.Home.content,
                "react-quill template")

        case Some(rows) =>
          //ugly .toString just to prove the concept...
          <.div(^.id := "home-content", css.Home.content, s"${rows.toString}")
      }
    }

    def clear = Callback {
      //      println("Clear called")
    }

  }

  val component = ReactComponentB[Unit]("HomePage")
    .initialState(State())
    .renderBackend[Backend]
    .componentDidMount(_.backend.loadRows)
    .componentWillUnmount(_.backend.clear)
    .build

  def apply(): ReactElement = {
    component()
  }
}