File Coverage

blib/lib/CGI/Application/Plugin/BREAD.pm

Criterion	Covered	Total	%
statement	21	174	12.0
branch	0	26	0.0
condition	0	3	0.0
subroutine	7	22	31.8
pod	5	5	100.0
total	33	230	14.3

package CGI::Application::Plugin::BREAD;

use 5.006;
use strict;
use warnings;

use vars qw( @ISA @EXPORT @EXPORT_OK $VERSION );

use HTML::Template;
use HTML::FillInForm;

@ISA = qw( Exporter AutoLoader );

our @EXPORT_OK = qw(
    bread_db
    browse_page_size
    template_path
    template_type
    log_directive
);

our $VERSION = '0.12_2';

sub import
{
    my $caller = scalar( caller );
    $caller->add_callback( 'prerun' => \&_register_runmodes );
    goto &Exporter::import;
}

sub _register_runmodes
{
    my ( $self, %runmodes, $tables, $uri );
    $self = shift;

    #warn "CGI::Application::Plugin::BREAD::register_runmodes() called!";
    %runmodes = ( 'start' => \&_start );
    $tables = {};
    if ( $self->{'BREAD'}->{'classes'} ) {
        foreach my $cdbi_class ( @{$self->{'BREAD'}->{'classes'}} ) {
            my $table = $cdbi_class->table;
            $runmodes{ "browse_$table" }            = \&_browse;
            $runmodes{ "read_$table" }              = \&_read;
            $runmodes{ "edit_$table" }              = \&_edit;
            $runmodes{ "add_$table" }               = \&_add;
            $runmodes{ "delete_$table" }            = \&_delete;
            $runmodes{ 'add_'.$table.'_submit' }    = \&_submit;
            $runmodes{ 'edit_'.$table.'_submit' }   = \&_submit;
            $tables->{$table} = $cdbi_class;
        }
    } else {
        die "We don't have any db classes!  Did you set any up with the bread_db() method?";
    }
    $self->{'BREAD'}->{'tables'} = $tables;
    $uri = $ENV{'SCRIPT_URI'};
    # take off any tailing parameters...
    #$uri =~ s/\?.+//;
    $self->{'BREAD'}->{'uri'} = $uri;

    $self->run_modes( %runmodes );
}

sub bread_db
{
    my ( $self, $parameter, $classes );

    ( $self, $parameter ) = @_;
    #warn "CGI::Application::Plugin::BREAD::bread_db() called!";

    # check parameter type ... it's either an arrayref or a ::Loader ref
    $classes = [];
    if ( ref( $parameter ) eq 'ARRAY' ) {
        $self->{'BREAD'}->{'cdbi_type'} = 'classes';
        foreach my $cdbi_class ( @$parameter ) {
            # check to see if it's loaded already
            unless ( $cdbi_class:: ) {
                my ( $file );
                $file = $cdbi_class;
                $file =~ s-::-/-g;
                eval {
                    require "$file.pm";
                    $cdbi_class->import();
                };
                die "CGI::Application::Plugin::BREAD::bread_db(): Couldn't use $cdbi_class class: $@" if ( $@ );
            }
            push @$classes, $cdbi_class;
        }
    } elsif ( ref( $parameter ) =~ /^Class::DBI::Loader/ ) {
        $self->{'BREAD'}->{'cdbi_type'} = 'loader';
        foreach my $class ( $parameter->classes ) {
            push @$classes, $class;
        }
    } else {
        my $ref = ref( $parameter );
        die "CGI::Application::Plugin::BREAD::bread_db(): Invalid parameter\nParameter must either be an array reference of Class::DBI classes or a Class::DBI::Loader object\nYou gave me a $ref object.";
    }
    $self->{'BREAD'}->{'classes'} = $classes;
}

sub browse_page_size
{
    my ( $self, $size ) = @_;
    if ( $size =~ /^\d+$/ && $size > 0 ) {
        $self->{'BREAD'}->{'page_size'} = $size;
    } else {
        warn "CGI::Application::Plugin::BREAD::browse_page_size(): Invalid page_size ($size) - must be a positive decimal.";
    }
}

