select results from the CPAN

Ado

=encoding utf8

=head1 NAME

Ado::Control - The base class for all controllers!

=head1 SYNOPSIS

It must be inherited by all controllers. Put code here only to be shared by
it's subclasses or used in hooks.

  package Ado::Control::Hello;
  use Mojo::Base 'Ado::Control';

=head1 ATTRIBUTES

Ado::Control inherits all attributes from L<Mojolicious::Controller>
and implements the following new ones.

=head2 description

Returns a default description used in C<head> element of HTML pages.

=head2 generator

Returns the concatenated moniker, VERSION and L<CODENAME>.

=head2 keywords

Returns default keywords used in C<head> element of HTML pages.

=head1 SUBROUTINES/METHODS

Methods shared among subclasses and in hooks

=head2 config

Overwrites the default helper L<Mojolicious::Plugin::DefaultHelpers/config>
which is actually an alias for L<Mojo/config>. Returns configuration specific
to the I<current controller> package only.

  #in Ado::Control::List or Ado::Control::Foo or...
  my $myvalue = $c->config('mykey');
  #a shortcut to
  my $myvalue = $app->config(__PACKAGE__)->{mykey}
  ...

To access the application-wide configuration use
C<$c-E<gt>app-E<gt>config('key')>.

=head2 debug

A shortcut to:

  $c->app->log->debug(@_);

=head2 list_for_json

Prepares a structure suitable for rendering as JSON for  listing  an ARRAYref
of HASHES or L<Ado::Model>* objects, returned by L<Ado::Model/select_range>
and returns it. Accepts two C<ARRAY> references  and one arbitrary C<HASH>
reference as parameters:

  my $res = $c->list_for_json([$limit, $offset], \@list_of_AMobjects_or_hashes, $meta);

Use this method to ensure uniform and predictable representation across all
listing resources. Use the C<$meta> key for arbitrary metadata, specific to
your resource. See L<http://127.0.0.1:3000/ado-users/list.json> for example
output and L<Ado::Control::Ado::Users/list> for the example source.

  my @range = ($c->param('limit') || 10, $c->param('offset') || 0);
  return $c->respond_to(
    json => $c->list_for_json(\@range, [Ado::Model::Users->select_range(@range)],{foo=>bar})
  );
  Outputs:
  {
    links => [{href=>$url, rel=>'self'},{...}],
    data=>[..],
    query=>{limit=>10, offset=>0},
    meta=> {foo=>'bar'}
  }

  return $c->respond_to(
    json => $c->list_for_json(\@range, [$dbix->query($SQL,@range)->hashes])
  );


=head2 require_formats

Checks for a list of accepted formats or renders "415 - Unsupported Media
Type" with a text/html type and links to the preferred formats, and returns
false. If the URL is in the required format, returns true. Adds a header C
<Content-Location> pointing to the first URL of the required formats.

  #in an action serving only json
  sub list {
    my $c = shift;
    $c->require_formats('json') || return;
    $c->debug('rendering json only');
      #your stuff here...
      return;
  }

This method exists only to show more descriptive message with available
formats to the end user and to give a chance to user agents to go to the
preferred resource URL.

=head2 validate_input

Uses L<Mojolicious::Controller/validation> to validate all input parameters at
once given a validation template. The template consists of keys matching the
input parameters to be validated. The values are HASH references describing
the rules. Each rule name corresponds  to a method/check in
L<Mojolicious::Validator/CHECKS>. You can use your own checks if you add them
using L<Mojolicious::Validator/add_check>.

Returns a HASH reference. In case of errors it contains C<errors> and C<json>
HASH references. In case of success contains only C<output> HASH reference
from  L<Mojolicious::Validator::Validation/output>.

    my $rules = {
        to_uid => {
            'required' => 1, like => qr/^\d{1,20}$/
        },
        subject => {
            'required' => 1, like => qr/^.{1,255}$/
        },
        #...
    }
    my $result = $c->validate_input($rules);

    #400 Bad Request
    return $c->render(
( run in 1.034 second using v1.01-cache-2.11-cpan-39bf76dae61 )