Linux Certif

Toute la documentation sur la certification Linux LPI

Mojolicious::Controller.3pm

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 MojoX::Dispatcher::Routes::Controller.

METHODS

Mojolicious::Controller inherits all methods from MojoX::Dispatcher::Routes::Controller 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);
     })->process;
 
 

For async processing you can use "pause" and "finish".

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

finish

     $c->finish;
 
 

Similar to "resume" but will also trigger automatic rendering and the "after_dispatch" plugin hook, which would normally get disabled once a request gets paused. For WebSockets it will gracefully end the connection.

finished

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

Callback signaling that the transaction has been finished.

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

helper

     $c->helper('foo');
     $c->helper(foo => 23);
 
 

Directly call a Mojolicious helper, see Mojolicious::Plugin::DefaultHelpers for a list of helpers that are always available.

pause

     $c->pause;
 
 

Pause transaction associated with this request, used for async web applications. Note that automatic rendering and some plugins that do state changing operations inside the "after_dispatch" hook won't work if you pause a transaction.

receive_message

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

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

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

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 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');
     $c->render('foo/bar', {format => 'html'});
 
 

This is a wrapper around MojoX::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 MojoX::Renderer::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 MojoX::Renderer::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');
 
 

Render a static asset using MojoX::Dispatcher::Static.

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.

resume

     $c->resume;
 
 

Resume transaction associated with this request, used for async web applications.

send_message

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

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

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.

SEE ALSO

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