NAME
   CGI::Application::Plugin::DBIx::Class - Access a DBIx::Class Schema from
   a CGI::Application

VERSION
   version 0.100210

SYNOPSIS
    use CGI::Application::Plugin::DBH (qw/dbh_config dbh/);
    use CGI::Application::Plugin::DBIx::Class ':all';

    sub cgiapp_init  {
        my $self = shift;

        $self->dbh_config($data_source, $username, $auth, \%attr);
        $self->dbic_config({schema => 'MyApp::Schema' });
    }

    sub person {
       my $self   = shift;
       my $id     = $self->query->param('id');
       my $person = $self->schema->resultset('People')->find($id);
       # ...
    }

    sub people {
       my $self   = shift;
       my $people = $self->page_and_sort(
           $self->simple_search(
              $self->schema->resultset('People')
           )
       );
       # ...
    }

DESCRIPTION
   This module helps you to map various DBIx::Class features to CGI
   parameters. For the most part that means it will help you search, sort,
   and paginate with a minimum of effort and thought. Currently it uses the
   connection from CGI::Application::Plugin::DBH.

METHODS
 dbic_config
    $self->dbic_config({schema => MyApp::Schema->connect(@connection_data)});

   You must run this method in setup or cgiapp_init to setup your schema.

   Valid arguments are:

    schema - Required, Name of DBIC Schema
    ignored_params - Optional, Params to ignore when doing a simple search or sort,
       defaults to
    [qw{limit start sort dir _dc rm xaction}]

    page_size - Optional, amount of results per page, defaults to 25

 page_and_sort
    my $resultset = $self->schema->resultset('Foo');
    my $result = $self->page_and_sort($resultset);

   This is a helper method that will first sort (with "simple_sort") your
   data and then paginate it. Returns a resultset.

 paginate
    my $resultset = $self->schema->resultset('Foo');
    my $result = $self->paginate($resultset);

   Paginates the passed in resultset based on the following CGI parameters:

    start - first row to display
    limit - amount of rows per page

   Returns a resultset.

 schema
    my $schema = $self->schema;

   This is just a basic accessor method for your schema

 search
    my $resultset   = $self->schema->resultset('Foo');
    my $searched_rs = $self->search($resultset);

   Calls the controller_search method on the passed in resultset with all
   of the CGI parameters. I like to have this look something like the
   following:

    # Base search dispatcher, defined in MyApp::Schema::ResultSet
    sub _build_search {
       my $self           = shift;
       my $dispatch_table = shift;
       my $q              = shift;

       my %search = ();
       my %meta   = ();

       foreach ( keys %{$q} ) {
          if ( my $fn = $dispatch_table->{$_} and $q->{$_} ) {
             my ( $tmp_search, $tmp_meta ) = $fn->( $q->{$_} );
             %search = ( %search, %{$tmp_search} );
             %meta   = ( %meta,   %{$tmp_meta} );
          }
       }

       return $self->search(\%search, \%meta);
    }

    # search method in specific resultset
    sub controller_search {
       my $self   = shift;
       my $params = shift;
       return $self->_build_search({
             status => sub {
                return { 'repair_order_status' => shift }, {};
             },
             part_id => sub {
                return {
                   'lineitems.part_id' => { -like => q{%}.shift( @_ ).q{%} }
                }, { join => 'lineitems' };
             },
             serial => sub {
                return {
                   'lineitems.serial' => { -like => q{%}.shift( @_ ).q{%} }
                }, { join => 'lineitems' };
             },
             id => sub {
                return { 'id' => shift }, {};
             },
             customer_id => sub {
                return { 'customer_id' => shift }, {};
             },
             repair_order_id => sub {
                return {
                   'repair_order_id' => { -like => q{%}.shift( @_ ).q{%} }
                }, {};
             },
          },$params
       );
    }

 sort
    my $resultset = $self->schema->resultset('Foo');
    my $result = $self->sort($resultset);

   Exactly the same as search, except calls controller_sort. Here is how I
   use it:

    # Base sort dispatcher, defined in MyApp::Schema::ResultSet
    sub _build_sort {
       my $self = shift;
       my $dispatch_table = shift;
       my $default = shift;
       my $q = shift;

       my %search = ();
       my %meta   = ();

       my $direction = $q->{dir};
       my $sort      = $q->{sort};

       if ( my $fn = $dispatch_table->{$sort} ) {
          my ( $tmp_search, $tmp_meta ) = $fn->( $direction );
          %search = ( %search, %{$tmp_search} );
          %meta   = ( %meta,   %{$tmp_meta} );
       } elsif ( $sort && $direction ) {
          my ( $tmp_search, $tmp_meta ) = $default->( $sort, $direction );
          %search = ( %search, %{$tmp_search} );
          %meta   = ( %meta,   %{$tmp_meta} );
       }

       return $self->search(\%search, \%meta);
    }

    # sort method in specific resultset
    sub controller_sort {
       my $self = shift;
       my $params = shift;
       return $self->_build_sort({
            first_name => sub {
               my $direction = shift;
               return {}, {
                  order_by => { "-$direction" => [qw{last_name first_name}] },
               };
            },
          }, sub {
         my $param = shift;
         my $direction = shift;
         return {}, {
            order_by => { "-$direction" => $param },
         };
          },$params
       );
    }

 simple_deletion
    $self->simple_deletion({ rs => 'Foo' });

   Deletes from the passed in resultset based on the following CGI
   parameter:

    to_delete - values of the ids of items to delete

   Valid arguments are:

    rs - resultset loaded into schema

   Note that this method uses the $rs->delete method, as opposed to
   $rs->delete_all

 simple_search
    my $searched_rs = $self->simple_search({ rs => 'Foo' });

   This method just searches on all of the CGI parameters that are not in
   the "ignored_params" with a like "%$value%". If there are multiple
   values it will make the search an "or" between the different values.

   Valid arguments are:

    rs - source loaded into schema

 simple_sort
    my $resultset = $self->schema->resultset('Foo');
    my $sorted_rs = $self->simple_sort($resultset);

   Sorts the passed in resultset based on the following CGI parameters:

    sort - field to sort by, defaults to primarky key
    dir  - direction to sort

SEE ALSO
   CGI::Application::Plugin::DBH

CREDITS
   Thanks to Micro Technology Services, Inc. for funding the initial
   development of this module.

AUTHOR
     Arthur Axel "fREW" Schmidt <[email protected]>

COPYRIGHT AND LICENSE
   This software is copyright (c) 2010 by Arthur Axel "fREW" Schmidt.

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

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.