You may have mistyped the address or the page may have moved.
25 |We've been notified about this issue and we'll take a look at it shortly.
24 |"+a+"";b=b.firstChild;f&&B(b,f,!0);H({j:d,m:f,h:b,l:1,a:null,i:null,c:null,g:null});return b.innerHTML}, 60 | prettyPrint:g=g=function(a,d){function f(){for(var b=R.PR_SHOULD_USE_CONTINUATION?c.now()+250:Infinity;r
Params:
26 |{textParams}Component1 output:
37 |{compo1.render()}
38 |
39 | Component2 output:
40 |{compo2.render().toString}
41 |
12 | URL = {absUrl[ArticlesDotShow]("id" -> 1, "format" -> "foo")}
13 | id = {id}
14 | format = {format}
15 |
16 | )
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/Errors.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import xitrum.annotation.{Error404, Error500}
4 |
5 | @Error404
6 | class NotFoundError extends AppAction {
7 | def execute(): Unit = {
8 | respondView()
9 | }
10 | }
11 |
12 | @Error500
13 | class ServerError extends AppAction {
14 | def execute(): Unit = {
15 | respondView()
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/FileMonitorEvents.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import java.io.{BufferedWriter, FileWriter}
4 | import java.nio.file.{Path, Paths}
5 |
6 | import xitrum.annotation.{GET, SOCKJS}
7 | import xitrum.Config.xitrum.tmpDir
8 | import xitrum.SockJsAction
9 | import xitrum.util.FileMonitor
10 |
11 | @GET("fileMonitor")
12 | class FileMonitorEvents extends AppAction {
13 | def execute(): Unit = {
14 | respondView()
15 | }
16 | }
17 |
18 | @SOCKJS("fileMonitorSocket")
19 | class FileMonitorEventsSocket extends SockJsAction {
20 | def execute(): Unit = {
21 | val targetDirPath = tmpDir.toPath.toAbsolutePath
22 | val targetFilePath = Paths.get(targetDirPath.toString + "/created_" + System.currentTimeMillis()).toAbsolutePath
23 |
24 | // Start monitoring create event in config dir
25 | FileMonitor.monitor(targetDirPath) { (event, path, stop) =>
26 | event match {
27 | case FileMonitor.CREATE => onCreate(path)
28 | case FileMonitor.MODIFY => onModify(path)
29 | case FileMonitor.DELETE => onDelete(path, stop)
30 | }
31 | }
32 |
33 | respondSockJsText(s"[Registered]: File monitor is registered to: $targetDirPath")
34 |
35 | // Kick off file create event
36 | Thread.sleep(1000)
37 | targetFilePath.toFile.createNewFile()
38 |
39 | def onCreate(path: Path): Unit = {
40 | respondSockJsText(s"[Created]: $path")
41 |
42 | // Kick off file modify event
43 | Thread.sleep(1000)
44 | val writer = new BufferedWriter(new FileWriter(path.toFile))
45 | writer.write("There's text in here wee!!")
46 | writer.close()
47 | }
48 |
49 | def onModify(path: Path): Unit = {
50 | respondSockJsText(s"[Modified]: $path")
51 |
52 | // Kick off file delete event
53 | Thread.sleep(1000)
54 | path.toFile.delete()
55 | }
56 |
57 | def onDelete(path: Path, stop: FileMonitor.Stop): Unit = {
58 | respondSockJsText(s"[Deleted]: $path")
59 | stop()
60 | }
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/Filter.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import xitrum.annotation.GET
4 |
5 | @GET("filter/before")
6 | class BeforeFilter extends AppAction {
7 | beforeFilter {
8 | log.info("I run therefore I am")
9 | }
10 |
11 | // This method is run after the above filters
12 | def execute(): Unit = {
13 | respondInlineView("Before filters should have been run, please check the log")
14 | }
15 | }
16 |
17 | @GET("filter/after")
18 | class AfterFilter extends AppAction {
19 | afterFilter {
20 | log.info("Run at " + System.currentTimeMillis())
21 | }
22 |
23 | def execute(): Unit = {
24 | respondInlineView("After filter should have been run, please check the log")
25 | }
26 | }
27 |
28 | @GET("filter/around")
29 | class AroundFilter extends AppAction {
30 | aroundFilter { action =>
31 | val begin = System.currentTimeMillis()
32 | action()
33 | val end = System.currentTimeMillis()
34 | log.info("The action took " + (end - begin) + " [ms]")
35 | }
36 |
37 | def execute(): Unit = {
38 | respondInlineView("Around filter should have been run, please check the log")
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/Forward.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import xitrum.annotation.GET
4 |
5 | @GET("forward")
6 | class ForwardDemo extends AppAction {
7 | def execute(): Unit = {
8 | forwardTo[ForwardedDemo]()
9 | }
10 | }
11 |
12 | @GET("forwarded")
13 | class ForwardedDemo extends AppAction {
14 | def execute(): Unit = {
15 | respondInlineView("This action could have been forwarded from ForwardDemo")
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/GetPost.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import xitrum.annotation.{GET, POST}
4 |
5 | @GET("get_post", "get_post_another_route")
6 | @POST("get_post")
7 | class GetPost extends AppAction {
8 | def execute(): Unit = {
9 | respondView()
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/JsonPost.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import io.netty.handler.codec.http.HttpMethod
4 | import xitrum.annotation.{GET, POST}
5 | import xitrum.util.SeriDeseri
6 |
7 | case class MyClass(x: Int, y: Int)
8 |
9 | @GET("json")
10 | @POST("json/:demo")
11 | class JsonPost extends AppAction {
12 | def execute(): Unit = {
13 | if (request.method == HttpMethod.POST) {
14 | param("demo") match {
15 | case "1" =>
16 | // You can parse the JSON as a Map like this:
17 | val map = SeriDeseri.fromJValue[Map[String, Int]](requestContentJValue)
18 | respondText(map)
19 |
20 | case _ =>
21 | // Or convert it to a (case) class instance
22 | val myClass = SeriDeseri.fromJValue[MyClass](requestContentJValue)
23 | respondText(myClass)
24 | }
25 | } else {
26 | respondView()
27 | }
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/OpenId.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import scala.util.control.NonFatal
4 |
5 | import org.openid4java.consumer.ConsumerManager
6 | import org.openid4java.discovery.DiscoveryInformation
7 | import org.openid4java.message.ParameterList
8 |
9 | import xitrum.annotation.{GET, POST}
10 |
11 | // See https://code.google.com/p/openid4java/wiki/QuickStart
12 | //
13 | // OpenID4Java dependency has been added to build.sbt:
14 | // libraryDependencies += "org.openid4java" % "openid4java" % "0.9.8"
15 |
16 | object OpenId {
17 | val manager = new ConsumerManager
18 | val SESSION_KEY = "openIdDiscovered"
19 | }
20 |
21 | @GET("openid/login")
22 | class OpenIdLogin extends AppAction {
23 | def execute(): Unit = {
24 | respondView()
25 | }
26 | }
27 |
28 | @POST("openid/redirect")
29 | class OpenIdRedirect extends AppAction {
30 | def execute(): Unit = {
31 | try {
32 | val openId = param("openId")
33 | val discoveries = OpenId.manager.discover(openId)
34 | val discovered = OpenId.manager.associate(discoveries)
35 | val returnUrl = absUrl[OpenIdVerify] // Must be http(s)://...
36 | val authReq = OpenId.manager.authenticate(discovered, returnUrl)
37 | val destinationUrl = authReq.getDestinationUrl(true)
38 |
39 | session(OpenId.SESSION_KEY) = discovered
40 | redirectTo(destinationUrl)
41 | } catch {
42 | case NonFatal(e) =>
43 | log.warn("OpenID error", e)
44 | flash("Could not redirect to remote OpenID provider. Your OpenID may be wrong.")
45 | redirectTo[OpenIdLogin]()
46 | }
47 | }
48 | }
49 |
50 | @GET("openid/verify")
51 | class OpenIdVerify extends AppAction {
52 | def execute(): Unit = {
53 | try {
54 | val queryString = request.uri.substring(request.uri.indexOf("?") + 1)
55 | val openIdResp = ParameterList.createFromQueryString(queryString)
56 | val discovered = session(OpenId.SESSION_KEY).asInstanceOf[DiscoveryInformation]
57 | val receivingUrl = absUrl[OpenIdVerify] + "?" + queryString
58 | val verification = OpenId.manager.verify(receivingUrl, openIdResp, discovered)
59 | val verifiedId = verification.getVerifiedId
60 |
61 | session.clear()
62 | if (verifiedId != null)
63 | flash("OpenID login success: " + verifiedId)
64 | else
65 | flash("OpenID login failed")
66 | } catch {
67 | case NonFatal(e) =>
68 | log.warn("OpenID error", e)
69 | flash("OpenID login failed")
70 | }
71 | redirectTo[OpenIdLogin]()
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/ScalateAction.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import xitrum.Config
4 | import xitrum.annotation.GET
5 | import xitrum.view.Scalate
6 |
7 | @GET("scalate/notFile")
8 | class ScalateJadeString extends AppAction {
9 | def execute(): Unit = {
10 | val scalate = Config.xitrum.template.get.asInstanceOf[Scalate]
11 | val template = "p This Jade template is from a string, not from a file."
12 | val string = scalate.renderJadeString(template)
13 | respondInlineView(string)
14 | }
15 | }
16 |
17 | @GET("scalate/mustache")
18 | class ScalateMustache extends AppAction {
19 | def execute(): Unit = {
20 | at("name") = "Chris"
21 | at("value") = 10000
22 | at("taxed_value") = 10000 - (10000 * 0.4)
23 | at("in_ca") = true
24 | respondView(Map("type" -> "mustache"))
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/SiteIndex.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import xitrum.annotation.GET
4 |
5 | @GET("")
6 | class SiteIndex extends AppAction {
7 | def execute(): Unit = {
8 | respondView()
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/SourceCode.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import scala.util.control.NonFatal
4 |
5 | import javassist.{ClassPool, ClassClassPath}
6 | import xitrum.Config.xitrum.cache
7 | import xitrum.util.Loader
8 |
9 | object SourceCode {
10 | private val classPool = {
11 | val ret = ClassPool.getDefault
12 | val classPath = new ClassClassPath(getClass)
13 | ret.insertClassPath(classPath)
14 | ret
15 | }
16 |
17 | def getSourceFileName(className: String): String = {
18 | cache.getAs[String](className) match {
19 | case Some(fileName) =>
20 | fileName
21 |
22 | case None =>
23 | val ctClass = classPool.get(className)
24 | val classFile = ctClass.getClassFile
25 | val fileName = classFile.getSourceFile
26 | cache.put(className, fileName)
27 | fileName
28 | }
29 | }
30 |
31 | def getFileContent(path: String): String = {
32 | cache.get(path) match {
33 | case Some(content) =>
34 | content.toString
35 |
36 | case None =>
37 | try {
38 | val content = Loader.stringFromFile(path)
39 | cache.put(path, content)
40 | content
41 | } catch {
42 | case NonFatal(_) =>
43 | "Could not load file: " + path
44 | }
45 | }
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/Swagger.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import io.netty.handler.codec.http.HttpResponseStatus
4 | import xitrum.{Action, SkipCsrfCheck}
5 | import xitrum.annotation.{GET, POST, PATCH, DELETE, Swagger}
6 |
7 | @Swagger(
8 | Swagger.Tags("Operations about articles"),
9 | Swagger.Produces("application/json")
10 | )
11 | trait Api extends Action with SkipCsrfCheck
12 |
13 | @GET("api/articles")
14 | @Swagger(
15 | Swagger.Summary("List all articles")
16 | )
17 | class ApiArticlesIndex extends Api {
18 | def execute(): Unit = {
19 | val articles = Article.findAll()
20 | respondJson(articles)
21 | }
22 | }
23 |
24 | @GET("api/articles/:id<[0-9]+>")
25 | @Swagger(
26 | Swagger.Summary("Show an article"),
27 | Swagger.IntPath("id", "ID of the article")
28 | )
29 | class ApiArticlesShow extends Api {
30 | def execute(): Unit = {
31 | val id = param[Int]("id")
32 | Article.find(id) match {
33 | case None =>
34 | response.setStatus(HttpResponseStatus.NOT_FOUND)
35 | respondText("Article not found")
36 |
37 | case Some(article) =>
38 | respondJson(article)
39 | }
40 | }
41 | }
42 |
43 | @POST("api/articles")
44 | @Swagger(
45 | Swagger.Summary("Create a new article"),
46 | Swagger.Consumes("application/x-www-form-urlencoded"),
47 | Swagger.StringForm("title"),
48 | Swagger.StringForm("content"),
49 | Swagger.Response(200, "ID of the newly created article will be returned")
50 | )
51 | class ApiArticlesCreate extends Api {
52 | def execute(): Unit = {
53 | val title = param("title")
54 | val content = param("content")
55 | val article = Article(title = title, content = content)
56 | article.validationMessage match {
57 | case None =>
58 | val id = Article.insert(article)
59 | respondJson(Map("id" -> id))
60 |
61 | case Some(msg) =>
62 | respondJson(Map("error" -> msg))
63 | }
64 | }
65 | }
66 |
67 | @PATCH("api/articles/:id")
68 | @Swagger(
69 | Swagger.Summary("Modify an article"),
70 | Swagger.IntPath("id", "ID of the article to modify"),
71 | Swagger.Consumes("application/x-www-form-urlencoded"),
72 | Swagger.StringForm("title", "New title"),
73 | Swagger.StringForm("content", "New content")
74 | )
75 | class ApiArticlesUpdate extends Api {
76 | def execute(): Unit = {
77 | val id = param[Int]("id")
78 | val title = param("title")
79 | val content = param("content")
80 | val article = Article(id, title, content)
81 | article.validationMessage match {
82 | case None =>
83 | Article.update(article)
84 | respondJson(Map("id" -> id))
85 |
86 | case Some(msg) =>
87 | response.setStatus(HttpResponseStatus.BAD_REQUEST)
88 | respondJson(Map("error" -> msg))
89 | }
90 | }
91 | }
92 |
93 | @DELETE("api/articles/:id")
94 | @Swagger(
95 | Swagger.Summary("Delete an article"),
96 | Swagger.IntPath("id")
97 | )
98 | class ApiArticlesDestroy extends Api {
99 | def execute(): Unit = {
100 | val id = param[Int]("id")
101 | if (id == 1) {
102 | response.setStatus(HttpResponseStatus.BAD_REQUEST)
103 | respondJson(Map("error" -> "This article is for demo, can't be deleted"))
104 | } else {
105 | Article.delete(id)
106 | respondJson(Map("id" -> id))
107 | }
108 | }
109 | }
110 |
111 | @GET("swagger")
112 | class SwaggerDemo extends AppAction {
113 | def execute(): Unit = {
114 | respondView()
115 | }
116 | }
117 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/Todos.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import xitrum.RequestVar
4 | import xitrum.annotation.{GET, POST}
5 | import xitrum.util.SeriDeseri
6 |
7 | // Actions ---------------------------------------------------------------------
8 |
9 | // Request var for passing data from action to Scalate view
10 | object RVTodoList extends RequestVar[TodoList]
11 |
12 | @GET("todos")
13 | class TodosIndex extends AppAction {
14 | def execute(): Unit = {
15 | val todoList = TodoList.get()
16 | RVTodoList.set(todoList)
17 | respondView()
18 | }
19 | }
20 |
21 | @POST("todos")
22 | class TodosSave extends AppAction {
23 | def execute(): Unit = {
24 | val json = param("model")
25 | val todoList = SeriDeseri.fromJson[TodoList](json).get
26 |
27 | // You can update the model on the browser like this:
28 | // val newTodoList = ...
29 | // respondJson(newTodoList)
30 | //
31 | // Whenever the model on the browser is updated, Knockout.js will automagically
32 | // update the UI!
33 |
34 | TodoList.update(todoList)
35 | jsRespondFlash("Todo list has been saved")
36 | }
37 | }
38 |
39 | // Model -----------------------------------------------------------------------
40 |
41 | case class Todo(done: Boolean, desc: String)
42 | case class TodoList(todos: Seq[Todo])
43 |
44 | object TodoList {
45 | private var storage = TodoList(Seq(Todo(done = true, "Task1"), Todo(done = false, "Task2")))
46 |
47 | def get(): TodoList = storage
48 | def update(todoList: TodoList): Unit = { storage = todoList }
49 | }
50 |
--------------------------------------------------------------------------------
/src/main/scala/demos/action/Upload.scala:
--------------------------------------------------------------------------------
1 | package demos.action
2 |
3 | import io.netty.handler.codec.http.multipart.FileUpload
4 | import xitrum.annotation.{GET, POST}
5 |
6 | @GET("upload")
7 | class Upload extends AppAction {
8 | def execute(): Unit = {
9 | respondView()
10 | }
11 | }
12 |
13 | @POST("upload")
14 | class DoUpload extends AppAction {
15 | def execute(): Unit = {
16 | paramo[FileUpload]("file") match {
17 | case Some(file) =>
18 | flash("Uploaded " + file)
19 |
20 | case None =>
21 | flash("Please upload a nonempty file")
22 | }
23 |
24 | respondView[Upload]()
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/src/main/scalate/demos/action/AppAction.jade:
--------------------------------------------------------------------------------
1 | - import demos.action._
2 |
3 | - val metricsApiKey = at[String]("metricsViewerApiKey")
4 |
5 | !!! 5
6 | html
7 | head
8 | != antiCsrfMeta
9 | != xitrumCss
10 |
11 | meta(content="text/html; charset=utf-8" http-equiv="content-type")
12 | title Welcome to Xitrum
13 |
14 | link(rel="shortcut icon" href={publicUrl("favicon.ico")})
15 |
16 | link(type="text/css" rel="stylesheet" media="all" href={webJarsUrl("bootstrap-css/3.3.6/css", "bootstrap.css", "bootstrap.min.css")})
17 | link(type="text/css" rel="stylesheet" media="all" href={publicUrl("app.css")})
18 |
19 | body
20 | .container
21 | .navbar.navbar-inverse
22 | .navbar-brand
23 | a(href={url[SiteIndex]}) Xitrum Demos
24 | ul.nav.navbar-nav
25 | li
26 | a(href="https://github.com/xitrum-framework/xitrum-demos/tree/master/src/main") Source code
27 | li
28 | a(href="http://xitrum-framework.github.io/") Xitrum Homepage
29 | li
30 | a(href="http://xitrum-framework.github.io/guide.html") Xitrum Guide
31 | li
32 | a(href="http://xitrum-framework.github.io/api.html") API Doc
33 | li
34 | a(href="https://github.com/xitrum-framework/xitrum-new") New Project Skeleton
35 | li
36 | a(href="https://groups.google.com/group/xitrum-framework") Google Group
37 |
38 | .container
39 | .col-md-9
40 | #flash
41 | !~ jsRenderFlash()
42 |
43 | != renderedView
44 |
45 | hr
46 | h3 Source code of current action
47 | div
48 | -# fileName is only, for example, Articles.scala, not /full/path/to/Articles.scala
49 | - val fileName = SourceCode.getSourceFileName(currentAction.getClass.getName)
50 | b= "demos/action/" + fileName
51 | pre(id="actionSrc" class="prettyprint linenums:1 lang-scala")
52 | ~~ SourceCode.getFileContent("src/main/scala/demos/action/" + fileName)
53 |
54 | .col-md-3
55 | p REST
56 | ul
57 | li
58 | a(href={url[ArticlesIndex]}) index
59 | li
60 | a(href={url[ArticlesShow]("id" -> 1)}) show
61 | li
62 | a(href={url[ArticlesEdit]("id" -> 1)}) edit
63 | li
64 | a(href={url[ArticlesNew]}) new
65 |
66 | p Async
67 | ul
68 | li
69 | a(href={url[ActorActionDemo]}) ActorAction (delayed 3s)
70 | li
71 | a(href={url[WebSocketChat]}) WebSocket chat
72 | li
73 | a(href={url[SockJsChat]}) SockJS chat
74 |
75 | p Filters
76 | ul
77 | li
78 | a(href={url[BeforeFilter]}) Before filter
79 | li
80 | a(href={url[AfterFilter]}) After filter
81 | li
82 | a(href={url[AroundFilter]}) Around filter
83 |
84 | p Cache
85 | ul
86 | li
87 | a(href={url[ActionCacheDemo]}) Action cache
88 | li
89 | a(href={url[PageCacheDemo]}) Page cache
90 |
91 | p Scalate
92 | ul
93 | li
94 | a(href={url[ScalateJadeString]}) Template from string
95 | li
96 | a(href={url[ScalateMustache]}) Mustache template
97 |
98 | p Various demos
99 | ul
100 | li
101 | a(href={url[Upload]}) File upload
102 | li
103 | a(href={url[CompoMain]("param1" -> "value1", "param" -> "value2")}) Component
104 | li
105 | a(href={url[ArticlesDotShow]("id" -> 1, "format" -> "foo")}) Dot in path
106 | li
107 | a(href={url[ForwardDemo]}) forwardTo
108 | li
109 | a(href={url[GetPost]}) Multiple routes to an action
110 | li
111 | a(href={url[JsonPost]}) Json POST parse action
112 | li
113 | a(href={url[TodosIndex]}) Knockout.js
114 | li
115 | a(href={url[OpenIdLogin]}) OpenID login
116 | li
117 | a(href={url[FileMonitorEvents]}) File monitor
118 |
119 | p Special demos
120 | ul
121 | li
122 | a(href={url[SwaggerDemo]}) Swagger demo
123 | li
124 | a(href={url[xitrum.metrics.XitrumMetricsViewer]("api_key" -> metricsApiKey)}) Metrics
125 |
126 | != jsDefaults
127 | script(src={publicUrl("run_prettify.js")})
128 | != jsForView
129 |
--------------------------------------------------------------------------------
/src/main/scalate/demos/action/ArticlesEdit.jade:
--------------------------------------------------------------------------------
1 | - import demos.action._
2 | - val article = RVArticle.get
3 |
4 | h1 Edit article
5 |
6 | form(action={url[ArticlesUpdate]("id" -> article.id)} method="post")
7 | != antiCsrfInput
8 | input(type="hidden" name="_method" value="patch")
9 |
10 | - at("article") = article
11 | != renderFragment("ArticlesForm")
12 |
13 | p
14 | a(href={url[ArticlesShow]("id" -> article.id)}) Cancel |
15 | a(href={url[ArticlesIndex]}) List of articles
16 |
--------------------------------------------------------------------------------
/src/main/scalate/demos/action/ArticlesIndex.jade:
--------------------------------------------------------------------------------
1 | - import demos.action._
2 |
3 | h1 Articles
4 |
5 | ul
6 | - for (article <- RVArticles.get)
7 | li
8 | a(href={url[ArticlesShow]("id" -> article.id)})= article.title
9 |
10 | p
11 | a(href={url[ArticlesNew]}) Create new
--------------------------------------------------------------------------------
/src/main/scalate/demos/action/ArticlesNew.jade:
--------------------------------------------------------------------------------
1 | - import demos.action._
2 | - val article = RVArticle.get
3 |
4 | h1 Create new article
5 |
6 | form(action={url[ArticlesCreate]} method="post")
7 | != antiCsrfInput
8 |
9 | - at("article") = article
10 | != renderFragment("ArticlesForm")
11 |
12 | p
13 | a(href={url[ArticlesIndex]}) List of articles
14 |
--------------------------------------------------------------------------------
/src/main/scalate/demos/action/ArticlesShow.jade:
--------------------------------------------------------------------------------
1 | - import demos.action._
2 | - val article = RVArticle.get
3 |
4 | h1= article.title
5 |
6 | p= article.content
7 |
8 | p
9 | a(href={url[ArticlesEdit]("id" -> article.id)}) Edit |
10 | a(href={url[ArticlesIndex]}) List of articles
11 |
--------------------------------------------------------------------------------
/src/main/scalate/demos/action/CompoMain.jade:
--------------------------------------------------------------------------------
1 | - import demos.action._
2 |
3 | p
4 | | You can create reusable components. A component is similar to an action, but without the
5 | code execute
6 | | method. A component can have or don't have associated views.
7 |
8 | h4 Component that has associated view
9 |
10 | != newComponent[CompoWithView]().render()
11 |
12 | h4 Component that renders directly
13 |
14 | != newComponent[CompoWithoutView]().render()
15 |
16 | h4 Component that contains other components
17 |
18 | != newComponent[CompoNested]().render()
19 |
--------------------------------------------------------------------------------
/src/main/scalate/demos/action/CompoWithView.jade:
--------------------------------------------------------------------------------
1 | p Headers:
2 |
3 | pre<
4 | code= request.headers.names
5 |
--------------------------------------------------------------------------------
/src/main/scalate/demos/action/FileMonitorEvents.jade:
--------------------------------------------------------------------------------
1 | - import demos.action._
2 |
3 | h1 FileMonitor demo
4 |
5 | p In this demo:
6 |
7 | ol
8 | li A file will be created
9 | li Then edited
10 | li Then deleted
11 |
12 | #chatOutput
13 |
14 | -
15 | jsAddToView(
16 | "var url = '" + sockJsUrl[FileMonitorEventsSocket] + "';" +
17 | """
18 | var socket;
19 |
20 |
21 | var initSocket = function() {
22 | socket = new SockJS(url);
23 |
24 | socket.onopen = function(event) {
25 | };
26 |
27 | socket.onclose = function(event) {
28 | // Reconnect
29 | setTimeout(initSocket, 1000);
30 | };
31 |
32 | socket.onmessage = function(event) {
33 | var text = event.data + '