NAME

Mojolicious::Controller - Controller Base Class

SYNOPSIS

    use base 'Mojolicious::Controller';

DESCRIPTION

Mojolicous::Controller is the base class for your Mojolicious controllers. It is also the default controller class for Mojolicious unless you set controller_class in your application.

ATTRIBUTES

Mojolicious::Controller inherits all attributes from Mojo::Base and implements the following new ones.

app

    my $app = $c->app;
    $c      = $c->app(Mojolicious->new);

A reference back to the application that dispatched to this controller.

match

    my $m = $c->match;

A Mojolicious::Routes::Match object containing the routes results for the current request.

tx

    my $tx = $c->tx;

The transaction that is currently being processed, defaults to a Mojo::Transaction::HTTP object.

METHODS

Mojolicious::Controller inherits all methods from Mojo::Base and implements the following new ones.

client

    my $client = $c->client;
    

A Mojo::Client prepared for the current environment.

    my $tx = $c->client->get('http://mojolicious.org');

    $c->client->post_form('http://kraih.com/login' => {user => 'mojo'});

    $c->client->get('http://mojolicious.org' => sub {
        my $client = shift;
        $c->render_data($client->res->body);
    })->start;

Some environments such as Mojo::Server::Daemon even allow async requests.

    $c->client->async->get('http://mojolicious.org' => sub {
        my $client = shift;
        $c->render_data($client->res->body);
    })->start;
    $c         = $c->cookie(foo => 'bar');
    $c         = $c->cookie(foo => 'bar', {path => '/'});
    my $value  = $c->cookie('foo');
    my @values = $c->cookie('foo');

Access request cookie values and create new response cookies.

finish

    $c->finish;

Gracefully end WebSocket connection.

flash

    my $flash = $c->flash;
    my $foo   = $c->flash('foo');
    $c        = $c->flash({foo => 'bar'});
    $c        = $c->flash(foo => 'bar');

Data storage persistent for the next request, stored in the session.

    $c->flash->{foo} = 'bar';
    my $foo = $c->flash->{foo};
    delete $c->flash->{foo};

on_finish

    $c->on_finish(sub {...});

Callback signaling that the transaction has been finished.

    $c->on_finish(sub {
        my $self = shift;
    });

on_message

    $c = $c->on_message(sub {...});

Receive messages via WebSocket, only works if there is currently a WebSocket connection in progress.

    $c->on_message(sub {
        my ($self, $message) = @_;
    });

param

    my @names = $c->param;
    my $foo   = $c->param('foo');
    my @foo   = $c->param('foo');
    $c        = $c->param(foo => 'ba;r');

Request parameters and routes captures.

redirect_to

    $c = $c->redirect_to('named');
    $c = $c->redirect_to('named', foo => 'bar');
    $c = $c->redirect_to('/path');
    $c = $c->redirect_to('http://127.0.0.1/foo/bar');

Prepare a 302 redirect response.

render

    $c->render;
    $c->render(controller => 'foo', action => 'bar');
    $c->render({controller => 'foo', action => 'bar'});
    $c->render(text => 'Hello!');
    $c->render(template => 'index');
    $c->render(template => 'foo/index');
    $c->render(template => 'index', format => 'html', handler => 'epl');
    $c->render(handler => 'something');
    $c->render('foo/bar');
    $c->render('foo/bar', format => 'html');

This is a wrapper around Mojolicious::Renderer exposing pretty much all functionality provided by it. It will set a default template to use based on the controller and action name or fall back to the route name. You can call it with a hash of options which can be preceded by an optional template name. Note that all render arguments get localized, so stash values won't be changed after the render call.

render_data

    $c->render_data($bits);

Render binary data, similar to render_text but data will not be encoded.

render_exception

    $c->render_exception($e);

Render the exception template exception.html.$handler. Will set the status code to 500 meaning Internal Server Error. Takes a Mojo::Exception object or error message and will fall back to rendering a static 500 page using Mojolicious::Static.

