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

VERSION
    version 0.092830

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

      sub cgiapp_init  {
          my $self = shift;

          # see docs for L<CGI::Application::Plugin::DBH>
          $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)});

   Description
    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_and_sort
      my $resultset = $self->schema->resultset('Foo');
      my $result = $self->page_and_sort($resultset);

   Description
    This is a helper method that will first sort your data and then paginate
    it. Returns a resultset.

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

   Description
    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;

   Description
    This is just a basic accessor method for your schema

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

   Description
    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);

   Description
    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' });

   Description
    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' });

   Valid arguments are:
      rs - source loaded into schema

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

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

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

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

AUTHOR
      Arthur Axel "fREW" Schmidt <frioux+cpan@gmail.com>

COPYRIGHT AND LICENSE
    This software is copyright (c) 2009 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.

