Although this chapter of the tutorial will show you how to build CRUD
functionality yourself, another option is to use a "CRUD builder" type
-of tool to automate the process. You get less control, but it's quick
-and easy. For example, see
-L<CatalystX::ListFramework::Builder|CatalystX::ListFramework::Builder>,
+of tool to automate the process. You get less control, but it can be
+quick and easy. For example, see
+L<Catalyst::Plugin::AutoCRUD|Catalyst::Plugin::AutoCRUD>,
L<CatalystX::CRUD|CatalystX::CRUD>, and
L<CatalystX::CRUD::YUI|CatalystX::CRUD::YUI>.
=cut
- sub url_create : Local {
+ sub url_create :Local {
# In addition to self & context, get the title, rating, &
# author_id args from the URL. Note that Catalyst automatically
# puts extra information after the "/<controller_name>/<action_name/"
# Note: Above is a shortcut for this:
# $book->create_related('book_authors', {author_id => $author_id});
- # Assign the Book object to the stash for display in the view
- $c->stash->{book} = $book;
-
- # Set the TT template to use
- $c->stash->{template} = 'books/create_done.tt2';
+ # Assign the Book object to the stash for display and set template
+ $c->stash(book => $book,
+ template => 'books/create_done.tt2');
}
Notice that Catalyst takes "extra slash-separated information" from the
to get around an issue in TT v2.15 where blessed hash objects were not
handled correctly. But, if you are still using v2.15, it's probably
-time to upgrade (v2.15 is exactly 3 years old on the day I'm typing
-this). If you are following along in Debian, then you should be on at
-least v2.20. You can test your version of Template Toolkit with the
-following:
+time to upgrade (v2.15 is almost 4 years old). If you are following
+along in Debian, then you should be on at least v2.20. You can test
+your version of Template Toolkit with the following:
perl -MTemplate -e 'print "$Template::VERSION\n"'
=head2 Try the 'url_create' Feature
-If the application is still running from before, use C<Ctrl-C> to kill
-it. Then restart the server:
+Make sure the development server is running with the "-r" restart
+option:
- $ DBIC_TRACE=1 script/myapp_server.pl
+ $ DBIC_TRACE=1 script/myapp_server.pl -r
Note that new path for C</books/url_create> appears in the startup debug
output.
-B<TIP>: You can use C<script/myapp_server.pl -r> to have the development
-server auto-detect changed files and reload itself (if your browser acts
-odd, you should also try throwing in a C<-k>). If you make changes to
-the TT templates only, you do not need to reload the development server
-(only changes to "compiled code" such as Controller and Model C<.pm>
-files require a reload).
-
Next, use your browser to enter the following URL:
http://localhost:3000/books/url_create/TCPIP_Illustrated_Vol-2/5/4
see the six DBIC debug messages similar to the following (where
N=1-6):
- SELECT author.id, author.first_name, author.last_name \
- FROM book_author me JOIN author author \
+ SELECT author.id, author.first_name, author.last_name
+ FROM book_author me JOIN author author
ON author.id = me.author_id WHERE ( me.book_id = ? ): 'N'
-(The '\' characters won't actually appear in the output -- we are
-using them as "line continuation markers" here.)
-
=head1 CONVERT TO A CHAINED ACTION
| /books/url_create | /books/url_create |
'-------------------------------------+--------------------------------------'
-Now start the development server with our basic chained method in
-place and the startup debug output should change to something along
-the lines of the following:
+When the development server restarts, the debug output should change
+to something along the lines of the following:
[debug] Loaded Path actions:
.-------------------------------------+--------------------------------------.
my ($self, $c) = @_;
# Store the ResultSet in stash so it's available for other methods
- $c->stash->{resultset} = $c->model('DB::Book');
+ $c->stash(resultset => $c->model('DB::Book'));
# Print a message to the debug log
$c->log->debug('*** INSIDE BASE METHOD ***');
sub url_create :Chained('base') :PathPart('url_create') :Args(3) {
-Next, try out the refactored chain by restarting the development
-server. Notice that our "Loaded Chained actions" section has changed
-slightly:
+Once you save C<lib/MyApp/Controller/Books.pm>, notice that the
+development server will restart and our "Loaded Chained actions" section
+will changed slightly:
[debug] Loaded Chained actions:
.-------------------------------------+--------------------------------------.
the C<url_create> method because this method "chained" off C<base> and
specified C<:PathPart('url_create')> (note that we could have omitted
the "PathPart" here because it matches the name of the method, but we
-will include it to make the logic behind the tutorial as explicit as
-possible).
+will include it to make the logic as explicit as possible).
Once again, enter the following URL into your browser:
my ($self, $c) = @_;
# Set the TT template to use
- $c->stash->{template} = 'books/form_create.tt2';
+ $c->stash(template => 'books/form_create.tt2');
}
This action simply invokes a view containing a form to create a book.
Open C<root/src/books/form_create.tt2> in your editor and enter:
[% META title = 'Manual Form Book Create' -%]
-
+
<form method="post" action="[% c.uri_for('form_create_do') %]">
<table>
<tr><td>Title:</td><td><input type="text" name="title"></td></tr>
# Note: Above is a shortcut for this:
# $book->create_related('book_authors', {author_id => $author_id});
- # Store new model object in stash
- $c->stash->{book} = $book;
-
# Avoid Data::Dumper issue mentioned earlier
# You can probably omit this
$Data::Dumper::Useperl = 1;
- # Set the TT template to use
- $c->stash->{template} = 'books/create_done.tt2';
+ # Store new model object in stash and set template
+ $c->stash(book => $book,
+ template => 'books/create_done.tt2');
}
=head2 Test Out The Form
-If the application is still running from before, use C<Ctrl-C> to kill
-it. Then restart the server:
-
- $ script/myapp_server.pl
-
Notice that the server startup log reflects the two new chained
methods that we added:
[% # authors into the list. Note that the 'push' TT vmethod doesn't return -%]
[% # a value, so nothing will be printed here. But, if you have something -%]
[% # in TT that does return a value and you don't want it printed, you can -%]
- [% # 1) assign it to a bogus value, or # 2) use the CALL keyword to -%]
- [% # call it and discard the return value. -%]
+ [% # 1) assign it to a bogus value, or -%]
+ [% # 2) use the CALL keyword to call it and discard the return value. -%]
[% tt_authors = [ ];
tt_authors.push(author.last_name) FOREACH author = book.authors %]
[% # Now use a TT 'virtual method' to display the author count in parens -%]
have the appropriate book waiting for it in
C<$c-E<gt>stash-E<gt>{object}>.
-Also note that we are using a different technique for setting
-C<$c-E<gt>stash>. The advantage of this style is that it lets you set
-multiple stash variables at a time. For example:
-
- $c->stash(object => $c->stash->{resultset}->find($id),
- another_thing => 1);
-
-or as a hashref:
-
- $c->stash({object => $c->stash->{resultset}->find($id),
- another_thing => 1});
-
-Either format works, but the C<$c-E<gt>stash(name =E<gt> value);>
-style is growing in popularity -- you may wish to use it all
-the time (even when you are only setting a single value).
-
=head2 Add a Delete Action to the Controller
=head2 Try the Delete Feature
-If the application is still running from before, use C<Ctrl-C> to kill
-it. Then restart the server:
-
- $ DBIC_TRACE=1 script/myapp_server.pl
-
-The C<delete> method now appears in the "Loaded Chained actions" section
+One you save the Books controller, the server should automatically restart.
+The C<delete> method should now appear in the "Loaded Chained actions" section
of the startup debug output:
[debug] Loaded Chained actions:
=head2 Try the Delete and Redirect Logic
-Restart the development server and point your browser to
-L<http://localhost:3000/books/list> (don't just hit "Refresh" in your
-browser since we left the URL in an invalid state in the previous
-section!) and delete the first copy of the remaining two
-"TCPIP_Illustrated_Vol-2" books. The URL in your browser should return
-to the L<http://localhost:3000/books/list> URL, so that is an
-improvement, but notice that I<no green "Book deleted" status message is
-displayed>. Because the stash is reset on every request (and a redirect
-involves a second request), the C<status_msg> is cleared before it can
-be displayed.
+Point your browser to L<http://localhost:3000/books/list> (don't just
+hit "Refresh" in your browser since we left the URL in an invalid state
+in the previous section!) and delete the first copy of the remaining two
+"TCPIP_Illustrated_Vol-2" books. The URL in your browser should return
+to the L<http://localhost:3000/books/list> URL, so that is an
+improvement, but notice that I<no green "Book deleted" status message is
+displayed>. Because the stash is reset on every request (and a redirect
+involves a second request), the C<status_msg> is cleared before it can
+be displayed.
=head2 Using 'uri_for' to Pass Query Parameters
=head2 Try the Delete and Redirect With Query Param Logic
-Restart the development server and point your browser to
-L<http://localhost:3000/books/list> (you should now be able to safely
-hit "refresh" in your browser). Then delete the remaining copy of
-"TCPIP_Illustrated_Vol-2". The green "Book deleted" status message
-should return.
+Point your browser to L<http://localhost:3000/books/list> (you should
+now be able to safely hit "refresh" in your browser). Then delete the
+remaining copy of "TCPIP_Illustrated_Vol-2". The green "Book deleted"
+status message should return. But notice that you can now hit the
+"Reload" button in your browser and it just redisplays the book
+list (and it correctly shows it without the "Book deleted" message
+on redisplay).
B<NOTE:> Another popular method for maintaining server-side
information across a redirect is to use the C<flash> technique we
each book was added and when each book is updated:
$ sqlite3 myapp.db
- sqlite> ALTER TABLE book ADD created INTEGER;
- sqlite> ALTER TABLE book ADD updated INTEGER;
+ sqlite> ALTER TABLE book ADD created TIMESTAMP;
+ sqlite> ALTER TABLE book ADD updated TIMESTAMP;
sqlite> UPDATE book SET created = DATETIME('NOW'), updated = DATETIME('NOW');
sqlite> SELECT * FROM book;
- 1|CCSP SNRS Exam Certification Guide|5|2009-03-08 16:26:35|2009-03-08 16:26:35
- 2|TCP/IP Illustrated, Volume 1|5|2009-03-08 16:26:35|2009-03-08 16:26:35
- 3|Internetworking with TCP/IP Vol.1|4|2009-03-08 16:26:35|2009-03-08 16:26:35
- 4|Perl Cookbook|5|2009-03-08 16:26:35|2009-03-08 16:26:35
- 5|Designing with Web Standards|5|2009-03-08 16:26:35|2009-03-08 16:26:35
- 9|TCP/IP Illustrated, Vol 3|5|2009-03-08 16:26:35|2009-03-08 16:26:35
+ 1|CCSP SNRS Exam Certification Guide|5|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 2|TCP/IP Illustrated, Volume 1|5|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 3|Internetworking with TCP/IP Vol.1|4|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 4|Perl Cookbook|5|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 5|Designing with Web Standards|5|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 9|TCP/IP Illustrated, Vol 3|5|2010-02-16 04:15:45|2010-02-16 04:15:45
sqlite> .quit
$
with the new fields:
$ script/myapp_create.pl model DB DBIC::Schema MyApp::Schema \
- create=static components=TimeStamp dbi:SQLite:myapp.db
+ create=static components=TimeStamp dbi:SQLite:myapp.db \
+ on_connect_do="PRAGMA foreign_keys = ON"
exists "/root/dev/MyApp/script/../lib/MyApp/Model"
exists "/root/dev/MyApp/script/../t"
Dumping manual schema for MyApp::Schema to directory /root/dev/MyApp/script/../lib ...
it to include the L<DBIx::Class::TimeStamp|DBIx::Class::TimeStamp>
in the C<load_components> line of the Result Classes.
-If you open C<lib/MyApp/Schema/Result/Book.pm> in your editor you
-should see that the C<created> and C<updated> fields are now included
-in the call to C<add_columns()>, but our relationship information below
-the "C<# DO NOT MODIFY...>" line was automatically preserved.
+If you open C<lib/MyApp/Schema/Result/Book.pm> in your editor you should
+see that the C<created> and C<updated> fields are now included in the
+call to C<add_columns()>. However, also notice that the C<many_to_many>
+relationships we manually added below the "C<# DO NOT MODIFY...>" line
+were automatically preserved.
While we have this file open, let's update it with some additional
information to have DBIC automatically handle the updating of these
#
__PACKAGE__->add_columns(
"created",
- { data_type => 'datetime', set_on_create => 1 },
+ { data_type => 'timestamp', set_on_create => 1 },
"updated",
- { data_type => 'datetime', set_on_create => 1, set_on_update => 1 },
+ { data_type => 'timestamp', set_on_create => 1, set_on_update => 1 },
);
This will override the definition for these fields that Schema::Loader
update the timestamps in these columns whenever a row is created or
modified.
-To test this out, restart the development server using the
-C<DBIC_TRACE=1> option:
-
- DBIC_TRACE=1 script/myapp_server.pl
-
Then enter the following URL into your web browser:
http://localhost:3000/books/url_create/TCPIP_Illustrated_Vol-2/5/4
you will see that the new book we added has an appropriate date and
time entered for it (see the last line in the listing below):
- sqlite3 myapp.db "select * from book"
- 1|CCSP SNRS Exam Certification Guide|5|2009-03-08 16:26:35|2009-03-08 16:26:35
- 2|TCP/IP Illustrated, Volume 1|5|2009-03-08 16:26:35|2009-03-08 16:26:35
- 3|Internetworking with TCP/IP Vol.1|4|2009-03-08 16:26:35|2009-03-08 16:26:35
- 4|Perl Cookbook|5|2009-03-08 16:26:35|2009-03-08 16:26:35
- 5|Designing with Web Standards|5|2009-03-08 16:26:35|2009-03-08 16:26:35
- 9|TCP/IP Illustrated, Vol 3|5|2009-03-08 16:26:35|2009-03-08 16:26:35
- 10|TCPIP_Illustrated_Vol-2|5|2009-03-08 16:29:08|2009-03-08 16:29:08
+ $ sqlite3 myapp.db "select * from book"
+ 1|CCSP SNRS Exam Certification Guide|5|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 2|TCP/IP Illustrated, Volume 1|5|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 3|Internetworking with TCP/IP Vol.1|4|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 4|Perl Cookbook|5|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 5|Designing with Web Standards|5|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 9|TCP/IP Illustrated, Vol 3|5|2010-02-16 04:15:45|2010-02-16 04:15:45
+ 10|TCPIP_Illustrated_Vol-2|5|2010-02-16 04:18:42|2010-02-16 04:18:42
+ sqlite> .q
Notice in the debug log that the SQL DBIC generated has changed to
incorporate the datetime logic:
INSERT INTO book ( created, rating, title, updated ) VALUES ( ?, ?, ?, ? ):
- '2009-05-25 20:39:41', '5', 'TCPIP_Illustrated_Vol-2', '2009-05-25 20:39:41'
+ '2010-02-16 04:18:42', '5', 'TCPIP_Illustrated_Vol-2', '2010-02-16 04:18:42'
INSERT INTO book_author ( author_id, book_id ) VALUES ( ?, ? ): '4', '10'
method that returns books added in the last 10 minutes. Start by
making a directory where DBIx::Class will look for our ResultSet Class:
- mkdir lib/MyApp/Schema/ResultSet
+ $ mkdir lib/MyApp/Schema/ResultSet
Then open C<lib/MyApp/Schema/ResultSet/Book.pm> and enter the following:
sub created_after {
my ($self, $datetime) = @_;
- my $date_str = $self->_source_handle->schema->storage
+ my $date_str = $self->result_source->schema->storage
->datetime_parser->format_datetime($datetime);
return $self->search({
1;
-Then we need to tell the Result Class to to treat this as a ResultSet
-Class. Open C<lib/MyApp/Schema/Result/Book.pm> and add the following
-above the "C<1;>" at the bottom of the file:
-
- #
- # Set ResultSet Class
- #
- __PACKAGE__->resultset_class('MyApp::Schema::ResultSet::Book');
-
Then add the following method to the C<lib/MyApp/Controller/Books.pm>:
=head2 list_recent
# Retrieve all of the book records as book model objects and store in the
# stash where they can be accessed by the TT template, but only
# retrieve books created within the last $min number of minutes
- $c->stash->{books} = [$c->model('DB::Book')
- ->created_after(DateTime->now->subtract(minutes => $mins))];
+ $c->stash(books => [$c->model('DB::Book')
+ ->created_after(DateTime->now->subtract(minutes => $mins))]);
# Set the TT template to use. You will almost always want to do this
# in your action methods (action methods respond to user input in
# your controllers).
- $c->stash->{template} = 'books/list.tt2';
+ $c->stash(template => 'books/list.tt2');
}
-Now start the development server with C<DBIC_TRACE=1> and try
-different values for the minutes argument (the final number value) for
-the URL C<http://localhost:3000/books/list_recent/10>. For example,
-this would list all books added in the last fifteen minutes:
+Now try different values for the "minutes" argument (the final number
+value) using the URL C<http://localhost:3000/books/list_recent/_#_> in
+your browser. For example, this would list all books added in the last
+fifteen minutes:
http://localhost:3000/books/list_recent/15
Depending on how recently you added books, you might want to
-try a higher or lower value.
+try a higher or lower value for the minutes.
=head2 Chaining ResultSets
# stash where they can be accessed by the TT template, but only
# retrieve books created within the last $min number of minutes
# AND that have 'TCP' in the title
- $c->stash->{books} = [$c->model('DB::Book')
+ $c->stash(books => [$c->model('DB::Book')
->created_after(DateTime->now->subtract(minutes => $mins))
->search({title => {'like', '%TCP%'}})
- ];
+ ]);
# Set the TT template to use. You will almost always want to do this
# in your action methods (action methods respond to user input in
# your controllers).
- $c->stash->{template} = 'books/list.tt2';
+ $c->stash(template => 'books/list.tt2');
}
-To try this out, restart the development server with:
-
- DBIC_TRACE=1 script/myapp_server.pl
-
-And enter the following URL into your browser:
+To try this out, enter the following URL into your browser:
http://localhost:3000/books/list_recent_tcp/100
the first URL and you should see something similar to the following:
SELECT me.id, me.title, me.rating, me.created, me.updated FROM book me
- WHERE ( ( title LIKE ? AND created > ? ) ): '%TCP%', '2009-05-25 19:09:13'
+ WHERE ( ( title LIKE ? AND created > ? ) ): '%TCP%', '2010-02-16 02:49:32'
However, let's not pollute our controller code with this raw "TCP"
query -- it would be cleaner to encapsulate that code in a method on
# stash where they can be accessed by the TT template, but only
# retrieve books created within the last $min number of minutes
# AND that have 'TCP' in the title
- $c->stash->{books} = [$c->model('DB::Book')
+ $c->stash(books => [$c->model('DB::Book')
->created_after(DateTime->now->subtract(minutes => $mins))
->title_like('TCP')
- ];
+ ]);
# Set the TT template to use. You will almost always want to do this
# in your action methods (action methods respond to user input in
# your controllers).
- $c->stash->{template} = 'books/list.tt2';
+ $c->stash(template => 'books/list.tt2');
}
-Then restart the development server and try out the C<list_recent_tcp>
-and C<list_recent> URL as we did above. It should work just the same,
-but our code is obviously cleaner and more modular, while also being
-more flexible at the same time.
+Try out the C<list_recent_tcp> and C<list_recent> URLs as we did above.
+They should work just the same, but our code is obviously cleaner and
+more modular, while also being more flexible at the same time.
=head2 Adding Methods to Result Classes
always, it must be above the closing "C<1;>"):
#
- # Helper methods
+ # Row-level helper methods
#
sub full_name {
my ($self) = @_;
(Only C<author.last_name> was changed to C<author.full_name> -- the
rest of the file should remain the same.)
-Now restart the development server and go to the standard book list
-URL:
+Now go to the standard book list URL:
http://localhost:3000/books/list
The "Author(s)" column will now contain both the first and last name.
And, because the concatenation logic was encapsulated inside our
-Result Class, it keeps the code inside our .tt template nice and clean
+Result Class, it keeps the code inside our TT template nice and clean
(remember, we want the templates to be as close to pure HTML markup as
possible). Obviously, this capability becomes even more useful as you
use to to remove even more complicated row-specific logic from your
return the number of authors for a book. Open
C<lib/MyApp/Schema/Result/Book.pm> and add the following method:
-=head2 author_count
-
-Return the number of authors for the current book
-
+ =head2 author_count
+
+ Return the number of authors for the current book
+
=cut
sub author_count {
...
Although most of the code we removed comprised comments, the overall
-effect is dramatic... because our view code is so simple, we don't
-huge comments to clue people in to the gist of our code. The view
-code is now self-documenting and readable enough that you could
-probably get by with no comments at all. All of the "complex" work is
-being done in our Result Class methods (and, because we have broken
-the code into nice, modular chucks, the Result Class code is hardly
-something you would call complex).
+effect is dramatic... because our view code is so simple, we don't need
+huge comments to clue people in to the gist of our code. The view code
+is now self-documenting and readable enough that you could probably get
+by with no comments at all. All of the "complex" work is being done in
+our Result Class methods (and, because we have broken the code into
+nice, modular chucks, the Result Class code is hardly something you
+would call complex).
As we saw in this section, always strive to keep your view AND
controller code as simple as possible by pulling code out into your
make your code cleaner, easier to write, less error-prone, and easier
to debug and maintain.
+Before you conclude this section, hit Refresh in your browser... the
+output should be the same even though the backend code has been trimmed
+down.
+
=head1 AUTHOR
projects / catagits/Catalyst-Manual.git / blobdiff