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

FreeBSD Manual Pages

  
 
  

home | help
Catalyst::Manual::TutCUseryCon:ributed:PerlrDoc:mentationNAME
       Catalyst::Manual::Tutorial::09_AdvancedCRUD::09_FormFu -	Catalyst
       Tutorial	- Chapter 9: Advanced CRUD - FormFu

OVERVIEW
       This is Chapter 9 of 10 for the Catalyst	tutorial.

       Tutorial	Overview

       1.  Introduction

       2.  Catalyst Basics

       3.  More	Catalyst Basics

       4.  Basic CRUD

       5.  Authentication

       6.  Authorization

       7.  Debugging

       8.  Testing

       9.  09_Advanced CRUD::09_FormFu

       10. Appendices

DESCRIPTION
       This portion of the tutorial explores HTML::FormFu and how it can be
       used to manage forms, perform validation	of form	input, as well as save
       and restore data	to/from	the database.

       See Catalyst::Manual::Tutorial::09_AdvancedCRUD for additional form
       management options other	than HTML::FormFu.

       Source code for the tutorial in included	in the /home/catalyst/Final
       directory of the	Tutorial Virtual machine (one subdirectory per
       chapter).  There	are also instructions for downloading the code in
       Catalyst::Manual::Tutorial::01_Intro.

HTML::FormFu FORM CREATION
       This section looks at how HTML::FormFu can be used to add additional
       functionality to	the manually created form from Chapter 4.

   Inherit From	Catalyst::Controller::HTML::FormFu
       First, change your lib/MyApp/Controller/Books.pm	to inherit from
       Catalyst::Controller::HTML::FormFu by changing the "extends" line from
       the default of:

	   BEGIN {extends 'Catalyst::Controller'; }

       to use the FormFu base controller class:

	   BEGIN {extends 'Catalyst::Controller::HTML::FormFu';	}

       Don't forget to add:

	   requires 'HTML::FormFu';
	   requires 'Catalyst::Controller::HTML::FormFu';
	   requires 'HTML::FormFu::Model::DBIC';

       to your "Makefile.PL".

   Add Action to Display and Save the Form
       Open lib/MyApp/Controller/Books.pm in your editor and add the following
       method:

	   =head2 formfu_create

	   Use HTML::FormFu to create a	new book

	   =cut

	   sub formfu_create :Chained('base') :PathPart('formfu_create') :Args(0) :FormConfig {
	       my ($self, $c) =	@_;

	       # Get the form that the :FormConfig attribute saved in the stash
	       my $form	= $c->stash->{form};

	       # Check if the form has been submitted (vs. displaying the initial
	       # form) and if the data passed validation.  "submitted_and_valid"
	       # is shorthand for "$form->submitted && !$form->has_errors"
	       if ($form->submitted_and_valid) {
		   # Create a new book
		   my $book = $c->model('DB::Book')->new_result({});
		   # Save the form data	for the	book
		   $form->model->update($book);
		   # Set a status message for the user & return	to books list
		   $c->response->redirect($c->uri_for($self->action_for('list'),
		       {mid => $c->set_status_msg("Book	created")}));
		   $c->detach;
	       } else {
		   # Get the authors from the DB
		   my @author_objs = $c->model("DB::Author")->all();
		   # Create an array of	arrayrefs where	each arrayref is an author
		   my @authors;
		   foreach (sort {$a->last_name	cmp $b->last_name} @author_objs) {
		       push(@authors, [$_->id, $_->last_name]);
		   }
		   # Get the select added by the config	file
		   my $select =	$form->get_element({type => 'Select'});
		   # Add the authors to	it
		   $select->options(\@authors);
	       }

	       # Set the template
	       $c->stash(template => 'books/formfu_create.tt2');
	   }

   Create a Form Config	File
       Although	HTML::FormFu supports any configuration	file handled by
       Config::Any, most people	tend to	use YAML.  First create	a directory to
       hold your form configuration files:

	   $ mkdir -p root/forms/books

       Then create the file root/forms/books/formfu_create.yml and enter the
       following text:

	   ---
	   # indicator is the field that is used to test for form submission
	   indicator: submit
	   # Start listing the form elements
	   elements:
	       # The first element will	be a text field	for the	title
	       - type: Text
		 name: title
		 label:	Title
		 # This	is an optional 'mouse over' title pop-up
		 attributes:
		   title: Enter	a book title here

	       # Another text field for	the numeric rating
	       - type: Text
		 name: rating
		 label:	Rating
		 attributes:
		   title: Enter	a rating between 1 and 5 here

	       # Add a drop-down list for the author selection.	 Note that we will
	       # dynamically fill in all the authors from the controller but we
	       # could manually	set items in the drop-list by adding this YAML code:
	       # options:
	       #   - [ '1', 'Bastien' ]
	       #   - [ '2', 'Nasseh'  ]
	       - type: Select
		 name: authors
		 label:	Author

	       # The submit button
	       - type: Submit
		 name: submit
		 value:	Submit

       NOTE: Copying and pasting YAML from Perl	documentation is sometimes
       tricky.	See the	"Config::General Config	for this tutorial" section of
       this document for a more	foolproof config format.

   Update the CSS
       Edit root/static/css/main.css and add the following lines to the	bottom
       of the file:

	   ...
	   input {
	       display:	block;
	   }
	   select {
	       display:	block;
	   }
	   .submit {
	       padding-top: .5em;
	       display:	block;
	   }

       These changes will display form elements	vertically.

   Create a Template Page To Display The Form
       Open root/src/books/formfu_create.tt2 in	your editor and	enter the
       following:

	   [% META title = 'Create/Update Book'	%]

	   [%# Render the HTML::FormFu Form %]
	   [% form %]

	   <p><a href="[% c.uri_for(c.controller.action_for('list'))
	       %]">Return to book list</a></p>

   Add Links for Create	and Update via "HTML::FormFu"
       Open root/src/books/list.tt2 in your editor and add the following to
       the bottom of the existing file:

	   ...
	   <p>
	     HTML::FormFu:
	     <a	href="[% c.uri_for(c.controller.action_for('formfu_create')) %]">Create</a>
	   </p>

       This adds a new link to the bottom of the book list page	that we	can
       use to easily launch our	HTML::FormFu-based form.

   Test	The HTML::FormFu Create	Form
       Make sure the server is running with the	"-r" restart option:

	   $ script/myapp_server.pl -r

       Login as	"test01" (password: mypass).  Once at the Book List page,
       click the new HTML::FormFu "Create" link	at the bottom to display the
       form.  Fill in the following values:

	   Title:  Internetworking with	TCP/IP Vol. II
	   Rating: 4
	   Author: Comer

       Click the "Submit" button, and you will be returned to the Book List
       page with a "Book created" status message displayed.

       Also note that this implementation allows you to	create books with any
       bogus information.  Although we have constrained	the authors with the
       drop-down list (note that this isn't bulletproof	because	we still have
       not prevented a user from "hacking" the form to specify other values),
       there are no restrictions on items such as the length of	the title (for
       example,	you can	create a one-letter title) and the value of the	rating
       (you can	use any	number you want, and even non-numeric values with
       SQLite).	 The next section will address this concern.

       Note: Depending on the database you are using and how you established
       the columns in your tables, the database	could obviously	provide
       various levels of "type enforcement" on your data.  The key point being
       made in the previous paragraph is that the web application itself is
       not performing any validation.