sub template_path
{
    warn "Sorry - this feature (CAP::Bread::template_path()) hasn't been implemented yet!";
}

sub template_type
{
    warn "Sorry - this feature (CAP::Bread::template_type()) hasn't been implemented yet!";
}

sub log_directive
{
    warn "Sorry - this feature (CAP::Bread::log_directive()) hasn't been implemented yet!";
}

sub _start
{
    my ( $self, $table_ar, $table_hr, $uri, $template_html, $template );
    $self = shift;

    $table_ar = [];
    $table_hr = $self->{'BREAD'}->{'tables'};
    while( my ( $table, undef ) = each %$table_hr ) {
        push @$table_ar, {
                'table' => $table,
            };
    }
    $uri = $self->{'BREAD'}->{'uri'};

    $template_html = <<_EOF_;


Database Administration


This application is setup to manage the following tables:


: ">Browse or ">Add




_EOF_

    $template = HTML::Template->new( 'scalarref' => \$template_html );
    $template->param( 'tables' => $table_ar );
    $template->output;
}

sub _browse
{
    my ( $self, $runmode, $table, $class, @columns, $colspan, @other_columns, $objects_iterator, $headers, $records, $subtemplate, $uri, $template_html, $template, $get_data_sub, $pager );

    $self = shift;
    $runmode = $self->get_current_runmode();
    ( $table ) = $runmode =~ /^browse_(.+)$/;

    $class = $self->{'BREAD'}->{'tables'}->{$table};
    $self->{'BREAD'}->{'page_size'} = 20 if ! $self->{'BREAD'}->{'page_size'};

    @columns = $class->columns;
    $colspan = scalar( @columns );
    $objects_iterator = $class->retrieve_all;
    $headers = [];
    $subtemplate = '';
    $uri = $self->{'BREAD'}->{'uri'};
    # pull out primary column (if we have it) first...
    if ( my $primary = $class->primary_column ) {
        push @$headers, { 'header' => $primary };
        $subtemplate .= qq%
        # now need to take it out of @columns
        @other_columns = grep( !/^$primary$/, @columns );
    } else {
        @other_columns = @columns;
    }
    foreach my $header ( sort @other_columns ) {
        push @$headers, { 'header' => $header };
        $subtemplate .= qq%
    }

    $template_html = <<_EOF_;


Database Administration :: Browsing <TMPL_VAR NAME="table" ESCAPE=HTML> Table




The  table has the following  records, broken up into  pages of  each:




   




205




 





 





 





 





 





 



    




206




 





 





 





 





 





 



      




207




 





 





 





 





 





 



      




208




 





 





 





 





 





 



      




209




 





 





 





 





 





 



      




210




 





 





 





 





 





 



      




211




 





 





 





 





 





 



    




212




 





 





 





 





 





 



      




213




 





 





 





 





 





 



         $subtemplate 




214




 





 





 





 





 





 



      




215




 





 





 





 





 





 



    




216




 





 





 





 





 





 



    




217




 





 





 





 





 





 



      




218




 





 





 





 





 





 



      




219




 





 





 





 





 





 



      




220




 





 





 





 





 





 



    




221




 





 





 





 





 





 



    




222








        $subtemplate














_EOF_

    $template = HTML::Template->new( 'scalarref' => \$template_html, 'global_vars' => 1 );
    $template->param(
            'table'     => $table,
            'headers'   => $headers,
            'count'     => $objects_iterator->count,
            'pagesize'  => $self->{'BREAD'}->{'page_size'},
            'num_pages' => sprintf( "%d", ($objects_iterator->count/$self->{'BREAD'}->{'page_size'})+1 )
        );

    $get_data_sub = sub
       {
            my ( $offset, $rows, @objects, $records );
            ( $offset, $rows ) = @_;
            @objects = $objects_iterator->slice( $offset, $rows+$offset-1 );
            $records = [];

            foreach my $obj ( @objects ) {
                my %data = ();
                foreach my $column ( @columns ) {
                    my $subdata = $obj->get( $column );
                    $subdata = ref( $subdata ) if ref( $subdata );
                    $data{$column} = $subdata;
                }
                push @$records, \%data;
            }

            return $records;
        };

    require HTML::Pager;
    $pager = HTML::Pager->new(
            'template'          => $template,
            'query'             => $self->query,
            'rows'              => $objects_iterator->count,
            'page_size'         => $self->{'BREAD'}->{'page_size'},
            'get_data_callback' => $get_data_sub,
            'persist_vars'      => [ 'rm' ],
        );
   return  $pager->output();
}