render_inner

    my $output = $c->render_inner;
    my $output = $c->render_inner('content');
    my $output = $c->render_inner(content => 'Hello world!');
    my $output = $c->render_inner(content => sub { 'Hello world!' });

Contains partial rendered templates, used for the renderers layout and extends features.

render_json

    $c->render_json({foo => 'bar'});
    $c->render_json([1, 2, -3]);

Render a data structure as JSON.

render_not_found

    $c->render_not_found;
    $c->render_not_found($resource);
    

Render the not found template not_found.html.$handler. Also sets the response status code to 404, will fall back to rendering a static 404 page using Mojolicious::Static.

render_partial

    my $output = $c->render_partial;
    my $output = $c->render_partial(action => 'foo');
    

Same as render but returns the rendered result.

render_static

    $c->render_static('images/logo.png');
    $c->render_static('../lib/MyApp.pm');

Render a static file using Mojolicious::Static relative to the public directory of your application.

render_text

    $c->render_text('Hello World!');
    $c->render_text('Hello World', layout => 'green');

Render the given content as plain text, note that text will be encoded. See render_data for an alternative without encoding.

rendered

    $c->rendered;

Finalize response and run after_dispatch plugin hook. Note that this method is EXPERIMENTAL and might change without warning!

req

    my $req = $c->req;

Alias for $c-tx->req>. Usually refers to a Mojo::Message::Request object.

res

    my $res = $c->res;

Alias for $c-tx->res>. Usually refers to a Mojo::Message::Response object.

send_message

    $c = $c->send_message('Hi there!');

Send a message via WebSocket, only works if there is currently a WebSocket connection in progress.

session

    my $session = $c->session;
    my $foo     = $c->session('foo');
    $c          = $c->session({foo => 'bar'});
    $c          = $c->session(foo => 'bar');

Persistent data storage, by default stored in a signed cookie. Note that cookies are generally limited to 4096 bytes of data.

    $c->session->{foo} = 'bar';
    my $foo = $c->session->{foo};
    delete $c->session->{foo};
    $c         = $c->signed_cookie(foo => 'bar');
    $c         = $c->signed_cookie(foo => 'bar', {path => '/'});
    my $value  = $c->signed_cookie('foo');
    my @values = $c->signed_cookie('foo');

Access signed request cookie values and create new signed response cookies. Cookies failing signature verification will be automatically discarded.

stash

    my $stash = $c->stash;
    my $foo   = $c->stash('foo');
    $c        = $c->stash({foo => 'bar'});
    $c        = $c->stash(foo => 'bar');

Non persistent data storage and exchange.

    $c->stash->{foo} = 'bar';
    my $foo = $c->stash->{foo};
    delete $c->stash->{foo};

url_for

    my $url = $c->url_for;
    my $url = $c->url_for(controller => 'bar', action => 'baz');
    my $url = $c->url_for('named', controller => 'bar', action => 'baz');

Generate a Mojo::URL for the current or a named route.

write

    $c->write;
    $c->write('Hello!');
    $c->write(sub {...});
    $c->write('Hello!', sub {...});

Write dynamic content matching the corresponding Content-Length header chunk wise, the optional drain callback will be invoked once all data has been written to the kernel send buffer or equivalent.

    $c->res->headers->content_length(6);
    $c->write('Hel');
    $c->write('lo!');

Note that this method is EXPERIMENTAL and might change without warning!

write_chunk

    $c->write_chunk;
    $c->write_chunk('Hello!');
    $c->write_chunk(sub {...});
    $c->write_chunk('Hello!', sub {...});

Write dynamic content chunk wise with the chunked Transfer-Encoding which doesn't require a Content-Length header, the optional drain callback will be invoked once all data has been written to the kernel send buffer or equivalent. Note that this method is EXPERIMENTAL and might change without warning!

    $c->write_chunk('Hel');
    $c->write_chunk('lo!');
    $c->write_chunk('');

An empty chunk marks the end of the stream.

    3
    Hel
    3
    lo!
    0

SEE ALSO

Mojolicious, Mojolicious::Guides, http://mojolicious.org.