grails create-controller book

package myapp
class BookController {
    def index() { }
}

class BookController {
    def list() {
        // do controller logic
        // create model
        return model
    }
}

grails.compile.artefacts.closures.convert = true

static defaultAction = "list"

class BookController {
    def find() {
        def findBy = params["findBy"]
        def appContext = request["foo"]
        def loggedUser = session["logged_user"]
    }
}

class BookController {
    def find() {
        def findBy = params.findBy
        def appContext = request.foo
        def loggedUser = session.logged_user
    }
}

def delete() {
    def b = Book.get(params.id)
    if (!b) {
        flash.message = "User not found for id ${params.id}"
        redirect(action:list)
    }
    … // remaining code
}

static scope = "singleton"

grails.controllers.defaultScope = "singleton"

def show() {
    [book: Book.get(params.id)]
}

class BookController {
    List books
    List authors
    def list() {
        books = Book.list()
        authors = Author.list()
    }
}

import org.springframework.web.servlet.ModelAndView
def index() {
    // get some books just for the index page, perhaps your favorites
    def favoriteBooks = ...
    // forward to the list view to show them
    return new ModelAndView("/book/list", [ bookList : favoriteBooks ])
}

class BookController {
    def show() {
         [book: Book.get(params.id)]
    }
}

def show() {
    def map = [book: Book.get(params.id)]
    render(view: "display", model: map)
}

def show() {
    def map = [book: Book.get(params.id)]
    render(view: "/shared/display", model: map)
}

render "Hello World!"

// マークアップを返す
render {
   for (b in books) {
      div(id: b.id, b.title)
   }
}

// 指定したビューを描写
render(view: 'show')

// コレクションの中身をそれぞれ指定したテンプレートを適応して描写
render(template: 'book_template', collection: Book.list())

// 文字列を指定したエンコーディングとコンテントタイプで描写
render(text: "<xml>some xml</xml>", contentType: "text/xml", encoding: "UTF-8")

import groovy.xml.MarkupBuilder
…
def login() {
    def writer = new StringWriter()
    def builder = new MarkupBuilder(writer)
    builder.html {
        head {
            title 'Log in'
        }
        body {
            h1 'Hello'
            form {
            }
        }
    }
    def html = writer.toString()
    render html
}

def login() {
    // …
    body {
        h1 'Hello'
        builder.form {
        }
    }
    // …
}

class OverviewController {
    def login() {}
    def find() {
        if (!session.user)
            redirect(action: 'login')
            return
        }
        …
    }
}

// Call the login action within the same class
redirect(action: login)

// Also redirects to the index action in the home controller
redirect(controller: 'home', action: 'index')

// Redirect to an explicit URI
redirect(uri: "/login.html")

// Redirect to a URL
redirect(url: "http://grails.org")

redirect(action: 'myaction', params: [myparam: "myvalue"])

redirect(action: "next", params: params)

redirect(controller: "test", action: "show", fragment: "profile")

class ExampleChainController {
    def first() {
        chain(action: second, model: [one: 1])
    }
    def second () {
        chain(action: third, model: [two: 2])
    }
    def third() {
        [three: 3])
    }
}

[one: 1, two: 2, three: 3]

class ChainController {
    def nextInChain() {
        def model = chainModel.myModel
        …
    }
}

chain(action: "action1", model: [one: 1], params: [myparam: "param1"])

def beforeInterceptor = {
    println "Tracing action ${actionUri}"
}

def beforeInterceptor = [action: this.&auth, except: 'login']
// defined with private scope, so it's not considered an action
private auth() {
    if (!session.user) {
        redirect(action: 'login')
        return false
    }
}
def login() {
    // display login page
}

def afterInterceptor = { model ->
    println "Tracing action ${actionUri}"
}

def afterInterceptor = { model, modelAndView ->
    println "Current view is ${modelAndView.viewName}"
    if (model.someVar) modelAndView.viewName = "/mycontroller/someotherview"
    println "View is now ${modelAndView.viewName}"
}

def beforeInterceptor = [action: this.&auth, except: 'login']

def beforeInterceptor = [action: this.&auth, except: ['login', 'register']]

def beforeInterceptor = [action: this.&auth, only: ['secure']]

// grails-app/domain/Person.groovy
class Person {
    String firstName
    String lastName
    Integer age
}

def bindingMap = [firstName: 'Peter', lastName: 'Gabriel', age: 63]
def person = new Person(bindingMap)
assert person.firstName == 'Peter'
assert person.lastNaem == 'Gabriel'
assert person.age == 63

def bindingMap = [firstName: 'Peter', lastName: 'Gabriel', age: 63]
def person = Person.get(someId)
person.properties = bindingMap
assert person.firstName == 'Peter'
assert person.lastNaem == 'Gabriel'
assert person.age == 63

class Person {
    String firstName
    String lastName
    Integer age
    Address homeAddress
}
class Address {
    String county
    String country
}

def bindingMap = [firstName: 'Peter', lastName: 'Gabriel', age: 63, homeAddress: [county: 'Surrey', country: 'England'] ]
def person = new Person(bindingMap)
assert person.firstName == 'Peter'
assert person.lastNaem == 'Gabriel'
assert person.age == 63
assert person.homeAddress.county == 'Surrey'
assert person.homeAddress.country == 'England'

class Band {
    String name
    static hasMany = [albums: Album]
    List albums
}
class Album {
    String title
    Integer numberOfTracks
}

def bindingMap = [name: 'Genesis', 
                  'albums[0]': [title: 'Foxtrot', numberOfTracks: 6], 
                  'albums[1]': [title: 'Nursery Cryme', numberOfTracks: 7]]
def band = new Band(bindingMap)
assert band.name == 'Genesis'
assert band.albums.size() == 2
assert band.albums[0].title == 'Foxtrot'
assert band.albums[0].numberOfTracks == 6
assert band.albums[1].title == 'Nursery Cryme'
assert band.albums[1].numberOfTracks == 7

/*
 * The value of the indexes 0 and 1 in albums[0] and albums[1] are arbitrary
 * values that can be anything as long as they are unique within the Map.
 * They do not correspond to the order of elements in albums because albums
 * is a Set.
 */
def bindingMap = ['albums[0]': [id: 9, title: 'The Lamb Lies Down On Broadway']
                  'albums[1]': [id: 4, title: 'Selling England By The Pound']]
def band = Band.get(someBandId)
/*
 * This will find the Album in albums that has an id of 9 and will set its title
 * to 'The Lamb Lies Down On Broadway' and will find the Album in albums that has
 * an id of 4 and set its title to 'Selling England By The Pound'.  In both 
 * cases if the Album cannot be found in albums then the album will be retrieved
 * from the database by id, the Album will be added to albums and will be updated 
 * with the values described above.  If a Album with the specified id cannot be
 * found in the database, then a binding error will be created and associated
 * with the band object.  More on binding errors later.
 */
band.properties = bindingMap

class Album {
    String title
    static hasMany = [players: Player]
    Map players
}
class Player {
    String name
}