HTML::FormFu VALIDATION	AND FILTERING
       Although	the use	of HTML::FormFu	in the previous	section	did provide an
       automated mechanism to build the	form, the real power of	this module
       stems from functionality	that can automatically validate	and filter the
       user input.  Validation uses constraints	to be sure that	users input
       appropriate data	(for example, that the email field of a	form contains
       a valid email address).	Filtering can also be used to remove
       extraneous whitespace from fields or to escape meta-characters in user
       input.

   Add Constraints
       Open root/forms/books/formfu_create.yml in your editor and update it to
       match:

	   ---
	   # indicator is the field that is used to test for form submission
	   indicator: submit
	   # Start listing the form elements
	   elements:
	       # The first element will	be a text field	for the	title
	       - type: Text
		 name: title
		 label:	Title
		 # This	is an optional 'mouse over' title pop-up
		 attributes:
		   title: Enter	a book title here
		 # Add constraints for the field
		 constraints:
		   # Force the length to be between 5 and 40 chars
		   - type: Length
		     min: 5
		     max: 40
		     # Override	the default of 'Invalid	input'
		     message: Length must be between 5 and 40 characters

	       # Another text field for	the numeric rating
	       - type: Text
		 name: rating
		 label:	Rating
		 attributes:
		   title: Enter	a rating between 1 and 5 here
		 # Use Filter to clean up the input data
		 # Could use 'NonNumeric' below, but since Filters apply *before*
		 # constraints,	it would conflict with the 'Integer' constraint	below.
		 # So let's skip this and just use the constraint.
		 #filter:
		   # Remove everything except digits
		   #- NonNumeric
		 # Add constraints to the field
		 constraints:
		   # Make sure it's a number
		   - type: Integer
		     message: "Required. Digits	only, please."
		   # Check the min & max values
		   - type: Range
		     min: 1
		     max: 5
		     message: "Must be between 1 and 5."

	       # Add a select list for the author selection.  Note that	we will
	       # dynamically fill in all the authors from the controller but we
	       # could manually	set items in the select	by adding this YAML code:
	       # options:
	       #   - [ '1', 'Bastien' ]
	       #   - [ '2', 'Nasseh'  ]
	       - type: Select
		 name: authors
		 label:	Author
		 # Convert the drop-down to a multi-select list
		 multiple: 1
		 # Display 3 entries (user can scroll to see others)
		 size: 3
		 # One could argue we don't need to do filters or constraints for
		 # a select list, but it's smart to do validation and sanity
		 # checks on this data in case a user "hacks" the input
		 # Add constraints to the field
		 constraints:
		   # Make sure it's a number
		   - Integer

	       # The submit button
	       - type: Submit
		 name: submit
		 value:	Submit

	   # Global filters and	constraints.
	   constraints:
	       # The user cannot leave any fields blank
	       - Required
	       # If not	all fields are required, move the Required constraint to the
	       # fields	that are
	   filter:
	       # Remove	whitespace at both ends
	       - TrimEdges
	       # Escape	HTML characters	for safety
	       - HTMLEscape

       NOTE: Copying and pasting YAML from Perl	documentation is sometimes
       tricky.	See the	"Config::General Config	for this tutorial" section of
       this document for a more	foolproof config format.

       The main	changes	are:

       o   The "Select"	element	for "authors" is changed from a	single-select
	   drop-down to	a multi-select list by adding configuration for	the
	   "multiple" and "size" options in formfu_create.yml.

       o   Constraints are added to provide validation of the user input.  See
	   HTML::FormFu::Constraint for	other constraints that are available.

       o   A variety of	filters	are run	on every field to remove and escape
	   unwanted input.  See	HTML::FormFu::Filter for more filter options.

   Try Out the Updated Form
       Make sure you are still logged in as "test01" and try adding a book
       with various errors: title less than 5 characters, non-numeric rating,
       a rating	of 0 or	6, etc.	 Also try selecting one, two, and zero
       authors.	 When you click	Submit,	the HTML::FormFu "constraint" items
       will validate the logic and insert feedback as appropriate.  Try	adding
       blank spaces at the front or the	back of	the title and note that	it
       will be removed.

       Note that you can update	your FormFu YAML forms and the development
       server does not need to reload -- the form definition is	read from the
       YAML file each time a controller	action uses it.

