## 6.1.4 Redirects and Chaining

#### Redirects

Actions can be redirected using the redirect method present in all controllers:

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

Internally the redirect method uses the HttpServletResonse object's `sendRedirect` method.

The `redirect` method expects either:

- Another closure within the same controller class:

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

- The name of a controller and action:

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

- A URI for a resource relative the application context path:

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

- Or a full URL:

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

Parameters can be optionally passed from one action to the next using the `params` argument of the method:

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

These parameters are made available through the params dynamic property that also accesses request parameters. If a parameter is specified with the same name as a request parameter the request parameter is overridden and the controller parameter used.

Since the `params` object is also a map, you can use it to pass the current request parameters from one action to the next:

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

Finally, you can also include a fragment in the target URI:

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

will (depending on the URL mappings) redirect to something like "/myapp/test/show#profile".

#### Chaining

Actions can also be chained. Chaining allows the model to be retained from one action to the next. For example calling the `first` action in the below action:

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

Results in the model:

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

The model can be accessed in subsequent controller actions in the chain via the `chainModel` map. This dynamic property only exists in actions following the call to the `chain` method:

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

Like the `redirect` method you can also pass parameters to the `chain` method:

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