def bindingMap = [title: 'The Lamb Lies Down On Broadway',
                  'players[guitar]': [name: 'Steve Hacket'],
                  'players[vocals]': [name: 'Peter Gabriel']
                  'players[keyboards]': [name: 'Tony Banks']]
def album = new Album(bindingMap)
assert album.title == 'The Lamb Lies Down On Broadway'
assert album.players.size() == 3
assert album.players.guitar == 'Steve Hacket'
assert album.players.vocals == 'Peter Gabriel'
assert album.players.keyboards == 'Tony Banks'

def bindingMap = [title: 'The Lamb Lies Down On Broadway',
                  'players[guitar]': [name: 'Steve Hacket'],
                  'players[vocals]': [name: 'Peter Gabriel']
                  'players[keyboards]': [name: 'Tony Banks']]
def album = new Album(bindingMap)
assert album.title == 'The Lamb Lies Down On Broadway'
assert album.players.size() == 3
assert album.players.guitar == 'Steve Hacket'
assert album.players.vocals == 'Peter Gabriel'
assert album.players.keyboards == 'Tony Banks'
def updatedBindingMap = ['players[drums]': [name: 'Phil Collins'],
                         'players[keyboards]': [name: 'Anthony George Banks']]
album.properties = updatedBindingMap
assert album.title == 'The Lamb Lies Down On Broadway'
assert album.players.size() == 4
assert album.players.guitar == 'Steve Hacket'
assert album.players.vocals == 'Peter Gabriel'
assert album.players.keyboards == 'Anthony George Banks'
assert album.players.drums == 'Phil Collins'

[person: [homeAddress: [country: 'USA', city: 'St. Louis']]]

def save() {
    def b = new Book(params)
    b.save()
}

/book/save?title=The%20Stand&author=Stephen%20King

def save() {
    def b = Book.get(params.id)
    b.properties = params
    b.save()
}

// the default value is true
grails.databinding.trimStrings = false
// ...

// the default value is true
grails.databinding.convertEmptyStringsToNull = false
// ...

/book/save?author.id=20

def b = new Book(params)

/book/save?author.id=null

<g:select name="books"
          from="${Book.list()}"
          size="5" multiple="yes" optionKey="id"
          value="${author?.books}" />

<g:textField name="books[0].title" value="the Stand" />
<g:textField name="books[1].title" value="the Shining" />

<g:textField name="books[0].title" value="the Stand" />
<g:textField name="books[1].title" value="the Shining" />
<g:textField name="books[2].title" value="Red Madder" />

<g:textField name="books[0].title" value="the Stand" />
<g:textField name="books[1].title" value="the Shining" />
<g:textField name="books[5].title" value="Red Madder" />

<g:select name="books[0].id" from="${bookList}"
          value="${author?.books[0]?.id}" />
<g:select name="books[1].id" from="${bookList}"
          value="${author?.books[1]?.id}" />
<g:select name="books[2].id" from="${bookList}"
          value="${author?.books[2]?.id}" />

<g:select name="books[0].id"
          from="${Book.list()}"
          value="${author?.books[0]?.id}"
          noSelection="['null': '']"/>

<g:select name="images[cover].id"
          from="${Image.list()}"
          value="${book?.images[cover]?.id}"
          noSelection="['null': '']"/>

// grails-app/conf/Config.groovy
// the default value is 256
grails.databinding.autoGrowCollectionLimit = 128
// ...

/book/save?book.title=The%20Stand&author.name=Stephen%20King

def b = new Book(params.book)

def a = new Author(params.author)

class AccountingController {
   // accountNumber will be initialized with the value of params.accountNumber
   // accountType will be initialized with params.accountType
   def displayInvoice(String accountNumber, int accountType) {
       // …
   }
}

/accounting/displayInvoice?accountNumber=B59786&accountType=bogusValue

import grails.web.RequestParameter
class AccountingController {
   // mainAccountNumber will be initialized with the value of params.accountNumber
   // accountType will be initialized with params.accountType
   def displayInvoice(@RequestParameter('accountNumber') String mainAccountNumber, int accountType) {
       // …
   }
}

class Book {
    …
    URL publisherURL
}

/book/save?publisherURL=a-bad-url

def b = new Book(params)
if (b.hasErrors()) {
    println "The value ${b.errors.getFieldError('publisherURL').rejectedValue}" +
            " is not a valid URL!"
}

typeMismatch.java.net.URL=The field {0} is not a valid URL

typeMismatch.Book.publisherURL=The publisher URL you specified is not a valid URL

import org.grails.databinding.BindUsing
class SomeClass {
    @BindUsing({
        obj, source -> source['name']?.toUpperCase()
    })
    String name
}

@BindUsing(SomeClassWhichImplementsBindingHelper)
class SomeClass {
    String someProperty
    Integer someOtherProperty
}

package com.myapp.converters
import org.grails.databinding.converters.ValueConverter
/**
 * A custom converter which will convert String of the
 * form 'city:state' into an Address object.
 */
class AddressValueConverter implements ValueConverter {
    boolean canConvert(value) {
        value instanceof String
    }
    def convert(value) {
        def pieces = value.split(':')
        new com.myapp.Address(city: pieces[0], state: pieces[1])
    }
    Class<?> getTargetType() {
        com.myapp.Address
    }
}

// grails-app/conf/spring/resources.groovy
beans = {
    addressConverter com.myapp.converters.AddressValueConverter
    // ...
}

class Person {
    String firstName
    Address homeAddress
}
class Address {
    String city
    String state
}
def person = new Person()
person.properties = [firstName: 'Jeff', homeAddress: "O'Fallon:Missouri"]
assert person.firstName == 'Jeff'
assert person.homeAddress.city = "O'Fallon"
assert person.homeAddress.state = 'Missouri'

import org.grails.databinding.BindingFormat
class Person {
    @BindingFormat('MMddyyyy')
    Date birthDate
}

// grails-app/conf/Config.groovy
grails.databinding.dateFormats = ['MMddyyyy', 'yyyy-MM-dd HH:mm:ss.S', "yyyy-MM-dd'T'hh:mm:ss'Z'"]

package com.myapp.converters
import org.grails.databinding.converters.FormattedValueConverter
class FormattedStringValueConverter implements FormattedValueConverter {
    def convert(value, String format) {
        if('UPPERCASE' == format) {
            value = value.toUpperCase()
        } else if('LOWERCASE' == format) {
            value = value.toLowerCase()
        }
        value
    }
    Class getTargetType() {
        // specifies the type to which this converter may be applied
        String
    }
}

// grails-app/conf/spring/resources.groovy
beans = {
    formattedStringConverter com.myapp.converters.FormattedStringValueConverter
    // ...
}

import org.grails.databinding.BindingFormat
class Person {
    @BindingFormat('UPPERCASE')
    String someUpperCaseString
    @BindingFormat('LOWERCASE')
    String someLowerCaseString
    String someOtherString
}

import org.grails.databinding.BindingFormat
class Person {
    @BindingFormat(code='date.formats.birthdays')
    Date birthDate
}