sub _read
{
    # not sure if this is needed...
}

sub _edit
{
    my ( $self, $runmode, $table, $html, $class, $obj, %data, $fif );

    $self = shift;
    $runmode = $self->get_current_runmode();
    ( $table ) = $runmode =~ /^edit_(.+)$/;

    $html = _get_add_or_edit_form( $self );

    $class = $self->{'BREAD'}->{'tables'}->{$table};
    $obj = $class->retrieve( $self->query->param( 'id' ) );
    %data = ();
    foreach my $column ( sort $class->columns ) {
        $data{ $column } = $obj->get( $column );
    }

    $fif = HTML::FillInForm->new();
    $fif->fill(
            'scalarref' => \$html,
            'fdat'      => \%data
        );
}

sub _add
{
    my ( $self );

    $self = shift;

    _get_add_or_edit_form( $self );
}

sub _delete
{
    my ( $self, $runmode, $table, $class, $obj );

    $self = shift;
    $runmode = $self->get_current_runmode();
    ( $table ) = $runmode =~ /^delete_(.+)$/;
    $class = $self->{'BREAD'}->{'tables'}->{$table};
    $obj = $class->retrieve( $self->query->param( 'id' ) );

    $obj->delete;

    $self->header_type( 'redirect' );
    $self->header_props( -url => $self->{'BREAD'}->{'uri'} );
}

sub _submit
{
    my ( $self, $runmode, $mode, $table, $class, $form );

    $self = shift;
    $runmode = $self->get_current_runmode();
    ( $mode, $table ) = $runmode =~ /^(add|edit)_(.+)_submit$/;
    $class = $self->{'BREAD'}->{'tables'}->{$table};

    $form = $class->as_form( params => $self->query );
    if ( $form->submitted ) {
        if ( $mode eq 'add' ) {
            my $obj = $class->create_from_form( $form );
        } elsif ( $mode eq 'edit' ) {
            my $obj = $class->update_from_form( $form );
        } else {
            warn "CGI::Application::Plugin::BREAD::_submit(): Unknown mode ($mode) - Expecting add or edit.";
        }
    }

    # redirecting user back to main page
    $self->header_type( 'redirect' );
    $self->header_props( -url => $self->{'BREAD'}->{'uri'} );
}

sub _get_add_or_edit_form
{
    my ( $self, $subtitle, $form, $rm_hidden, $runmode, $mode, $table, $class, $template_html, $template );

    $self = shift;

    if ( $self->query->param( 'id' ) ) {
        $subtitle = q%Editing Entry # %;
    } else {
        $subtitle = 'Adding an Entry';
    }

    $runmode = $self->get_current_runmode();
    ( $mode, $table ) = $runmode =~ /^(add|edit)_(.+)$/;
    $class = $self->{'BREAD'}->{'tables'}->{$table};
    $class->form_builder_defaults( { method => 'post' } );

    $form = $class->as_form( params => $self->query )->render;
    $rm_hidden = '';
    $form =~ s/

    $template_html = <<_EOF_;


Database Administration :: $subtitle to the <TMPL_VAR NAME="table" ESCAPE=HTML> Table



$form



_EOF_

    $template = HTML::Template->new( 'scalarref' => \$template_html, 'associate' => $self->query );
    $template->param(
            'table'     => $table,
        );
    $template->output;
}

1;
__END__