view release on metacpan or  search on metacpan

lib/Form/Processor/Model/RDBO.pm  view on Meta::CPAN

    if ( $@ ) {
        $foreign_manager = 'Rose::DB::Object::Manager';
        $foreign_manager->require or die "Unable to require $foreign_manager";
    }

    # Trying to determinate the active column the default value for
    # active_column is "name"
    my $active_column;
    if ( $foreign_class->can('active_column') ) {
        $active_column = $foreign_class->active_column;
    } elsif ( $self->can('active_column') ) {
        $active_column = $self->active_column;
    }

    # Check that active_column exists in foreign class columns list
    # If the active column does not exist in foreign class columns list
    # set it to '' (boolean false)
    #my @foreign_columns  = $foreign_class->meta->column_names;
    #$active_column = '' unless grep { $_ eq $active_column } @foreign_columns;
    # FIXME: can't simply check if column exists because relative column can be
    # specified: 't2.title'

    $active_column = "name" unless $active_column;

    my ( $primary_key )  = ( $foreign_class->meta->primary_key_column_names );

    my @options;
    # Fetch options only if active_column exists

    if ( $active_column ) {
        my %m_params = (
            'object_class' => $foreign_class,
            'select'       => [ $primary_key, $active_column ],
        );
        my $records = $foreign_manager->get_objects( %m_params);

        foreach my $r ( @$records ) {
            push @options,
              (
                  $r->$primary_key => $r->can( 'active_column_method' )
                ? $r->active_column_method()
                : $r->$active_column
              );
        }
    } else {
        warn 'active_column is undefined';
        @options = ();
    }
    
    return \@options;
}

=head2 update_from_form

Makes form validation and returns the filled RDBO item, filled by update_model.
It does not save the current item automatically. You should do this in your
code, after the call update_from_form.

=cut

sub update_from_form {
    my ( $self, $params ) = @_;
    return unless $self->validate( $params );
    return $self->update_model( $params );
}

=head2 update_model

Returns the new RDBO item, filled with passed form params. It does not save any
data to the database, just creates and fills new RDBO object.

=cut

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

    my $item = $self->item;
    my $class = ref( $item ) || $self->object_class;

    my %fields = map { $_->name, $_ } grep { !$_->noupdate } $self->fields;

    $item = $class->new() unless $item;
    while ( my ( $name, $field ) = each %fields ) {
        if ( $item->can( $name ) ) {
            if (   !$field->isa( 'Form::Processor::Field::Select' )
                && defined $item->$name
                && defined $field->value )
            {
                next if $item->$name eq $field->value;
            }

            $item->$name( $field->value );
        }
    }

    return $item;
}

=head2 model_validate

Does simple validation of fields, that you specified as unique in your form
profile. You are free to override this method if you want to implement much
serious model validation.

=cut

sub model_validate
{
    my ($self) = @_;
    return unless $self->validate_unique;
    return 1;
}

=head2 validate_unique

Internal method. Does simple validation of fields, that you specified as unique
in your form profile.

=cut

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

    my $unique = $self->profile->{ unique } || return 1;

    my $item = $self->item;

    my $class = ref( $item ) || $self->object_class;

    my $found_error = 0;

    for my $field ( map { $self->field( $_ ) } @$unique ) {
        next if $field->errors;