# grails-app/conf/i18n/messages.properties
date.formats.birthdays=MMddyyyy

# grails-app/conf/i18n/messages_es.properties
date.formats.birthdays=ddMMyyyy

// src/groovy/bindingdemo/Widget.groovy
package bindingdemo
class Widget {
    String name
    Integer size
}

// grails-app/services/bindingdemo/WidgetService.groovy
package bindingdemo
class WidgetService {
    def updateWidget(Widget widget, Map data) {
        // this will throw an exception because
        // properties is read-only
        widget.properties = data
    }
}

// grails-app/services/bindingdmeo/WidgetService
package bindingdemo
import org.grails.databinding.SimpleMapDataBindingSource
class WidgetService {
    // this bean will be autowired into the service
    def grailsWebDataBinder
    def updateWidget(Widget widget, Map data) {
        grailsWebDataBinder.bind widget, data as SimpleMapDataBindingSource
    }
}

def p = Person.get(1)
p.properties['firstName','lastName'] = params

def p = new Person()
bindData(p, params)

def p = new Person()
bindData(p, params, [exclude: 'dateOfBirth'])

def p = new Person()
bindData(p, params, [include: ['firstName', 'lastName']])

def list() {
    def results = Book.list()
    render(contentType: "text/xml") {
        books {
            for (b in results) {
                book(title: b.title)
            }
        }
    }
}

<books>
    <book title="The Stand" />
    <book title="The Shining" />
</books>

def list() {
    def books = Book.list()  // naming conflict here
    render(contentType: "text/xml") {
        books {
            for (b in results) {
                book(title: b.title)
            }
        }
    }
}

def list() {
    def results = Book.list()
    render(contentType: "application/json") {
        books = array {
            for (b in results) {
                book title: b.title
            }
        }
    }
}

[
    {"title":"The Stand"},
    {"title":"The Shining"}
]

import grails.converters.*

render Book.list() as XML

<?xml version="1.0" encoding="ISO-8859-1"?>
<list>
  <book id="1">
    <author>Stephen King</author>
    <title>The Stand</title>
  </book>
  <book id="2">
    <author>Stephen King</author>
    <title>The Shining</title>
  </book>
</list>

def xml = Book.list().encodeAsXML()
render xml

render Book.list() as JSON

[
    {"id":1,
     "class":"Book",
     "author":"Stephen King",
     "title":"The Stand"},
    {"id":2,
     "class":"Book",
     "author":"Stephen King",
     "releaseDate":new Date(1194127343161),
     "title":"The Shining"}
 ]

grails.json.legacy.builder = false

render(contentType: "application/json") {
    hello = "world"
}

{"hello":"world"}

render(contentType: "application/json") {
    categories = ['a', 'b', 'c']
}

{"categories":["a","b","c"]}

render(contentType: "application/json") {
    categories = [ { a = "A" }, { b = "B" } ]
}

{"categories":[ {"a":"A"} , {"b":"B"}] }

render(contentType: "application/json") {
    element 1
    element 2
    element 3
}

[1,2,3]

render(contentType: "application/json") {
    categories = ['a', 'b', 'c']
    title = "Hello JSON"
    information = {
        pages = 10
    }
}

{"categories":["a","b","c"],"title":"Hello JSON","information":{"pages":10}}

render(contentType: "application/json") {
    categories = [ { a = "A" }, { b = "B" } ]
}

def results = Book.list()
render(contentType: "application/json") {
    books = array {
        for (b in results) {
            book title: b.title
        }
    }
}

def builder = new JSONBuilder()
def result = builder.build {
    categories = ['a', 'b', 'c']
    title = "Hello JSON"
    information = {
        pages = 10
    }
}
// prints the JSON text
println result.toString()
def sw = new StringWriter()
result.render sw

Upload Form: <br />
    <g:uploadForm action="upload">
        <input type="file" name="myFile" />
        <input type="submit" />
    </g:uploadForm>

def upload() {
    def f = request.getFile('myFile')
    if (f.empty) {
        flash.message = 'file cannot be empty'
        render(view: 'uploadForm')
        return
    }
    f.transferTo(new File('/some/local/dir/myfile.txt'))
    response.sendError(200, 'Done')
}

class Image {
    byte[] myFile
    static constraints = {
        // Limit upload file size to 2MB
        myFile maxSize: 1024 * 1024 * 2
    }
}

def img = new Image(params)

class Image {
   String myFile
}

@grails.validation.Validateable
class LoginCommand {
    String username
    String password
    static constraints = {
        username(blank: false, minSize: 6)
        password(blank: false, minSize: 6)
    }
}

class LoginController {
    def login(LoginCommand cmd) {
        if (cmd.hasErrors()) {
            redirect(action: 'loginForm')
            return
        }
        // work with the command object data
    }
}

@grails.validation.Validateable
class LoginCommand {
    def loginService
    String username
    String password
    static constraints = {
        username validator: { val, obj ->
            obj.loginService.canLogin(obj.username, obj.password)
        }
    }
}

// grails-app/controllers/bindingdemo/DemoController.groovy
package bindingdemo
class DemoController {
    def createWidget(Widget w) {
        render "Name: ${w?.name}, Size: ${w?.size}"
    }
}
class Widget {
    String name
    Integer size
}

$ curl -H "Content-Type: application/json" -d '{"name":"Some Widget","size":"42"}' localhost:8080/myapp/demo/createWidget
 Name: Some Widget, Size: 42
~ $
$ curl -H "Content-Type: application/xml" -d '<widget><name>Some Other Widget</name><size>2112</size></widget>' localhost:8080/bodybind/demo/createWidget
 Name: Some Other Widget, Size: 2112
~ $

// grails-app/controllers/bindingdemo/DemoController.groovy
package bindingdemo
class DemoController {
    def createWidget(Widget w) {
        // this will fail because it requires reading the body,
        // which has already been read.
        def json = request.JSON
        // ...
    }
}

<g:form useToken="true" ...>

withForm {
   // good request
}.invalidToken {
   // bad request
}

<g:if test="${flash.invalidToken}">
  Don't click the button twice!
</g:if>

def total = params.int('total')

def total = params.int('total', 42)

for (name in params.list('name')) {
    println name
}

// grails-app/controllers/demo/DemoController.groovy
package demo
class DemoController {
    def someAction() {
        // do some work
    }
    def handleSQLException(SQLException e) {
        render 'A SQLException Was Handled'
    }
    def handleBatchUpdateException(BatchUpdateException e) {
        redirect controller: 'logging', action: 'batchProblem'
    }
    def handleNumberFormatException(NumberFormatException nfe) {
        [problemDescription: 'A Number Was Invalid']
    }
}

