Adam Paynter

NAME

Data::FormValidator::Constraints::HTTP - Simple Data::FormValidator constraint methods for checking various HTTP methods.

SYNOPSIS

    use Data::FormValidator;
    use Data::FormValidator::Constraints::HTTP qw( POST );
    
    my %input = (
        method => $request->method,
        author => $request->parameter('author'),
        name   => $request->parameter('name'),
    );
    
    my %profile = (
        required           => [ qw( method author ) ],
        optional           => [ qw( name ) ],
        constraint_methods => {
            method         => POST,
        },
    );
    
    my $results = Data::FormValidator->check( \%input, \%profile );
    
    # If $request->method was not 'POST', then this form validation 
    # will not be successful.
    

DESCRIPTION

This module provides some simple, Data::FormValidator compatible constraint methods for validating HTTP request methods. For example, it may be desirable to consider a form invalid until the request method is POST.

INTEGRATION WITH THE CATALYST WEB FRAMEWORK

I have found this technique of making forms invalid unless the request method is POST to be rather useful within the Catalyst web framework, using the FormValidator and FillInForm plugins.

The FillInForm plugin will automatically fill in an HTML form with the values located in $c->request->parameters *AS LONG AS THE CURRENT FORM IS INVALID*. We can use this behaviour to make our lives simpler. By placing the HTTP method constraint method in our validation profile, we can be guaranteed that FillInForm will engage if the method is not POST (it may still engage even if the method *IS* POST, depending on the form validation profile and the client's provided input).

    package My::App;
    
    use Catalyst qw( Static::Simple FillInForm FormValidator );
    
    1;
    
    
    
    ...
    
    
    
    package My::App::Controller::Root;
    
    use base qw( Catalyst::Controller );
    
    sub auto : Private {
        my ($self, $c) = @_;
        
        # The HTTP request method must be placed into the request 
        # parameters in order for the FormValidator plugin to check it.
        # This can easily be done in the root controller's "auto" 
        # action to avoid this in the various controllers.
        # Just another tip to make the code cleaner. :)
        $c->request->parameter( method => $c->request->method );
        
        1;
    }
    
    1;
    
    
    
    ...
    
    
    
    package My::App::Controller::Foo;
    
    use Data::FormValidator::Constraints::HTTP qw( POST );
    
    sub update : Local {
        my ($self, $c, $foo) = @_;
        $foo = $c->model('Schema::Foo')->find( $foo );
        
        $c->form(
            required           => [ qw( method name author ) ],
            constraint_methods => {
                method         => POST,
                name           => FV_min_length( 6 ),
                # ... yadda, yadda, yadda
            },
        );
        
        if ($c->form->success) {
            # you can be sure this will only be reached if the request 
            # method is POST and the rest of the request parameters 
            # have successfully passed the rest of your form validation 
            # profile.
            
            $foo->update_from_form( $c->form );
        }
        else {
            # By setting the parameters in this manner, FillInForm will 
            # automatically fill in the HTML form using the current 
            # object values, being overridden by any request parameters 
            # already specified. Meaning, if $foo get a field called 
            # 'title' and its value had already been set, FillInForm 
            # will place that value into the HTML form being presented 
            # to the client. However, if the request parameters include 
            # a value for 'title', *THAT* value gets placed in the 
            # HTML form.
            
            $c->request->parameters({
                $foo->get_columns,
                %{ $c->request->parameters },
            });
        }
    }
    
    1;
    

METHODS

http_method ( $method )

Returns a constraint method to determine whether or not a method is equal to the provided variable.

DELETE ( )

GET ( )

OPTIONS ( )

POST ( )

PUT ( )

TRACE ( )

Returns a constraint method to determine whether or not a method is equal to the name of the rule (i.e. - GET, POST, PUT, etc...).

SEE ALSO

  • Data::FormValidator

  • Data::FormValidator::Constraints

  • Catalyst

AUTHOR

Adam Paynter <adapay@cpan.org>

COPYRIGHT AND LICENSE

Copyright 2006 by Adam Paynter

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