catalystx::simplelogin::controller::login(3pm) [debian man page]

CatalystX::SimpleLogin::Controller::Login(3pm)		User Contributed Perl Documentation	    CatalystX::SimpleLogin::Controller::Login(3pm)

NAME

       CatalystX::SimpleLogin::Controller::Login - Configurable login controller

SYNOPSIS

	   # For simple useage exmple, see CatalystX::SimpleLogin, this is a
	   # full config example
	   __PACKAGE__->config(
	       'Controller::Login' => {
		   traits => [
		       'WithRedirect', # Optional, enables redirect-back feature
		       '-RenderAsTTTemplate', # Optional, allows you to use your own template
		   ],
		   actions => {
		       login => { # Also optional
			   PathPart => ['theloginpage'], # Change login action to /theloginpage
		       },
		   },
	       },
	   );

       See CatalystX::SimpleLogin::Form::Login for configuring the form.

DESCRIPTION

       Controller base class which exists to have login roles composed onto it for the login and logout actions.

ATTRIBUTES

   login_form_class
       A class attribute containing the class of the form to be initialised. One can override it in a derived class with the class of a new form,
       possibly subclassing CatalystX::SimpleLogin::Form::Login. For example:

	   package MyApp::Controller::Login;

	   use Moose;

	   extends('CatalystX::SimpleLogin::Controller::Login');

	   has '+login_form_class' => (
	       default => "MyApp::Form::Login",
	   );

	   1;

   login_form_class_roles
       An attribute containing an array reference of roles to be consumed by the form. One can override it in a similar way to "login_form_class":

	   package MyApp::Controller::Login;

	   use Moose;

	   extends('CatalystX::SimpleLogin::Controller::Login');

	   has '+login_form_class_roles' => (
	       default => sub { [qw(MyApp::FormRole::Foo MyApp::FormRole::Bar)] },
	   );

	   1;

METHODS

   BUILD
       Cause form instance to be built at application startup.

   do_post_login_redirect
       This method does a post-login redirect. TODO for BOBTFISH - should it even be public? If it does need to be public, then document it
       because the Pod coverage test failed.

   login
       Login action.

   login_redirect
       Redirect to the login action.

   login_GET
       Displays the login form

   login_POST
       Processes a submitted login form, and if correct, logs the user in and redirects

   not_required
       A stub action that is anchored at the root of the site ("/") and does not require registration (hence the name).

   redirect_after_login_uri
       If you are using WithRedirect (i.e. by default), then this methd is overridden to redirect the user back to the page they intially hit
       which required authentication.

       Note that even if the original URI was a post, then the redirect back will only be a GET.

       If you choose NOT to compose the WithRedirect trait, then you can set the uri users are redirected to with the "redirect_after_login_uri"
       config key, or by overriding the redirect_after_login_uri method in your own login controller if you need custom logic.

   render_login_form
       Renders the login form. By default it just calls the form's render method. If you want to do something different, like rendering the form
       with a template through your view, this is the place to hook into.

   required
       A stub action that is anchored at the root of the site ("/") and does require registration (hence the name).

SEE ALSO

       CatalystX::SimpleLogin::TraitFor::Controller::Login::WithRedirect
       CatalystX::SimpleLogin::Form::Login

AUTHORS

       See CatalystX::SimpleLogin for authors.

LICENSE

       See CatalystX::SimpleLogin for license.

perl v5.14.2							    2012-07-15			    CatalystX::SimpleLogin::Controller::Login(3pm)

HTML::FormHandler::Manual::Catalyst(3pm)		User Contributed Perl Documentation		  HTML::FormHandler::Manual::Catalyst(3pm)

NAME

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

VERSION

       version 0.40013

SYNOPSIS

       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.

DESCRIPTION

       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.

   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' }

	  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;

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

   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';
	   ....
	   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.

   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' );
	   ....
	   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" );
	      }
	   }

AUTHOR

       FormHandler Contributors - see HTML::FormHandler

COPYRIGHT AND LICENSE

       This software is copyright (c) 2012 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.14.2							    2012-06-25				  HTML::FormHandler::Manual::Catalyst(3pm)