// grails-app/controllers/demo/DemoController.groovy
package demo
class DemoController {
    def someAction() {
        try {
            // do some work
        } catch (BatchUpdateException e) {
            return handleBatchUpdateException(e)
        } catch (SQLException e) {
            return handleSQLException(e)
        } catch (NumberFormatException e) {
            return handleNumberFormatException(e)
        }
    }
    def handleSQLException(SQLException e) {
        render 'A SQLException Was Handled'
    }
    def handleBatchUpdateException(BatchUpdateException e) {
        redirect controller: 'logging', action: 'batchProblem'
    }
    def handleNumberFormatException(NumberFormatException nfe) {
        [problemDescription: 'A Number Was Invalid']
    }
}

render(view: "index")

def show() {
    [book: Book.get(params.id)]
}

${book.title}

<html>
   <body>
     <% out << "Hello GSP!" %>
   </body>
</html>

<html>
   <body>
     <%="Hello GSP!" %>
   </body>
</html>

<html>
   <body>
     <%-- This is my comment --%>
     <%="Hello GSP!" %>
   </body>
</html>

<% now = new Date() %>

<%=now%>

<html>
   <body>
      <% [1,2,3,4].each { num -> %>
         <p><%="Hello ${num}!" %></p>
      <%}%>
   </body>
</html>

<html>
   <body>
      <% if (params.hello == 'true')%>
      <%="Hello!"%>
      <% else %>
      <%="Goodbye!"%>
   </body>
</html>

<%@ page import="java.awt.*" %>

<%@ page contentType="application/json" %>

<html>
  <body>
    Hello ${params.name}
  </body>
</html>

<g:example />

<g:example>
   Hello world
</g:example>

<g:example attr="${new Date()}">
   Hello world
</g:example>

<g:example attr="${new Date()}" attr2="[one:1, two:2, three:3]">
   Hello world
</g:example>

<g:example attr="${new Date()}" attr2="[one:'one', two:'two']">
   Hello world
</g:example>

<g:set var="now" value="${new Date()}" />

<g:set var="myHTML">
   Some re-usable code on: ${new Date()}
</g:set>

<g:set var="bookService" bean="bookService" />

<g:set var="now" value="${new Date()}" scope="request" />

<g:if test="${session.role == 'admin'}">
   <%-- show administrative functions --%>
</g:if>
<g:else>
   <%-- show basic functions --%>
</g:else>

<g:each in="${[1,2,3]}" var="num">
   <p>Number ${num}</p>
</g:each>
<g:set var="num" value="${1}" />
<g:while test="${num < 5 }">
    <p>Number ${num++}</p>
</g:while>

Stephen King's Books:
<g:findAll in="${books}" expr="it.author == 'Stephen King'">
     <p>Title: ${it.title}</p>
</g:findAll>

<g:grep in="${books}" filter="NonFictionBooks.class">
     <p>Title: ${it.title}</p>
</g:grep>

<g:grep in="${books.title}" filter="~/.*?Groovy.*?/">
     <p>Title: ${it}</p>
</g:grep>

<g:link action="show" id="1">Book 1</g:link>
<g:link action="show" id="${currentBook.id}">${currentBook.name}</g:link>
<g:link controller="book">Book Home</g:link>
<g:link controller="book" action="list">Book List</g:link>
<g:link url="[action: 'list', controller: 'book']">Book List</g:link>
<g:link params="[sort: 'title', order: 'asc', author: currentBook.author]"
        action="list">Book List</g:link>

<g:form name="myForm" url="[controller:'book',action:'list']">...</g:form>

<g:textField name="myField" value="${myValue}" />

<g:actionSubmit value="Some update label" action="update" />

Static Resource: ${createLinkTo(dir: "images", file: "logo.jpg")}

<img src="${createLinkTo(dir: 'images', file: 'logo.jpg')}" />

<img src="<g:createLinkTo dir="images" file="logo.jpg" />" />

def imageLocation = createLinkTo(dir:"images", file:"logo.jpg").toString()

def imageLocation = g.createLinkTo(dir:"images", file:"logo.jpg").toString()

def editor = fckeditor.editor(name: "text", width: "100%", height: "400")

<div class="book" id="${book?.id}">
   <div>Title: ${book?.title}</div>
   <div>Author: ${book?.author?.name}</div>
</div>

<g:render template="bookTemplate" model="[book: myBook]" />

<g:render template="bookTemplate" var="book" collection="${bookList}" />

<g:render template="/shared/mySharedTemplate" />

<g:render template="/book/bookTemplate" model="[book: myBook]" />

<g:render template="bookTemplate" model="[book:myBook]" />

<tmpl:bookTemplate book="${myBook}" />

def bookData() {
    def b = Book.get(params.id)
    render(template:"bookTemplate", model:[book:b])
}

def bookData() {
    def b = Book.get(params.id)
    String content = g.render(template:"bookTemplate", model:[book:b])
    render content
}

<html>
    <head>
        <title><g:layoutTitle default="An example decorator" /></title>
        <g:layoutHead />
    </head>
    <body onload="${pageProperty(name:'body.onload')}">
        <div class="menu"><!--my common menu goes here--></menu>
            <div class="body">
                <g:layoutBody />
            </div>
        </div>
    </body>
</html>

<html>
    <head>
        <title>An Example Page</title>
        <meta name="layout" content="main" />
    </head>
    <body>This is my content!</body>
</html>

<html>
    <head>
        <title>An Example Page</title>
    </head>
    <body onload="">
        <div class="menu"><!--my common menu goes here--></div>
        <div class="body">
            This is my content!
        </div>
    </body>
</html>

class BookController {
    static layout = 'customer'
    def list() { … }
}

class BookController {
    static layout = 'custom/customer'
    def list() { … }
}

class BookController {
    def list() { … }
}

grails.sitemesh.default.layout = 'myLayoutName'

<g:applyLayout name="myLayout" template="bookTemplate" collection="${books}" />
<g:applyLayout name="myLayout" url="http://www.google.com" />
<g:applyLayout name="myLayout">
The content to apply a layout to
</g:applyLayout>

<g:include controller="book" action="list" />

<g:applyLayout name="myLayout">
   <g:include controller="book" action="list" />
</g:applyLayout>

def content = include(controller:"book", action:"list")

<html>
   <head>
      <r:require module="jquery"/>
      <r:layoutResources/>
   </head>
   <body>
      …
      <r:layoutResources/>
   </body>
</html>

<html>
   <head>
      <r:require modules="jquery, main, blueprint, charting"/>
      <r:layoutResources/>
   </head>
   <body>
      …
      <r:layoutResources/>
   </body>
</html>

<html>
   <head>
      <g:layoutTitle/>
      <r:layoutResources/>
   </head>
   <body>
      <g:layoutBody/>
      <r:layoutResources/>
   </body>
</html>

<html>
   <head>
      <g:layoutTitle/>
      <r:layoutResources/>
   </head>
   <body>
      <g:layoutBody/>
      <r:layoutResources/>
   </body>
</html>

<html>
   <head>
      <title>Testing r:script magic!</title>
   </head>
   <body>
      <r:script disposition="head">
         window.alert('This is at the end of <head>');
      </r:script>
      <r:script disposition="defer">
         window.alert('This is at the end of the body, and the page has loaded.');
      </r:script>
   </body>