CREATE AND UPDATE/EDIT ACTION
       Let's expand the	work done above	to add an edit action.	First, open
       lib/MyApp/Controller/Books.pm and add the following method to the
       bottom:

	   =head2 formfu_edit

	   Use HTML::FormFu to update an existing book

	   =cut

	   sub formfu_edit :Chained('object') :PathPart('formfu_edit') :Args(0)
		   :FormConfig('books/formfu_create.yml') {
	       my ($self, $c) =	@_;

	       # Get the specified book	already	saved by the 'object' method
	       my $book	= $c->stash->{object};

	       # Make sure we were able	to get a book
	       unless ($book) {
		   # Set an error message for the user & return	to books list
		   $c->response->redirect($c->uri_for($self->action_for('list'),
		       {mid => $c->set_error_msg("Invalid book -- Cannot edit")}));
		   $c->detach;
	       }

	       # Get the form that the :FormConfig attribute saved in the stash
	       my $form	= $c->stash->{form};

	       # Check if the form has been submitted (vs. displaying the initial
	       # form) and if the data passed validation.  "submitted_and_valid"
	       # is shorthand for "$form->submitted && !$form->has_errors"
	       if ($form->submitted_and_valid) {
		   # Save the form data	for the	book
		   $form->model->update($book);
		   # Set a status message for the user
		   # Set a status message for the user & return	to books list
		   $c->response->redirect($c->uri_for($self->action_for('list'),
		       {mid => $c->set_status_msg("Book	edited")}));
		   $c->detach;
	       } else {
		   # Get the authors from the DB
		   my @author_objs = $c->model("DB::Author")->all();
		   # Create an array of	arrayrefs where	each arrayref is an author
		   my @authors;
		   foreach (sort {$a->last_name	cmp $b->last_name} @author_objs) {
		       push(@authors, [$_->id, $_->last_name]);
		   }
		   # Get the select added by the config	file
		   my $select =	$form->get_element({type => 'Select'});
		   # Add the authors to	it
		   $select->options(\@authors);
		   # Populate the form with existing values from DB
		   $form->model->default_values($book);
	       }

	       # Set the template
	       $c->stash(template => 'books/formfu_create.tt2');
	   }

       Most of this code should	look familiar to what we used in the
       "formfu_create" method (in fact,	we should probably centralize some of
       the common code in separate methods).  The main differences are:

       o   We have to manually specify the name	of the FormFu .yml file	as an
	   argument to ":FormConfig" because the name can no longer be
	   automatically deduced from the name of our action/method (by
	   default, FormFu would look for a file named books/formfu_edit.yml).

       o   We load the book object from	the stash (found using the $id passed
	   to the Chained object method)

       o   We use $id to look up the existing book from	the database.

       o   We make sure	the book lookup	returned a valid book.	If not,	we set
	   the error message and return	to the book list.

       o   If the form has been	submitted and passes validation, we skip
	   creating a new book and just	use "$form->model->update" to update
	   the existing	book.

       o   If the form is being	displayed for the first	time (or has failed
	   validation and it being redisplayed), we use
	   "$form->model->default_values" to populate the form with data from
	   the database.

       Then, edit root/src/books/list.tt2 and add a new	link below the
       existing	"Delete" link that allows us to	edit/update each existing
       book.  The last <td> cell in the	book list table	should look like the
       following:

	   ...
	   <td>
	     [%	# Add a	link to	delete a book %]
	     <a	href="[%
	       c.uri_for(c.controller.action_for('delete'), [book.id]) %]">Delete</a>
	     [%	# Add a	link to	edit a book %]
	     <a	href="[%
	       c.uri_for(c.controller.action_for('formfu_edit'), [book.id]) %]">Edit</a>
	   </td>
	   ...

       Note: Only add three lines (the "Add a link to edit a book" comment and
       the href	for "formfu_edit").  Make sure you add it below	the existing
       "delete"	link.

   Try Out the Edit/Update Feature
       Make sure you are still logged in as "test01" and go to the
       <http://localhost:3000/books/list> URL in your browser.	Click the
       "Edit" link next	to "Internetworking with TCP/IP	Vol. II", change the
       rating to a 3, the "II" at end of the title to the number "2", add
       Stevens as a co-author (control-click), and click Submit.  You will
       then be returned	to the book list with a	"Book edited" message at the
       top in green.  Experiment with other edits to various books.

   More	Things to Try
       You are now armed with enough knowledge to be dangerous.	 You can keep
       tweaking	the example application; some things you might want to do:

       o   Add an appropriate authorization check to the new Edit function.

       o   Cleanup the List page so that the Login link	only displays when the
	   user	isn't logged in	and the	Logout link only displays when a user
	   is logged in.

       o   Add a more sensible policy for when and how users and admins	can do
	   things in the CRUD cycle.

       o   Support the CRUD cycle for authors.

       Or you can proceed to write your	own application, which is probably the
       real reason you worked through this Tutorial in the first place.

   Config::General Config for this tutorial
       If you are having difficulty with YAML config above, please save	the
       below into the file formfu_create.conf and delete the formfu_create.yml
       file.  The below	is in Config::General format which follows the syntax
       of Apache config	files.

	   constraints	 Required
	   <elements>
	       <constraints>
		   min	 5
		   max	 40
		   type	  Length
		   message   Length must be between 5 and 40 characters
	       </constraints>
	       filter	TrimEdges
	       filter	HTMLEscape
	       name   title
	       type   Text
	       label   Title
	       <attributes>
		   title   Enter a book	title here
	       </attributes>
	   </elements>
	   <elements>
	       constraints   Integer
	       filter	TrimEdges
	       filter	NonNumeric
	       name   rating
	       type   Text
	       label   Rating
	       <attributes>
		   title   Enter a rating between 1 and	5 here
	       </attributes>
	   </elements>
	   <elements>
	       constraints   Integer
	       filter	TrimEdges
	       filter	HTMLEscape
	       name   authors
	       type   Select
	       label   Author
	       multiple	  1
	       size   3
	   </elements>
	   <elements>
	       value   Submit
	       name   submit
	       type   Submit
	   </elements>
	   indicator   submit

AUTHOR
       Kennedy Clark, "hkclark@gmail.com"

       Feel free to contact the	author for any errors or suggestions, but the
       best way	to report issues is via	the CPAN RT Bug	system at
       <https://rt.cpan.org/Public/Dist/Display.html?Name=Catalyst-Manual>.

       Copyright 2006-2011, Kennedy Clark, under the Creative Commons
       Attribution Share-Alike License Version 3.0
       (<https://creativecommons.org/licenses/by-sa/3.0/us/>).

perl v5.32.1	     Catalyst::Manual::Tutorial::09_AdvancedCRUD::09_FormFu(3)

NAME | OVERVIEW | DESCRIPTION | HTML::FormFu FORM CREATION | HTML::FormFu VALIDATION AND FILTERING | CREATE AND UPDATE/EDIT ACTION | AUTHOR

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Catalyst::Manual::Tutorial::09_AdvancedCRUD::09_FormFu&sektion=3&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help