Although HTML::FormHandler can be used in any Perl web application, module, or script, one of its most
common uses is in Catalyst applications.
Using a form takes only a few lines of code, so it's not necessary to have a Catalyst base controller,
although you could make a base controller for FormHandler if you're doing more than the basics.
AControllerExample
The following example uses chained dispatching. The 'form' method is called by both the create and edit
actions.
package BookDB::Controller::Borrower;
use Moose;
BEGIN { extends 'Catalyst::Controller' }
use BookDB::Form::Borrower;
sub borrower_base : Chained PathPart('borrower') CaptureArgs(0) { }
sub list : Chained('borrower_base') PathPart('list') Args(0) {
my ( $self, $c ) = @_;
my $borrowers = [ $c->model('DB::Borrower')->all ];
my @columns = ( 'name', 'email' );
$c->stash( borrowers => $borrowers, columns => \@columns,
template => 'borrower/list.tt' );
}
sub add : Chained('borrower_base') PathPart('add') Args(0) {
my ( $self, $c ) = @_;
# Create the empty borrower row for the form
$c->stash( borrower => $c->model('DB::Borrower')->new_result({}) );
return $self->form($c);
}
sub item : Chained('borrower_base') PathPart('') CaptureArgs(1) {
my ( $self, $c, $borrower_id ) = @_;
$c->stash( borrower => $c->model('DB::Borrower')->find($borrower_id) );
}
sub edit : Chained('item') PathPart('edit') Args(0) {
my ( $self, $c ) = @_;
return $self->form($c);
}
sub form {
my ( $self, $c ) = @_;
my $form = BookDB::Form::Borrower->new;
$c->stash( form => $form, template => 'borrower/form.tt' );
return unless $form->process( item => $c->stash->{borrower},
params => $c->req->parameters );
$c->res->redirect( $c->uri_for($self->action_for('list')) );
}
sub delete : Chained('item') PathPart('delete') Args(0) {
my ( $self, $c ) = @_;
$c->stash->{borrower}->delete;
$c->res->redirect( $c->uri_for($c->action_for('list')) );
}
1;
Anotherwaytosetupyourform
If you are setting the schema or other form attributes (such as the user_id, or other attributes) on your
form you could create a base controller that would set these in the form on each call using
Catalyst::Component::InstancePerContext, or set them in a base Chained method.
sub book_base : Chained PathPart('book') CaptureArgs(0) {
my ( $self, $c ) = @_;
my $form = MyApp::Form->new;
$form->schema( $c->model('DB')->schema );
$form->params( $c->req->parameters );
$form->user_id( $c->user->id );
$c->stash( form => $form );
}
Then you could just pass in the item_id when the form is processed.
return unless $c->stash->{form}->process( item_id => $id );
PuttingaforminaMooseattribute
You can also put your form in a Moose attribute in the controller.
package MyApp::Controller::Book;
use Moose;
BEGIN { extends 'Catalyst::Controller'; }
use MyApp::Form::Book;
has 'edit_form' => ( isa => 'MyApp::Form::Book', is => 'rw',
lazy => 1, default => sub { MyApp::Form::Book->new } );
Then you can process the form in your actions with "$self->edit_form->process( params =>
$c->req->body_parameters );" or "my $result = $self->edit_form->run( params => $c->req->body_parameters
);".
UsingHTML::FillInForm
If you want to use HTML::FillInForm to fill in values instead of doing it in directly in a template using
either the field or the form 'fif' methods, you can use Catalyst::View::FillInForm on your view class:
package MyApp::View::TT;
use Moose;
with 'Catalyst::View::FillInForm';
....
1;
and set the 'fif' hash in the 'fillinform' stash variable:
$self->form->process( ... );
$c->stash( fillinform => $self->form->fif );
return unless $form->validated;
When the 'fillinform' stash variable is set, HTML::FillInForm will automatically be used by your view to
fill in the form values. This can be very helpful when you want to build your forms by hand, or when you
have legacy forms that you're just trying to hook up to FormHandler.
TheCatalystcontext
FormHandler has a 'ctx' attribute that can be used to set the Catalyst context (or anything you want,
really). But if you can avoid passing in the context, you should do so, because you're mixing up your MVC
and it makes it much more difficult to test your forms. But if you need to do it, you can:
my $form = MyApp::Form->new( ctx => $c );
Usually you should prefer to add new attributes to your form:
package MyApp::Form;
use HTML::FormHandler::Moose;
extends 'HTML::FormHandler';
has 'user_id' => ( is => 'rw' );
has 'hostname' => ( is => 'rw' );
has 'captcha_store' => ( is => 'rw' );
....
1;
Then just pass the attributes in on new:
my $form => MyApp::Form->new( user_id => $c->user->id, hostname => $c->req->host,
captcha_store => $c->{session}->{captcha} );
Or set them using accessors:
$form->user_id( $c->user->id );
$form->hostname( $c->req->host );
$form->captcha_store( $c->{session}->{captcha} );
Then you can access these attributes in your form validation methods:
sub validate_selection {
my ( $self, $field ) = @_;
if( $field->value eq 'something' && $self->hostname eq 'something_else' )
{
$field->add_error("some error message" );
}
}
Install Now
PNG Icons
SVG Icons