</html>

<html>
   <head>
      <title>Testing r:img</title>
   </head>
   <body>
      <r:img uri="/images/logo.png"/>
   </body>
</html>

modules = {
    core {
        dependsOn 'jquery, utils'
        resource url: '/js/core.js', disposition: 'head'
        resource url: '/js/ui.js'
        resource url: '/css/main.css',
        resource url: '/css/branding.css'
        resource url: '/css/print.css', attrs: [media: 'print']
    }
    utils {
        dependsOn 'jquery'
        resource url: '/js/utils.js'
    }
    forms {
        dependsOn 'core,utils'
        resource url: '/css/forms.css'
        resource url: '/js/forms.js'
    }
}

modules = {
    core {
        dependsOn 'jquery, utils'
        defaultBundle 'monolith'
        resource url: '/js/core.js', disposition: 'head'
        resource url: '/js/ui.js'
        resource url: '/css/main.css',
        resource url: '/css/branding.css'
        resource url: '/css/print.css', attrs: [media: 'print']
    }
    utils {
        dependsOn 'jquery'
        defaultBundle 'monolith'
        resource url: '/js/utils.js'
    }
    forms {
        dependsOn 'core,utils'
        defaultBundle 'monolith'
        resource url: '/css/forms.css'
        resource url: '/js/forms.js'
    }
    overrides {
        jquery {
            defaultBundle 'monolith'
        }
    }
}

modules = {
    core {
        dependsOn 'jquery, utils'
        defaultBundle 'common'
        resource url: '/js/core.js', disposition: 'head'
        resource url: '/js/ui.js', bundle: 'ui'
        resource url: '/css/main.css', bundle: 'theme'
        resource url: '/css/branding.css'
        resource url: '/css/print.css', attrs: [media: 'print']
    }
    utils {
        dependsOn 'jquery'
        resource url: '/js/utils.js', bundle: 'common'
    }
    forms {
        dependsOn 'core,utils'
        resource url: '/css/forms.css', bundle: 'ui'
        resource url: '/js/forms.js', bundle: 'ui'
    }
}

grails.resources.debug = true

modules = {
    forms {
        resource url: '/css/forms.css', nohashandcache: true
        resource url: '/js/forms.js', nohashandcache: true
    }
}

// We wouldn't link to .exe files using Resources but for the sake of example:
grails.resources.zip.excludes = ['**/*.zip', '**/*.exe']
// Perhaps for some reason we want to prevent bundling on "less" CSS files:
grails.resources.bundle.excludes = ['**/*.less']

grails.resources.adhoc.patterns = ['images/*', '*.js', '*.css']

<content tag="navbar">
… ここにナビゲーションバーコンテンツ…
</content>
<content tag="header">
… ここにヘッダーコンテンツ…
</content>
<content tag="footer">
… ここにフッターコンテンツ…
</content>
<content tag="body">
… ここにボディコンテンツ…
</content>

<html>
    <body>
        <div id="header">
            <g:applyLayout name="headerLayout">
                <g:pageProperty name="page.header" />
            </g:applyLayout>
        </div>
        <div id="nav">
            <g:applyLayout name="navLayout">
                <g:pageProperty name="page.navbar" />
            </g:applyLayout>
        </div>
        <div id="body">
            <g:applyLayout name="bodyLayout">
                <g:pageProperty name="page.body" />
            </g:applyLayout>
        </div>
        <div id="footer">
            <g:applyLayout name="footerLayout">
                <g:pageProperty name="page.footer" />
            </g:applyLayout>
        </div>
    </body>
</html>

grails.gsp.enable.reload = true
grails.gsp.view.dir = "/var/www/grails/my-app/"

