Mojolicious::Controller

НАЗВАНИЕ
КРАТКИЙ ОБЗОР
ОПИСАНИЕ
АТРИБУТЫ
МЕТОДЫ
HELPERS
СМ. ТАКЖЕ

НАЗВАНИЕ

Mojolicious::Controller - Controller Base Class

КРАТКИЙ ОБЗОР

  use Mojo::Base 'Mojolicious::Controller';

ОПИСАНИЕ

Mojolicious::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.

АТРИБУТЫ

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 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.

МЕТОДЫ

Mojolicious::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.html.$handler or exception.html.$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.

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 $tx = pop;
    $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 {
      $t->end(pop->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.

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!');

СМ. ТАКЖЕ

Mojolicious, Mojolicious::Guides, http://mojolicio.us.