HTML-FormHandler

 view release on metacpan or  search on metacpan

lib/HTML/FormHandler.pm  view on Meta::CPAN

    catch {
        die "Error occurred localizing error message for " . $self->name . ".  $_";
    };
    $self->push_form_errors($out);
    return;
}

sub get_default_value { }
sub _can_deflate { }

sub update_fields {
    my $self = shift;
    if( $self->has_update_field_list ) {
        my $updates = $self->update_field_list;
        foreach my $field_name ( keys %{$updates} ) {
            $self->update_field($field_name, $updates->{$field_name} );
        }
        $self->clear_update_field_list;
    }
    if( $self->has_defaults ) {
        my $defaults = $self->defaults;
        foreach my $field_name ( keys %{$defaults} ) {
            $self->update_field($field_name, { default => $defaults->{$field_name} } );
        }
        $self->clear_defaults;
    }
}

sub update_field {
    my ( $self, $field_name, $updates ) = @_;

    my $field = $self->field($field_name);
    unless( $field ) {
        die "Field $field_name is not found and cannot be updated by update_fields";
    }
    while ( my ( $attr_name, $attr_value ) = each %{$updates} ) {
        confess "invalid attribute '$attr_name' passed to update_field"
            unless $field->can($attr_name);
        if( $attr_name eq 'tags' ) {

lib/HTML/FormHandler/Model/CDBI.pm  view on Meta::CPAN

        my $match = $class->search( { $name => $value } )->first || next;
        next if $self->items_same( $item, $match );
        my $field_error = $field->unique_message ||
            'Value must be unique in the database';
        $field->add_error($field_error);
        $found_error++;
    }
    return $found_error;
}

sub update_model {
    my ($self) = @_;

    # Grab either the item or the object class.
    my $item = $self->item;
    my $class = ref($item) || $self->item_class;
    my $updated_or_created;

    # get a hash of all fields
    my %fields = map { $_->name, $_ } grep { !$_->noupdate } $self->fields;
    # First process the normal and has_a columns

lib/HTML/FormHandler/Model/Object.pm  view on Meta::CPAN

package HTML::FormHandler::Model::Object;
# ABSTRACT: stub for Object model
$HTML::FormHandler::Model::Object::VERSION = '0.40068';
use Moose::Role;

sub update_model {
    my $self = shift;

    my $item = $self->item;
    return unless $item;
    foreach my $field ( $self->all_fields ) {
        my $name = $field->name;
        next unless $item->can($name);
        $item->$name( $field->value );
    }
}

t/field_setup/update_fields.t  view on Meta::CPAN

    package Test::Field::Updates;
    use HTML::FormHandler::Moose;
    extends 'HTML::FormHandler';

    has 'form_id' => ( isa => 'Str', is => 'rw' );

    has_field 'foo';
    has_field 'bar';
    has_field 'blah' => ( type => 'Hidden' );

    sub update_fields {
        my $self = shift;
        $self->field('foo')->temp( 'foo_temp' );
        $self->field('bar')->default( 'foo_value' );
        $self->field('blah')->default( $self->form_id );
    }
}

$form = Test::Field::Updates->new;
$fif = {};
$form->process( form_id => 'page1form', params => $fif );

t/form_setup/no_update.t  view on Meta::CPAN

use Test::More;

{
    package MyApp::Form::Test;
    use HTML::FormHandler::Moose;
    extends 'HTML::FormHandler';

    has_field 'foo';
    has_field 'bar';

    sub update_model {
        my $self = shift;
        my $values = $self->values;
        $values->{foo} = 'updated';
        $self->_set_value($values);
    }
}

my $form = MyApp::Form::Test->new;
my $params = { foo => 'pfoo', bar => 'pbar' };
$form->process( params => $params );

t/memory_cycles.t  view on Meta::CPAN

    has_field 'entries.foo' => (
        type     => 'Text',
        required => 1,
    );
    has_field 'entries.bar' => (
        type     => 'Text',
        required => 1,
    );
    has_field 'some_select' => ( type => 'Select', inactive => 1 );

    sub update_model {
        my $self = shift;
        my $value = $self->field('some_select')->value;
    }
}

my $form = new_ok( 'My::RepeatableForm' );

my $params = {
    reqname => 'Testrequest',
    'entries.1.foo' => 'test1',

t/repeatable/reload.t  view on Meta::CPAN

    use HTML::FormHandler::Moose;
    extends 'HTML::FormHandler';

    has_field 'foo';
    has_field 'bar';
    has_field 'my_rep' => ( type => 'Repeatable' );
    has_field 'my_rep.rep_id' => ( type => 'PrimaryKey' );
    has_field 'my_rep.one';
    has_field 'my_rep.two';

    sub update_model {
        my $self = shift;
        my $value = $self->value;
        my $index = 1;
        foreach my $rep ( @{ $value->{my_rep} } ) {
            $rep->{rep_id} = $index;
            $index++;
        }
        $self->item( $value );
    }
}

 view all matches for this distribution
 view release on metacpan -  search on metacpan