mkdir -p /var/www/grails/my-app/grails-app/views
cp -R grails-app/views/* /var/www/grails/my-app/grails-app/views

<!-- GSP #2 START template: /home/.../views/_carousel.gsp
     precompiled: false lastmodified: … -->
.
.
.
<!-- GSP #2 END template: /home/.../views/_carousel.gsp
     rendering time: 115 ms -->

class SimpleTagLib {
}

class SimpleTagLib {
    def simple = { attrs, body ->
    }
}

class SimpleTagLib {
    def emoticon = { attrs, body ->
       out << body() << (attrs.happy == 'true' ? " :-)" : " :-(")
    }
}

<g:emoticon happy="true">Hi John</g:emoticon>

def dateFormat = { attrs, body ->
    out << new java.text.SimpleDateFormat(attrs.format).format(attrs.date)
}

<g:dateFormat format="dd-MM-yyyy" date="${new Date()}" />

def formatBook = { attrs, body ->
    out << "<div id="${attrs.book.id}">"
    out << "Title : ${attrs.book.title}"
    out << "</div>"
}

def formatBook = { attrs, body ->
    out << render(template: "bookTemplate", model: [book: attrs.book])
}

def isAdmin = { attrs, body ->
    def user = attrs.user
    if (user && checkUserPrivs(user)) {
        out << body()
    }
}

<g:isAdmin user="${myUser}">
    // some restricted content
</g:isAdmin>

def repeat = { attrs, body ->
    attrs.times?.toInteger()?.times { num ->
        out << body(num)
    }
}

<g:repeat times="3">
<p>Repeat this 3 times! Current repeat = ${it}</p>
</g:repeat>

out << body(num)

def repeat = { attrs, body ->
    def var = attrs.var ?: "num"
    attrs.times?.toInteger()?.times { num ->
        out << body((var):num)
    }
}

out << body((var):num)

<g:repeat times="3" var="j">
<p>Repeat this 3 times! Current repeat = ${j}</p>
</g:repeat>

class SimpleTagLib {
    static namespace = "my"
    def example = { attrs ->
        …
    }
}

<my:example name="..." />

out << my.example(name:"foo")

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<fmt:formatNumber value="${10}" pattern=".00"/>

${fmt.formatNumber(value:10, pattern:".00")}

class ObjectReturningTagLib {
    static namespace = "cms"
    static returnObjectForTags = ['content']
    def content = { attrs, body ->
        CmsContent.findByCode(attrs.code)?.content
    }
}

class UrlMappings {
    static mappings = {
    }
}

"/product"(controller: "product", action: "list")

"/product"(controller: "product")

"/product" {
    controller = "product"
    action = "list"
}

group "/product", {
    "/apple"(controller:"product", id:"apple")
    "/htc"(controller:"product", id:"htc")
}

"/hello"(uri: "/hello.dispatch")

"/books"(resources:'book')

"/books"(resources:'book', excludes:['delete', 'update'])
or
"/books"(resources:'book', includse:['index', 'show'])

"/book"(resource:'book')

"/books"(resources:'book') {
  "/authors"(resources:"author")
}

"/books"(resources: "book") {
    "/publisher"(controller:"publisher")
}

<g:link controller="book" action="index">My Link</g:link>

<g:link resource="${book}">My Link</g:link>

"/books"(resources:'book') {
  "/authors"(resources:"author")
}

// Results in /books/1/authors/2
<g:link controller="author" action="show" method="GET" params="[bookId:1]" id="2">The Author</g:link>

// Results in /books/1/authors/2
<g:link resource="book/author" action="show" bookId="1" id="2">My Link</g:link>

"/viewBooks"(redirect: '/books/list')
"/viewAuthors"(redirect: [controller: 'author', action: 'list'])
"/viewPublishers"(redirect: [controller: 'publisher', action: 'list', permanent: true])

static mappings = {
  "/product/$id"(controller: "product")
}

class ProductController {
     def index() { render params.id }
}

static mappings = {
   "/$blog/$year/$month/$day/$id"(controller: "blog", action: "show")
}

/graemerocher/2007/01/10/my_funky_blog_entry

static mappings = {
    "/$controller/$action?/$id?"()
}

static mappings = {
    "/$controller" {
        action = { params.goHere }
    }
}

static mappings = {
    "/$blog/$year?/$month?/$day?/$id?"(controller:"blog", action:"show")
}

"/$controller/$action?/$id?(.$format)?"()

def index() {
    render "extension is ${response.format}"
}

"/holiday/win" {
     id = "Marrakech"
     year = 2007
}

"/holiday/win" {
     id = { params.id }
     isEligible = { session.user != null } // must be logged in
}

static mappings = {
    "/"(view: "/index")  // map the root URL
}

static mappings = {
   "/help"(controller: "site", view: "help") // to a view for a controller
}

static mappings = {
   "403"(controller: "errors", action: "forbidden")
   "404"(controller: "errors", action: "notFound")
   "500"(controller: "errors", action: "serverError")
}

static mappings = {
   "403"(view: "/errors/forbidden")
   "404"(view: "/errors/notFound")
   "500"(view: "/errors/serverError")
}

static mappings = {
   "403"(view: "/errors/forbidden")
   "404"(view: "/errors/notFound")
   "500"(controller: "errors", action: "illegalArgument",
         exception: IllegalArgumentException)
   "500"(controller: "errors", action: "nullPointer",
         exception: NullPointerException)
   "500"(controller: "errors", action: "customException",
         exception: MyException)
   "500"(view: "/errors/serverError")
}

class ErrorController {
    def handleError() {
        def exception = request.exception
        // perform desired processing to handle the exception
    }
}

static mappings = {
   "/product/$id"(controller:"product") {
       action = [GET:"show", PUT:"update", DELETE:"delete", POST:"save"]
   }
}

static mappings = {
    "/images/*.jpg"(controller: "image")
}

static mappings = {
    "/images/$name.jpg"(controller: "image")
}

static mappings = {
    "/images/**.jpg"(controller: "image")
}

static mappings = {
    // will match /image/logo.jpg and /image/other/logo.jpg
    "/images/$name**.jpg"(controller: "image")
}

def name = params.name
println name // prints "logo" or "other/logo"

class UrlMappings {
    static excludes = ["/images/*", "/css/*"]
    static mappings = {
        …
    }
}

static mappings = {
   "/$blog/$year?/$month?/$day?/$id?"(controller:"blog", action:"show")
}

<g:link controller="blog" action="show"
        params="[blog:'fred', year:2007]">
    My Blog
</g:link>
<g:link controller="blog" action="show"
        params="[blog:'fred', year:2007, month:10]">
    My Blog - October 2007 Posts
</g:link>

<a href="/fred/2007">My Blog</a>
<a href="/fred/2007/10">My Blog - October 2007 Posts</a>

static mappings = {
   "/$blog/$year?/$month?/$day?/$id?"(controller:"blog", action:"show")
}

/graemerocher/2007/01/10/my_funky_blog_entry

/graemerocher/not_a_year/not_a_month/not_a_day/my_funky_blog_entry

"/$blog/$year?/$month?/$day?/$id?" {
     controller = "blog"
     action = "show"
     constraints {
          year(matches:/\d{4}/)
          month(matches:/\d{2}/)
          day(matches:/\d{2}/)
     }
}

static mappings = {
   name <mapping name>: <url pattern> {
      // …
   }
}

static mappings = {
    name personList: "/showPeople" {
        controller = 'person'
        action = 'list'
    }
    name accountDetails: "/details/$acctNumber" {
        controller = 'product'
        action = 'accountDetails'
    }
}

<g:link mapping="personList">List People</g:link>

<a href="/showPeople">List People</a>

<g:link mapping="accountDetails" params="[acctNumber:'8675309']">
    Show Account
</g:link>

<a href="/details/8675309">Show Account</a>

<link:personList>List People</link:personList>

<a href="/showPeople">List People</a>

<link:accountDetails acctNumber="8675309">Show Account</link:accountDetails>

<a href="/details/8675309">Show Account</a>

<link:accountDetails attrs="[class: 'fancy']" acctNumber="8675309">
    Show Account
</link:accountDetails>

<a href="/details/8675309" class="fancy">Show Account</a>

// grails-app/conf/Config.groovy
grails.web.url.converter = 'hyphenated'

// src/groovy/com/myapplication/MyUrlConverterImpl.groovy
package com.myapplication
class MyUrlConverterImpl implements grails.web.UrlConverter {
    String toUrlElement(String propertyOrClassName) {
        // URLで描写するプロパティ名またはクラス名を返す
    }
}

// grails-app/conf/spring/resources.groovy
beans = {
    "${grails.web.UrlConverter.BEAN_NAME}"(com.myapplication.MyUrlConverterImpl)
}

// grails-app/controllers/com/app/reporting/AdminController.groovy
package com.app.reporting
class AdminController {
    static namespace = 'reports'
    // …
}

// grails-app/controllers/com/app/security/AdminController.groovy
package com.app.security
class AdminController {
    static namespace = 'users'
    // …
}

// grails-app/conf/UrlMappings.groovy
class UrlMappings {
    static mappings = {
        '/userAdmin' {
            controller = 'admin'
            namespace = 'users'
        }
        '/reportAdmin' {
            controller = 'admin'
            namespace = 'reports'
        }
        "/$namespace/$controller/$action?"()
    }
}

<g:link controller="admin" namespace="reports">Click For Report Admin</g:link>
<g:link controller="admin" namespace="users">Click For User Admin</g:link>

static mappings = {
    "/accountingReports" {
        controller = "reporting"
    }
    "/humanResourceReports" {
        controller = "reporting"
        plugin = "humanResources"
    }
}

static mappings = {
    "/humanResourceReports" {
        controller = "reporting"
    }
}

class BookController {
   def index() {
      redirect(action: "shoppingCart")
   }
   def shoppingCartFlow = {
        …
   }
}

class BookController {
   …
   def shoppingCartFlow ={
       showCart {
           on("checkout").to "enterPersonalDetails"
           on("continueShopping").to "displayCatalogue"
       }
       …
       displayCatalogue {
           redirect(controller: "catalogue", action: "show")
       }
       displayInvoice()
   }
}

enterPersonalDetails {
   on("submit").to "enterShipping"
   on("return").to "showCart"
}

enterPersonalDetails {
   render(view: "enterDetailsView")
   on("submit").to "enterShipping"
   on("return").to "showCart"
}

enterPersonalDetails {
   render(view: "/shared/enterDetailsView")
   on("submit").to "enterShipping"
   on("return").to "showCart"
}

listBooks {
   action {
      [bookList: Book.list()]
   }
   on("success").to "showCatalogue"
   on(Exception).to "handleError"
}

on(Exception).to "handleError"

processPurchaseOrder {
    action {
        def a =  flow.address
        def p = flow.person
        def pd = flow.paymentDetails
        def cartItems = flow.cartItems
        flow.clear()
        def o = new Order(person: p, shippingAddress: a, paymentDetails: pd)
        o.invoiceNumber = new Random().nextInt(9999999)
        for (item in cartItems) { o.addToItems item }
        o.save()
        [order: o]
    }
    on("error").to "confirmPurchase"
    on(Exception).to "confirmPurchase"
    on("success").to "displayInvoice"
}

enterPersonalDetails {
   on("submit") {
       log.trace "Going to enter shipping"
   }.to "enterShipping"
   on("return").to "showCart"
}

def shoppingCartFlow = {
    showCart {
        on("checkout").to "enterPersonalDetails"
        on("continueShopping").to "displayCatalogue"
    }
    …
}

<g:form>
    <g:submitButton name="continueShopping" value="Continue Shopping" />
    <g:submitButton name="checkout" value="Checkout" />
</g:form>

<g:link event="checkout" />

enterPersonalDetails {
   on("submit") {
         def p = new Person(params)
         flow.person = p
         if (!p.validate()) return error()
   }.to "enterShipping"
   on("return").to "showCart"
}

shippingNeeded {
   action {
       if (params.shippingRequired) yes()
       else no()
   }
   on("yes").to "enterShipping"
   on("no").to "enterPayment"
}

enterPersonalDetails {
    on("submit") {
        [person: new Person(params)]
    }.to "enterShipping"
   on("return").to "showCart"
}

class Book {
    String title
}

class Book implements Serializable {
    String title
}

class Book implements Serializable {
    String title
    Author author
}

class Book implements Serializable {
    String title
    def onLoad = {
        println "I'm loading"
    }
}

class Book implements Serializable {
    String title
    transient onLoad = {
        println "I'm loading"
    }
}

class Book implements Serializable {
    String title
    def onLoad() {
        println "I'm loading"
    }
}

enterPersonalDetails {
   on("submit").to "enterShipping"
   on("return").to "showCart"
}

<g:form>
    <!-- Other fields -->
    <g:submitButton name="submit" value="Continue"></g:submitButton>
    <g:submitButton name="return" value="Back"></g:submitButton>
</g:form>

enterPersonalDetails {
   on("submit") {
      flow.person = new Person(params)
      !flow.person.validate() ? error() : success()
   }.to "enterShipping"
   on("return").to "showCart"
}

enterPersonalDetails {
   on("submit") { PersonDetailsCommand cmd ->
       flow.personDetails = cmd
      !flow.personDetails.validate() ? error() : success()
   }.to "enterShipping"
   on("return").to "showCart"
}

def searchFlow = {
    displaySearchForm {
        on("submit").to "executeSearch"
    }
    executeSearch {
        action {
            [results:searchService.executeSearch(params.q)]
        }
        on("success").to "displayResults"
        on("error").to "displaySearchForm"
    }
    displayResults {
        on("searchDeeper").to "extendedSearch"
        on("searchAgain").to "displaySearchForm"
    }
    extendedSearch {
        // Extended search subflow
        subflow(controller: "searchExtensions", action: "extendedSearch")
        on("moreResults").to "displayMoreResults"
        on("noResults").to "displayNoMoreResults"
    }
    displayMoreResults()
    displayNoMoreResults()
}

def extendedSearchFlow = {
    startExtendedSearch {
        on("findMore").to "searchMore"
        on("searchAgain").to "noResults"
    }
    searchMore {
        action {
           def results = searchService.deepSearch(ctx.conversation.query)
           if (!results) return error()
           conversation.extendedResults = results
        }
        on("success").to "moreResults"
        on("error").to "noResults"
    }
    moreResults()
    noResults()
}

extendedSearch {
    // Extended search subflow
    subflow(controller: "searchExtensions", action: "extendedSearch")
    on("moreResults").to "displayMoreResults"
    on("noResults").to "displayNoMoreResults"
}

def searchFlow = {
        input {
            expertise(required: true)
            title("Search person")
        }
        search {
            onEntry {
                [personInstanceList: Person.findAllByExpertise(flow.expertise)]
            }
            on("select") {
                flow.person = Person.get(params.id)
            }.to("selected")
            on("cancel").to("cancel")
        }
        selected {
            output {
                person {flow.person}
            }
        }
        cancel()
    }
}

def newProjectWizardFlow = {
    ...
    managerSearch {
        subflow(controller: "person", action: "search",
                input: [expertise : "management", title: "Search project manager"])
        on("selected") {
            flow.projectInstance.manager = currentEvent.attributes.person
        }.to "techleadSearch"
    }
    techleadSearch {
        subflow(controller: "person", action: "search",
                input: [expertise : { flow.technology }, title: "Search technical lead"])
        on("selected") {
            flow.projectInstance.techlead = currentEvent.attributes.person
        }.to "projectDetails"
    }
    ...
}

class ExampleFilters {
   def filters = {
        // your filters here
   }
}

sampleFilter(controller:'*', action:'*') {
  // interceptor definitions
}

all(controller: '*', action: '*') {
}

justBook(controller: 'book', action: '*') {
}

notBook(controller: 'book', invert: true) {
}

saveInActionName(action: '*save*', find: true) {
}

actionBeginningWithBButNotBad(action: 'b*', actionExclude: 'bad*', find: true) {
}

someURIs(uri: '/book/**') {
}

allURIs(uri: '/**') {
}

class SecurityFilters {
   def filters = {
       loginCheck(controller: '*', action: '*') {
           before = {
              if (!session.user && !actionName.equals('login')) {
                  redirect(action: 'login')
                  return false
               }
           }
       }
   }
}

import java.util.concurrent.atomic.AtomicLong
class LoggingFilters {
   private static final AtomicLong REQUEST_NUMBER_COUNTER = new AtomicLong()
   private static final String START_TIME_ATTRIBUTE = 'Controller__START_TIME__'
   private static final String REQUEST_NUMBER_ATTRIBUTE = 'Controller__REQUEST_NUMBER__'
   def filters = {
      logFilter(controller: '*', action: '*') {
         before = {
            if (!log.debugEnabled) return true
            long start = System.currentTimeMillis()
            long currentRequestNumber = REQUEST_NUMBER_COUNTER.incrementAndGet()
            request[START_TIME_ATTRIBUTE] = start
            request[REQUEST_NUMBER_ATTRIBUTE] = currentRequestNumber
            log.debug "preHandle request #$currentRequestNumber : " +
               "'$request.servletPath'/'$request.forwardURI', " +
               "from $request.remoteHost ($request.remoteAddr) " +
               " at ${new Date()}, Ajax: $request.xhr, controller: $controllerName, " +
               "action: $actionName, params: ${new TreeMap(params)}"
            return true
         }
         after = { Map model ->
            if (!log.debugEnabled) return true
            long start = request[START_TIME_ATTRIBUTE]
            long end = System.currentTimeMillis()
            long requestNumber = request[REQUEST_NUMBER_ATTRIBUTE]
            def msg = "postHandle request #$requestNumber: end ${new Date()}, " +
                      "controller total time ${end - start}ms"
            if (log.traceEnabled) {
            	log.trace msg + "; model: $model"
            }
            else {
            	log.debug msg
            }
         }
         afterView = { Exception e ->
            if (!log.debugEnabled) return true
            long start = request[START_TIME_ATTRIBUTE]
            long end = System.currentTimeMillis()
            long requestNumber = request[REQUEST_NUMBER_ATTRIBUTE]
            def msg = "afterCompletion request #$requestNumber: " +
                      "end ${new Date()}, total time ${end - start}ms"
            if (e) {
               log.debug "$msg \n\texception: $e.message", e
            }
            else {
               log.debug msg
            }
         }
      }
   }
}

class MyFilters {
    def dependsOn = [MyOtherFilters]
    def filters = {
        checkAwesome(uri: "/*") {
            before = {
                if (request.isAwesome) { // do something awesome }
            }
        }
        checkAwesome2(uri: "/*") {
            before = {
                if (request.isAwesome) { // do something else awesome }
            }
        }
    }
}

class MyOtherFilters {
    def filters = {
        makeAwesome(uri: "/*") {
            before = {
                request.isAwesome = true
            }
        }
        doNothing(uri: "/*") {
            before = {
                // do nothing
            }
        }
    }
}

<g:javascript library="jquery" />

<g:remoteLink action="delete" id="1">Delete Book</g:remoteLink>

def delete() {
    def b = Book.get(params.id)
    b.delete()
    render "Book ${b.id} was deleted"
}

<div id="message"></div>
<g:remoteLink action="delete" id="1" update="message">
Delete Book
</g:remoteLink>

<div id="message"></div>
<div id="error"></div>
<g:remoteLink update="[success: 'message', failure: 'error']"
              action="delete" id="1">
Delete Book
</g:remoteLink>

<g:formRemote url="[controller: 'book', action: 'delete']"
              update="[success: 'message', failure: 'error']">
    <input type="hidden" name="id" value="1" />
    <input type="submit" value="Delete Book!" />
</g:formRemote >

<form action="delete">
    <input type="hidden" name="id" value="1" />
    <g:submitToRemote action="delete"
                      update="[success: 'message', failure: 'error']" />
</form>

<g:remoteLink action="show"
              id="1"
              update="success"
              onLoading="showProgress()"
              onComplete="hideProgress()">Show Book 1</g:remoteLink>

<g:javascript>
    function fireMe(event) {
        alert("XmlHttpRequest = " + event)
    }
}
</g:javascript>
<g:remoteLink action="example"
              update="success"
              onFailure="fireMe(XMLHttpRequest)">Ajax Link</g:remoteLink>

runtime ":prototype:latest.release"

<g:javascript library="prototype" />

<g:javascript library="scriptaculous" />

compile ":dojo:latest.release"

<g:javascript library="dojo" />

def showBook() {
    def b = Book.get(params.id)
    render(template: "bookTemplate", model: [book: b])
}

<g:remoteLink action="showBook" id="${book.id}"
              update="book${book.id}">Update Book</g:remoteLink>
<div id="book${book.id}">
   <!--existing book mark-up -->
</div>

import grails.converters.JSON
def showBook() {
    def b = Book.get(params.id)
    render b as JSON
}

<g:javascript>
function updateBook(data) {
    $("#book" + data.id + "_title").html( data.title );
}
</g:javascript>
<g:remoteLink action="showBook" id="${book.id}" onSuccess="updateBook(data)">
    Update Book
</g:remoteLink>
<g:set var="bookId">book${book.id}</g:set>
<div id="${bookId}">
    <div id="${bookId}_title">The Stand</div>
</div>

import grails.converters.XML
def showBook() {
    def b = Book.get(params.id)
    render b as XML
}

<g:javascript>
function updateBook(data) {
    var id = $(data).find("book").attr("id");
    $("#book" + id + "_title").html( $(data).find("title").text() );
}
<g:javascript>
<g:remoteLink action="test" update="foo" onSuccess="updateBook(e)">
    Update Book
</g:remoteLink>
<g:set var="bookId">book${book.id}</g:set>
<div id="${bookId}">
    <div id="${bookId}_title">The Stand</div>
</div>

def showBook() {
    def b = Book.get(params.id)
    response.contentType = "text/javascript"
    String title = b.title.encodeAsJavaScript()
    render "$('#book${b.id}_title').html('${title}');"
}

def listBooks() {
    def books = Book.list(params)
    if (request.xhr) {
        render template: "bookTable", model: [books: books]
    } else {
        render view: "list", model: [books: books]
    }
}

grails.mime.types = [
    all:           '*/*',
    atom:          'application/atom+xml',
    css:           'text/css',
    csv:           'text/csv',
    form:          'application/x-www-form-urlencoded',
    html:          ['text/html','application/xhtml+xml'],
    js:            'text/javascript',
    json:          ['application/json', 'text/json'],
    multipartForm: 'multipart/form-data',
    rss:           'application/rss+xml',
    text:          'text/plain',
    hal:           ['application/hal+json','application/hal+xml'],
    xml:           ['text/xml', 'application/xml']
]

