Mojolicious::ControlleUser Contributed Perl DocumentMojolicious::Controller(3)NAMEMojolicious::Controller - Controller Base Class
SYNOPSIS
use Mojo::Base 'Mojolicious::Controller';
DESCRIPTIONMojolicious::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.
ATTRIBUTESMojolicious::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 Mojolicious 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, usually a
Mojo::Transaction::HTTP or Mojo::Transaction::WebSocket object.
METHODSMojolicious::Controller inherits all methods from Mojo::Base and
implements the following new ones.
"cookie"
$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;
$c->finish('Bye!');
Gracefully end WebSocket connection or long poll stream.
"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 to be invoked when the transaction has been finished.
$c->on_finish(sub {
my $c = shift;
});
"on_message"
$c = $c->on_message(sub {...});
Callback to be invoked when new WebSocket messages arrive.
$c->on_message(sub {
my ($c, $message) = @_;
});
"param"
my @names = $c->param;
my $foo = $c->param('foo');
my @foo = $c->param('foo');
$c = $c->param(foo => 'ba;r');
Access GET/POST parameters and route captures that are not reserved
stash values.
# Only GET parameters
my $foo = $c->req->url->query->param('foo');
# Only GET and POST parameters
my $foo = $c->req->param('foo');
"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, takes the exact same arguments as
"url_for".
return $c->redirect_to('login') unless $c->session('user');
"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. It will also run the "before_render" plugin
hook.
"render_content"
my $output = $c->render_content;
my $output = $c->render_content('header');
my $output = $c->render_content(header => 'Hello world!');
my $output = $c->render_content(header => sub { 'Hello world!' });
Contains partial rendered templates, used for the renderers "layout"
and "extends" features.
"render_data"
$c->render_data($bits);
$c->render_data($bits, format => 'png');
Render the given content as raw bytes, similar to "render_text" but
data will not be encoded.
"render_exception"
$c->render_exception('Oops!');
$c->render_exception(Mojo::Exception->new('Oops!'));
Render the exception template "exception.$mode.$format.$handler" or
"exception.$format.$handler" and set the response status code to 500.
"render_json"
$c->render_json({foo => 'bar'});
$c->render_json([1, 2, -3]);
Render a data structure as JSON.
"render_later"
$c->render_later;
Disable auto rendering, especially for long polling this can be quite
useful.
$c->render_later;
Mojo::IOLoop->timer(2 => sub {
$c->render(text => 'Delayed by 2 seconds!');
});
"render_not_found"
$c->render_not_found;
$c->render_not_found($resource);
Render the not found template "not_found.$mode.html.$handler" or
"not_found.html.$handler" and set the response status code to 404.
"render_partial"
my $output = $c->render_partial('menubar');
my $output = $c->render_partial('menubar', format => 'txt');
Same as "render" but returns the rendered result.
"render_static"
my $success = $c->render_static('images/logo.png');
my $success = $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 Perl characters, which will be encoded to
bytes. See "render_data" for an alternative without encoding. Note
that this does not change the content type of the response, which is
"text/html;charset=UTF-8" by default.
$c->render_text('Hello World!', format => 'txt');
"rendered"
$c = $c->rendered;
$c = $c->rendered(302);
Finalize response and run "after_dispatch" plugin hook.
"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.
"respond_to"
$c->respond_to(
json => sub {...},
xml => {text => 'hello!'},
any => sub {...}
);
Automatically select best possible representation for resource from
"Accept" request header, "format" stash value or "format" GET/POST
parameter, defaults to rendering an empty 204 response. Note that this
method is EXPERIMENTAL and might change without warning!
$c->respond_to(
json => sub { $c->render_json({just => 'works'}) },
xml => {text => '<just>works</just>'},
any => {data => '', status => 204}
);
"send_message"
$c = $c->send_message('Hi there!');
$c = $c->send_message('Hi there!', sub {...});
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, defaults to using signed cookies. Note that
cookies are generally limited to 4096 bytes of data.
$c->session->{foo} = 'bar';
my $foo = $c->session->{foo};
delete $c->session->{foo};
"signed_cookie"
$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};
"ua"
my $ua = $c->ua;
A Mojo::UserAgent prepared for the current environment.
# Blocking
my $tx = $c->ua->get('http://mojolicio.us');
my $tx = $c->ua->post_form('http://kraih.com/login' => {user => 'mojo'});
# Non-blocking
$c->ua->get('http://mojolicio.us' => sub {
my ($self, $tx) = @_;
$c->render_data($tx->res->body);
});
# Parallel non-blocking
my $t = Mojo::IOLoop->trigger(sub {
my ($t, @titles) = @_;
$c->render_json(\@titles);
});
for my $url ('http://mojolicio.us', 'https://metacpan.org') {
$t->begin;
$c->ua->get($url => sub {
my ($self, $tx) = @_;
$t->end($tx->res->dom->html->head->title->text);
});
}
"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');
my $url = $c->url_for('/perldoc');
my $url = $c->url_for('http://mojolicio.us/perldoc');
Generate a portable Mojo::URL object with base for a route, path or
URL.
# "/perldoc" if application is deployed under "/"
print $c->url_for('/perldoc');
# "/myapp/perldoc" if application is deployed under "/myapp"
print $c->url_for('/perldoc');
"write"
$c->write;
$c->write('Hello!');
$c->write(sub {...});
$c->write('Hello!', sub {...});
Write dynamic content chunk wise, the optional drain callback will be
invoked once all data has been written to the kernel send buffer or
equivalent.
# Keep connection alive (with Content-Length header)
$c->res->headers->content_length(6);
$c->write('Hel', sub {
my $c = shift;
$c->write('lo!')
});
# Close connection when done (without Content-Length header)
$c->write('Hel', sub {
my $c = shift;
$c->write('lo!', sub {
my $c = shift;
$c->finish;
});
});
"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.
$c->write_chunk('He', sub {
my $c = shift;
$c->write_chunk('ll', sub {
my $c = shift;
$c->finish('o!');
});
});
You can call "finish" at any time to end the stream.
2
He
2
ll
2
o!
0
HELPERS
In addition to the attributes and methods above you can also call
helpers on instances of Mojolicious::Controller. This includes all
helpers from Mojolicious::Plugin::DefaultHelpers and
Mojolicious::Plugin::TagHelpers.
$c->layout('green');
$c->title('Welcome!');
SEE ALSO
Mojolicious, Mojolicious::Guides, <http://mojolicio.us>.
perl v5.14.1 2011-09-11 Mojolicious::Controller(3)
