if ( scalar @{ $c->error } ) {
$c->stash->{errors} = $c->error;
+ for my $error ( @{ $c->error } ) {
+ $c->log->error($error);
+ }
$c->stash->{template} = 'errors.tt';
$c->forward('MyApp::View::TT');
- $c->error(0);
+ $c->clear_errors;
}
return 1 if $c->response->status =~ /^3\d\d$/;
sub add_item : Local {
my ( $self, $c ) = @_;
- my $item_id = $c->req->param("item");
+ my $item_id = $c->req->params->{item};
push @{ $c->session->{items} }, $item_id;
sub login : Local {
my ($self, $c) = @_;
- if ( my $user = $c->req->param("user")
- and my $password = $c->req->param("password") )
+ if ( my $user = $c->req->params->{user}
+ and my $password = $c->req->param->{password} )
{
if ( $c->authenticate( username => $user, password => $password ) ) {
$c->res->body( "hello " . $c->user->name );
sub feed_moose : Local {
my ( $self, $c ) = @_;
- $c->model( "Moose" )->eat( $c->req->param("food") );
+ $c->model( "Moose" )->eat( $c->req->params->{food} );
}
With this action, anyone can just come into the moose cage and feed
my ( $self, $c ) = @_;
if ( $c->check_roles( "moose_feeder" ) ) {
- $c->model( "Moose" )->eat( $c->req->param("food") );
+ $c->model( "Moose" )->eat( $c->req->params->{food} );
} else {
$c->stash->{error} = "unauthorized";
}
=head1 Models
-Models are where application data belongs. Catalyst is exteremely
+Models are where application data belongs. Catalyst is extremely
flexible with the kind of models that it can use. The recipes here
are just the start.
__PACKAGE__->config(
schema_class => 'Some::DBIC::Schema',
- connect_info => ['dbi:SQLite:foo.db', '', '', {AutoCommit=>1}];
+ connect_info => ['dbi:SQLite:foo.db', '', '', {AutoCommit=>1}],
);
1;
=head2 Adding RSS feeds
Adding RSS feeds to your Catalyst applications is simple. We'll see two
-different aproaches here, but the basic premise is that you forward to
+different approaches here, but the basic premise is that you forward to
the normal view action first to get the objects, then handle the output
differently.
-=head3 Using TT templates
-
-This is the aproach used in Agave (L<http://dev.rawmode.org/>).
-
- sub rss : Local {
- my ($self,$c) = @_;
- $c->forward('view');
- $c->stash->{template}='rss.tt';
- }
-
-Then you need a template. Here's the one from Agave:
-
- <?xml version="1.0" encoding="UTF-8"?>
- <rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/">
- <channel>
- <title>[ [% blog.name || c.config.name || "Agave" %] ] RSS Feed</title>
- <link>[% base %]</link>
- <description>Recent posts</description>
- <language>en-us</language>
- <ttl>40</ttl>
- [% WHILE (post = posts.next) %]
- <item>
- <title>[% post.title %]</title>
- <description>[% post.formatted_teaser|html%]</description>
- <pubDate>[% post.pub_date %]</pubDate>
- <guid>[% post.full_uri %]</guid>
- <link>[% post.full_uri %]</link>
- <dc:creator>[% post.author.screenname %]</dc:creator>
- </item>
- [% END %]
- </channel>
- </rss>
-
=head3 Using XML::Feed
-A more robust solution is to use L<XML::Feed>, as was done in the Catalyst
-Advent Calendar. Assuming we have a C<view> action that populates
+Assuming we have a C<view> action that populates
'entries' with some DBIx::Class iterator, the code would look something
like this:
$c->res->body( $feed->as_xml );
}
-A little more code in the controller, but with this approach you're
+With this approach you're
pretty sure to get something that validates.
-Note that for both of the above aproaches, you'll need to set the
+Note that for both of the above approaches, you'll need to set the
content type like this:
$c->res->content_type('application/rss+xml');
This technique can be expanded as needed to fulfil your requirements - for example,
if you inherit the first action of a chain from a base class, then mixing in a
-different base class can be used to duplicate an entire URL hieratchy at a different
+different base class can be used to duplicate an entire URL hierarchy at a different
point within your application.
=head2 Component-based Subrequests
=head4 Cannot run different versions of libraries.
-If you have two differnet applications which run on the same machine,
+If you have two different applications which run on the same machine,
which need two different versions of a library then the only way to do
this is to have per-vhost perl interpreters (with different library paths).
This is entirely possible, but nullifies all the memory sharing benefits that
mundus:~/MyApp chansen$ cat t/01app.t | perl -ne 'printf( "%2d %s", $., $_ )'
1 use Test::More tests => 2;
- 2 use_ok( Catalyst::Test, 'MyApp' );
+ 2 BEGIN { use_ok( Catalyst::Test, 'MyApp' ) }
3
4 ok( request('/')->is_success );
test HTML, forms and links. A short example of usage:
use Test::More tests => 6;
- use_ok( Test::WWW::Mechanize::Catalyst, 'MyApp' );
+ BEGIN { use_ok( Test::WWW::Mechanize::Catalyst, 'MyApp' ) }
my $mech = Test::WWW::Mechanize::Catalyst->new;
$mech->get_ok("http://localhost/", 'Got index page');
=item Catalyst::Test
-L<http://search.cpan.org/dist/Catalyst/lib/Catalyst/Test.pm>
+L<Catalyst::Test>
=item Test::WWW::Mechanize::Catalyst
projects / catagits/Catalyst-Manual.git / blobdiff