http://my.domain.org/books?format=xml

import grails.converters.JSON
import grails.converters.XML
class BookController {
    def list() {
        def books = Book.list()
        withFormat {
            html bookList: books
            json { render books as JSON }
            xml { render books as XML }
        }
    }
}

*/*

text/xml, application/xml, application/xhtml+xml, text/html;q=0.9, 
    text/plain;q=0.8, image/png, */*;q=0.5

application/json

grails.mime.disable.accept.header.userAgents = ['Gecko', 'WebKit', 'Presto', 'Trident']

request.withFormat {
    xml {
        // read XML
    }
    json {
        // read JSON
    }
}

/book/list?format=xml

"/book/list"(controller:"book", action:"list") {
    format = "xml"
}

/book/list.xml

"/$controller/$action?/$id?(.${format})?"{

"/$controller/$action?/$id?"{

void testJavascriptOutput() {
    def controller = new TestController()
    controller.request.addHeader "Accept",
              "text/javascript, text/html, application/xml, text/xml, */*"
    controller.testAction()
    assertEquals "alert('hello')", controller.response.contentAsString
}

void testJavascriptOutput() {
    def controller = new TestController()
    controller.params.format = 'js'
    controller.testAction()
    assertEquals "alert('hello')", controller.response.contentAsString
}