Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
HTML::FormHandler::ManUser:Contributed PHTML::FormHandler::Manual::Catalyst(3)

       HTML::FormHandler::Manual::Catalyst - using HFH forms in	Catalyst

       version 0.40068

       Manual Index

       This part of the	FormHandler Manual describes the use of	the
       HTML::FormHandler package in Catalyst controllers.

       See the other FormHandler documentation at HTML::FormHandler::Manual,
       or the base class at HTML::FormHandler.

       Although	HTML::FormHandler can be used in any Perl web application,
       module, or script, one of its most common uses is in Catalyst

       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.

   A Controller	Example
       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/' );

	  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/' );
	     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->res->redirect(	$c->uri_for($c->action_for('list')) );


   Another way to set up your form
       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

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

   Putting a form in a Moose attribute
       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

   Using  HTML::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';

       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.

   The Catalyst	context
       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' );

       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"	);

       FormHandler Contributors	- see HTML::FormHandler

       This software is	copyright (c) 2017 by Gerda Shank.

       This is free software; you can redistribute it and/or modify it under
       the same	terms as the Perl 5 programming	language system	itself.

perl v5.32.0			  2017-0HTML::FormHandler::Manual::Catalyst(3)


Want to link to this manual page? Use this URL:

home | help