package Maypole::Model::CDBI;
-use base qw(Maypole::Model::Base Class::DBI);
-use Lingua::EN::Inflect::Number qw(to_PL);
-use Class::DBI::AsForm;
-use Class::DBI::FromCGI;
-use Class::DBI::Loader;
-use Class::DBI::AbstractSearch;
-use Class::DBI::Plugin::RetrieveAll;
-use Class::DBI::Pager;
-use CGI::Untaint;
use strict;
=head1 NAME
=head1 DESCRIPTION
-This is a master model class which uses C<Class::DBI> to do all the hard
+This is a master model class which uses L<Class::DBI> to do all the hard
work of fetching rows and representing them as objects. It is a good
model to copy if you're replacing it with other database abstraction
modules.
+It implements a base set of methods required for a Maypole Data Model.
+
+It inherits accessor and helper methods from L<Maypole::Model::Base>.
+
+When specified as the application model, it will use Class::DBI::Loader
+to generate the model classes from the provided database. If you do not
+wish to use this functionality, use L<Maypole::Model::CDBI::Plain> which
+will instead use Class::DBI classes provided.
+
=cut
-sub related {
- my ($self, $r) = @_;
- # Has-many methods; XXX this is a hack
- map {to_PL($_)}
- grep { exists $r->{config}{ok_tables}{$_} }
- map {$_->table}
- keys %{shift->__hasa_list || {}}
-}
-
-sub do_edit :Exported {
- my ($self, $r) = @_;
- my $h = CGI::Untaint->new(%{$r->{params}});
- my ($obj) = @{$r->objects};
- if ($obj) {
- # We have something to edit
- $obj->update_from_cgi($h);
- warn "Updating an object ($obj) with ".Dumper($h); use Data::Dumper;
- } else {
- $obj = $self->create_from_cgi($h);
+use base qw(Maypole::Model::Base Class::DBI);
+#use Class::DBI::Plugin::Type;
+use Class::DBI::Loader;
+use Class::DBI::AbstractSearch;
+use Class::DBI::Plugin::RetrieveAll;
+use Class::DBI::Pager;
+use Lingua::EN::Inflect::Number qw(to_PL);
+use attributes ();
+
+use Maypole::Model::CDBI::AsForm;
+use Maypole::Model::CDBI::FromCGI;
+use CGI::Untaint::Maypole;
+
+=head2 Untainter
+
+Set the class you use to untaint and validate form data
+Note it must be of type CGI::Untaint::Maypole (takes $r arg) or CGI::Untaint
+
+=cut
+sub Untainter { 'CGI::Untaint::Maypole' };
+
+# or if you like bugs
+
+#use Class::DBI::FromCGI;
+#use CGI::Untaint;
+#sub Untainter { 'CGI::Untaint' };
+
+
+__PACKAGE__->mk_classdata($_) for (qw/COLUMN_INFO/);
+
+=head1 Action Methods
+
+Action methods are methods that are accessed through web (or other public) interface.
+
+=head2 do_edit
+
+If there is an object in C<$r-E<gt>objects>, then it should be edited
+with the parameters in C<$r-E<gt>params>; otherwise, a new object should
+be created with those parameters, and put back into C<$r-E<gt>objects>.
+The template should be changed to C<view>, or C<edit> if there were any
+errors. A hash of errors will be passed to the template.
+
+=cut
+
+sub do_edit : Exported {
+ my ($self, $r, $obj) = @_;
+
+ my $config = $r->config;
+ my $table = $r->table;
+
+ # handle cancel button hit
+ if ( $r->{params}->{cancel} ) {
+ $r->template("list");
+ $r->objects( [$self->retrieve_all] );
+ return;
+ }
+
+ my $required_cols = $config->{$table}{required_cols} || [];
+ my $ignored_cols = $config->{$table}{ignore_cols} || [];
+
+ ($obj, my $fatal, my $creating) = $self->_do_update_or_create($r, $obj, $required_cols, $ignored_cols);
+
+ # handle errors, if none, proceed to view the newly created/updated object
+ my %errors = $fatal ? (FATAL => $fatal) : $obj->cgi_update_errors;
+
+ if (%errors) {
+ # Set it up as it was:
+ $r->template_args->{cgi_params} = $r->params;
+
+ # replace user unfriendly error messages with something nicer
+
+ foreach (@{$config->{$table}->{required_cols}}) {
+ next unless ($errors{$_});
+ my $key = $_;
+ s/_/ /g;
+ $r->template_args->{errors}{ucfirst($_)} = 'This field is required, please provide a valid value';
+ $r->template_args->{errors}{$key} = 'This field is required, please provide a valid value';
+ delete $errors{$key};
}
- if (my %errors = $obj->cgi_update_errors) {
- # Set it up as it was:
- warn "There were errors: ".Dumper(\%errors)."\n";
- $r->{template_args}{cgi_params} = $r->{params};
- $r->{template_args}{errors} = \%errors;
- $r->{template} = "edit";
- } else {
- $r->{template} = "view";
+
+ foreach (keys %errors) {
+ my $key = $_;
+ s/_/ /g;
+ $r->template_args->{errors}{ucfirst($_)} = 'Please provide a valid value for this field';
+ $r->template_args->{errors}{$key} = 'Please provide a valid value for this field';
}
- $r->objects([ $obj ]);
+
+ undef $obj if $creating;
+
+ die "do_update failed with error : $fatal" if ($fatal);
+ $r->template("edit");
+ } else {
+ $r->template("view");
+ }
+
+
+
+ $r->objects( $obj ? [$obj] : []);
}
-sub delete :Exported {
- my ($self, $r) = @_;
- $_->SUPER::delete for @{ $r->objects };
- $r->objects([ $self->retrieve_all ]);
- $r->{template} = "list";
+# split out from do_edit to be reported by Mp::P::Trace
+sub _do_update_or_create {
+ my ($self, $r, $obj, $required_cols, $ignored_cols) = @_;
+
+ my $fatal;
+ my $creating = 0;
+
+ my $h = $self->Untainter->new( %{$r->params} );
+
+ # update or create
+ if ($obj) {
+ # We have something to edit
+ eval { $obj->update_from_cgi( $r => {
+ required => $required_cols,
+ ignore => $ignored_cols,
+ });
+ $obj->update(); # pos fix for bug 17132 'autoupdate required by do_edit'
+ };
+ $fatal = $@;
+ } else {
+ eval {
+ $obj = $self->create_from_cgi( $r => {
+ required => $required_cols,
+ ignore => $ignored_cols,
+ } );
+ };
+ $fatal = $@;
+ $creating++;
+ }
+ return $obj, $fatal, $creating;
}
-sub adopt {
- my ($self, $child) = @_;
- $child->autoupdate(1);
- $child->columns( Stringify => qw/ name / );
+
+# split out from do_edit to be reported by Mp::P::Trace
+#sub _do_update_or_create {
+# my ($self, $r, $obj, $required_cols, $ignored_cols) = @_;
+#
+# my $fatal;
+# my $creating = 0;
+#
+# my $h = $self->Untainter->new( %{$r->params} );
+#
+# # update or create
+# if ($obj) {
+# # We have something to edit
+# eval { $obj->update_from_cgi( $h => {
+# required => $required_cols,
+# ignore => $ignored_cols,
+# } );
+# $obj->update(); # pos fix for bug 17132 'autoupdate required by do_edit'
+# };
+# $fatal = $@;
+# } else {
+# eval {
+# $obj = $self->create_from_cgi( $h => {
+# required => $required_cols,
+# ignore => $ignored_cols,
+# } );
+# };
+# $fatal = $@;
+# $creating++;
+# }
+#
+# return $obj, $fatal, $creating;
+#}
+
+=head2 delete
+
+Deprecated method that calls do_delete or a given classes delete method, please
+use do_delete instead
+
+=head2 do_delete
+
+Unsuprisingly, this command causes a database record to be forever lost.
+
+This method replaces the, now deprecated, delete method provided in prior versions
+
+=cut
+
+sub delete : Exported {
+ my $self = shift;
+ my ($sub) = (caller(1))[3];
+ # So subclasses can still send delete down ...
+ $sub =~ /^(.+)::([^:]+)$/;
+ if ($1 ne "Maypole::Model::Base" && $2 ne "delete") {
+ $self->SUPER::delete(@_);
+ } else {
+ warn "Maypole::Model::CDBI delete method is deprecated\n";
+ $self->do_delete(@_);
+ }
+}
+
+sub do_delete {
+ my ( $self, $r ) = @_;
+ # FIXME: handle fatal error with exception
+ $_->SUPER::delete for @{ $r->objects || [] };
+# $self->dbi_commit;
+ $r->objects( [ $self->retrieve_all ] );
+ $r->{template} = "list";
+ $self->list($r);
+}
+
+=head2 search
+
+Deprecated searching method - use do_search instead.
+
+=head2 do_search
+
+This action method searches for database records, it replaces
+the, now deprecated, search method previously provided.
+
+=cut
+
+sub search : Exported {
+ my $self = shift;
+ my ($sub) = (caller(1))[3];
+ $sub =~ /^(.+)::([^:]+)$/;
+ # So subclasses can still send search down ...
+ return ($1 ne "Maypole::Model::Base" && $2 ne "search") ?
+ $self->SUPER::search(@_) : $self->do_search(@_);
}
-sub search :Exported {
- return shift->SUPER::search(@_) if caller eq "Class::DBI"; # oops
- my ($self, $r) = @_;
- my %fields = map {$_ => 1 } $self->columns;
- my $oper = "like"; # For now
- use Carp; Carp::confess("Urgh") unless ref $r;
- my %params = %{$r->{params}};
- my %values = map { $_ => {$oper, $params{$_} } }
- grep { $params{$_} and $fields{$_} } keys %params;
+sub do_search : Exported {
+ my ( $self, $r ) = @_;
+ my %fields = map { $_ => 1 } $self->columns;
+ my $oper = "like"; # For now
+ my %params = %{ $r->{params} };
+ my %values = map { $_ => { $oper, $params{$_} } }
+ grep { defined $params{$_} && length ($params{$_}) && $fields{$_} }
+ keys %params;
- $r->objects([ %values ? $self->search_where(%values) : $self->retrieve_all ]);
$r->template("list");
+ if ( !%values ) { return $self->list($r) }
+ my $order = $self->order($r);
+ $self = $self->do_pager($r);
+ $r->objects(
+ [
+ $self->search_where(
+ \%values, ( $order ? { order_by => $order } : () )
+ )
+ ]
+ );
$r->{template_args}{search} = 1;
}
-sub list :Exported {
- my ($self, $r) = @_;
- my %ok_columns = map {$_ => 1} $self->columns;
- if ( my $rows = $r->config->{rows_per_page}) {
- $self = $self->pager($rows, $r->query->{page});
- $r->{template_args}{pager} = $self;
- }
- my $order;
- if ($order = $r->query->{order} and $ok_columns{$order}) {
- $r->objects([ $self->retrieve_all_sorted_by( $order.
- ($r->query->{o2} eq "desc" && " DESC")
- )]);
- } else {
- $r->objects([ $self->retrieve_all ]);
+=head2 list
+
+The C<list> method fills C<$r-E<gt>objects> with all of the
+objects in the class. The results are paged using a pager.
+
+=cut
+
+sub list : Exported {
+ my ( $self, $r ) = @_;
+ my $order = $self->order($r);
+ $self = $self->do_pager($r);
+ if ($order) {
+ $r->objects( [ $self->retrieve_all_sorted_by($order) ] );
+ }
+ else {
+ $r->objects( [ $self->retrieve_all ] );
+ }
+}
+
+###############################################################################
+# Helper methods
+
+=head1 Helper Methods
+
+
+=head2 adopt
+
+This class method is passed the name of a model class that represensts a table
+and allows the master model class to do any set-up required.
+
+=cut
+
+sub adopt {
+ my ( $self, $child ) = @_;
+ $child->autoupdate(1);
+ if ( my $col = $child->stringify_column ) {
+ $child->columns( Stringify => $col );
+ }
+}
+
+
+=head2 related
+
+This method returns a list of has-many accessors. A brewery has many
+beers, so C<BeerDB::Brewery> needs to return C<beers>.
+
+=cut
+
+sub related {
+ my ( $self, $r ) = @_;
+ return keys %{ $self->meta_info('has_many') || {} };
+}
+
+
+=head2 related_class
+
+Given an accessor name as a method, this function returns the class this accessor returns.
+
+=cut
+
+sub related_class {
+ my ( $self, $r, $accessor ) = @_;
+ my $meta = $self->meta_info;
+ my @rels = keys %$meta;
+ my $related;
+ foreach (@rels) {
+ $related = $meta->{$_}{$accessor};
+ last if $related;
+ }
+ return unless $related;
+
+ my $mapping = $related->{args}->{mapping};
+ if ( $mapping and @$mapping ) {
+ return $related->{foreign_class}->meta_info('has_a')->{$$mapping[0]}->{foreign_class};
+ }
+ else {
+ return $related->{foreign_class};
+ }
+ }
+
+=head2 related_meta
+
+ $class->related_meta($col);
+
+Given a column associated with a relationship it will return the relatation
+ship type and the meta info for the relationship on the column.
+
+=cut
+
+sub related_meta {
+ my ($self,$r, $accssr) = @_;
+ $self->_croak("You forgot to put the place holder for 'r' or forgot the accssr parameter") unless $accssr;
+ my $class_meta = $self->meta_info;
+ if (my ($rel_type) = grep { defined $class_meta->{$_}->{$accssr} }
+ keys %$class_meta)
+ { return $rel_type, $class_meta->{$rel_type}->{$accssr} };
+}
+
+
+
+=head2 stringify_column
+
+ Returns the name of the column to use when stringifying
+ and object.
+
+=cut
+
+sub stringify_column {
+ my $class = shift;
+ return (
+ $class->columns("Stringify"),
+ ( grep { /^(name|title)$/i } $class->columns ),
+ ( grep { /(name|title)/i } $class->columns ),
+ ( grep { !/id$/i } $class->primary_columns ),
+ )[0];
+}
+
+=head2 do_pager
+
+ Sets the pager template argument ($r->{template_args}{pager})
+ to a Class::DBI::Pager object based on the rows_per_page
+ value set in the configuration of the application.
+
+ This pager is used via the pager macro in TT Templates, and
+ is also accessible via Mason.
+
+=cut
+
+sub do_pager {
+ my ( $self, $r ) = @_;
+ if ( my $rows = $r->config->rows_per_page ) {
+ return $r->{template_args}{pager} =
+ $self->pager( $rows, $r->query->{page} );
}
+ else { return $self }
+}
+
+
+=head2 order
+
+ Returns the SQL order syntax based on the order parameter passed
+ to the request, and the valid columns.. i.e. 'title ASC' or 'date_created DESC'.
+
+ $sql .= $self->order($r);
+
+ If the order column is not a column of this table,
+ or an order argument is not passed, then the return value is undefined.
+
+ Note: the returned value does not start with a space.
+
+=cut
+
+sub order {
+ my ( $self, $r ) = @_;
+ my %ok_columns = map { $_ => 1 } $self->columns;
+ my $q = $r->query;
+ my $order = $q->{order};
+ return unless $order and $ok_columns{$order};
+ $order .= ' DESC' if $q->{o2} and $q->{o2} eq 'desc';
+ return $order;
}
+=head2 setup
+
+ This method is inherited from Maypole::Model::Base and calls setup_database,
+ which uses Class::DBI::Loader to create and load Class::DBI classes from
+ the given database schema.
+
+=cut
+
+=head2 setup_database
+
+The $opts argument is a hashref of options. The "options" key is a hashref of
+Database connection options . Other keys may be various Loader arguments or
+flags. It has this form:
+ {
+ # DB connection options
+ options { AutoCommit => 1 , ... },
+ # Loader args
+ relationships => 1,
+ ...
+ }
+
+=cut
+
sub setup_database {
- my ($self, $config, $namespace, $dsn) = @_;
- $config->{dsn} = $dsn;
- $config->{loader} = Class::DBI::Loader->new(
- namespace => $namespace,
- dsn => $dsn
+ my ( $class, $config, $namespace, $dsn, $u, $p, $opts ) = @_;
+ $dsn ||= $config->dsn;
+ $u ||= $config->user;
+ $p ||= $config->pass;
+ $opts ||= $config->opts;
+ $config->dsn($dsn);
+ warn "No DSN set in config" unless $dsn;
+ $config->loader || $config->loader(
+ Class::DBI::Loader->new(
+ namespace => $namespace,
+ dsn => $dsn,
+ user => $u,
+ password => $p,
+ %$opts,
+ )
);
$config->{classes} = [ $config->{loader}->classes ];
$config->{tables} = [ $config->{loader}->tables ];
+
+ my @table_class = map { $_ . " => " . $config->{loader}->_table2class($_) } @{ $config->{tables} };
+ warn( 'Loaded tables to classes: ' . join ', ', @table_class )
+ if $namespace->debug;
}
+=head2 class_of
+
+ returns class for given table
+
+=cut
+
sub class_of {
- my ($self, $r, $table) = @_;
- return $r->config->{loader}->_table2class($table);
+ my ( $self, $r, $table ) = @_;
+ return $r->config->loader->_table2class($table); # why not find_class ?
}
-1;
+=head2 fetch_objects
+
+Returns 1 or more objects of the given class when provided with the request
+
+=cut
+
+sub fetch_objects {
+ my ($class, $r)=@_;
+ my @pcs = $class->primary_columns;
+ if ( $#pcs ) {
+ my %pks;
+ @pks{@pcs}=(@{$r->{args}});
+ return $class->retrieve( %pks );
+ }
+ return $class->retrieve( $r->{args}->[0] );
+}
+
+
+
+
+=head2 _isa_class
+
+Private method to return the class a column
+belongs to that was inherited by an is_a relationship.
+This should probably be public but need to think of API
+
+=cut
+
+sub _isa_class {
+ my ($class, $col) = @_;
+ $class->_croak( "Need a column for _isa_class." ) unless $col;
+ my $isaclass;
+ my $isa = $class->meta_info("is_a") || {};
+ foreach ( keys %$isa ) {
+ $isaclass = $isa->{$_}->foreign_class;
+ return $isaclass if ($isaclass->find_column($col));
+ }
+ return; # col not in a is_a class
+}
+
+
+
+# Thanks to dave baird -- form builder for these private functions
+sub _column_info {
+ my $self = shift;
+ my $dbh = $self->db_Main;
+ return $self->COLUMN_INFO if ref $self->COLUMN_INFO;
+
+ my $meta; # The info we are after
+ my ($catalog, $schema) = (undef, undef);
+ # Dave is suspicious this (above undefs) could
+ # break things if driver useses this info
+
+ # '%' is a search pattern for columns - matches all columns
+ if ( my $sth = $dbh->column_info( $catalog, $schema, $self->table, '%' ) )
+ {
+ $dbh->errstr && die "Error getting column info sth: " . $dbh->errstr;
+ $self->COLUMN_INFO( $self->_hash_type_meta( $sth ) );
+# use Data::Dumper; warn "col info for typed is " . Dumper($self->COLUMN_INFO);
+ }
+ else
+ {
+ $self->COLUMN_INFO( $self->_hash_typeless_meta( ) );
+# use Data::Dumper; warn "col info TYPELESS is " . Dumper($self->COLUMN_INFO);
+ }
+ return $self->COLUMN_INFO;
+}
+
+sub _hash_type_meta
+{
+ my ($self, $sth) = @_;
+ my $meta;
+ while ( my $row = $sth->fetchrow_hashref )
+
+ {
+ my ($col_meta, $col_name);
+
+ foreach my $key ( keys %$row)
+ {
+ my $value = $row->{$key} || $row->{ uc $key };
+ $col_meta->{$key} = $value;
+ $col_name = $row->{COLUMN_NAME} || $row->{column_name};
+ }
+
+ $meta->{$col_name} = $col_meta;
+ }
+ return $meta;
+}
+
+# typeless db e.g. sqlite
+sub _hash_typeless_meta
+{
+ my ( $self ) = @_;
+
+ $self->set_sql( fb_meta_dummy => 'SELECT * FROM __TABLE__ WHERE 1=0' )
+ unless $self->can( 'sql_fb_meta_dummy' );
+
+ my $sth = $self->sql_fb_meta_dummy;
+
+ $sth->execute or die "Error executing column info: " . $sth->errstr;;
+
+ # see 'Statement Handle Attributes' in the DBI docs for a list of available attributes
+ my $cols = $sth->{NAME};
+ my $types = $sth->{TYPE};
+ # my $sizes = $sth->{PRECISION}; # empty
+ # my $nulls = $sth->{NULLABLE}; # empty
+
+ # we haven't actually fetched anything from the sth, so need to tell DBI we're not going to
+ $sth->finish;
+
+ my $order = 0;
+ my $meta;
+ foreach my $col ( @$cols )
+ {
+ my $col_meta;
+
+ $col_meta->{NULLABLE} = 1;
+
+ # in my limited testing, the columns are returned in the same order as they were defined in the schema
+ $col_meta->{ORDINAL_POSITION} = $order++;
+
+ # type_name is taken literally from the schema, but is not actually used by sqlite,
+ # so it can be anything, e.g. varchar or varchar(xxx) or VARCHAR etc.
+ my $type = shift( @$types );
+ $type =~ /(\w+)\((\w+)\)/;
+ $col_meta->{type} = $type;
+ $col_meta->{TYPE_NAME} = $1;
+ my $size = $2;
+ $col_meta->{COLUMN_SIZE} = $size if $type =~ /(CHAR|INT)/i;
+ $meta->{$col} = $col_meta;
+ }
+ return $meta;
+}
+
+
+
+=head2 column_type
+
+ my $type = $class->column_type('column_name');
+
+This returns the 'type' of this column (VARCHAR(20), BIGINT, etc.)
+For now, it returns "BOOL" for tinyints.
+
+TODO :: TEST with enums and postgres
+
+=cut
+sub column_type {
+ my $class = shift;
+ my $col = shift or die "Need a column for column_type";
+ my $info = $class->_column_info->{$col} ||
+ eval { $class->_isa_class($col)->_column_info($col) } ||
+ return '';
+
+ my $type = $info->{mysql_type_name} || $info->{type};
+ unless ($type) {
+ $type = $info->{TYPE_NAME};
+ if ($info->{COLUMN_SIZE}) { $type .= "($info->{COLUMN_SIZE})"; }
+ }
+ # Bool if tinyint
+ if ($type and $type =~ /^tinyint/i and $info->{COLUMN_SIZE} == 1) {
+ $type = 'BOOL';
+ }
+ return $type;
+}
+
+=head2 column_nullable
+
+Returns true if a column can be NULL and false if not.
+
+=cut
+
+sub column_nullable {
+ my $class = shift;
+ my $col = shift or $class->_croak( "Need a column for column_nullable" );
+ my $info = $class->_column_info->{$col} ||
+ eval { $class->_isa_class($col)->_column_info($col) } ||
+ return 1;
+ return $info->{NULLABLE};
+}
+
+=head2 column_default
+
+Returns default value for column or the empyty string.
+Columns with NULL, CURRENT_TIMESTAMP, or Zeros( 0000-00...) for dates and times
+have '' returned.
+
+=cut
+
+sub column_default {
+ my $class = shift;
+ my $col = shift or $class->_croak( "Need a column for column_default");
+ #return unless $class->find_column($col); # not a real column
+
+ my $info = $class->_column_info->{$col} ||
+ eval { $class->_isa_class($col)->_column_info($col) } ||
+ return '';
+
+ my $def = $info->{COLUMN_DEF};
+ $def = '' unless defined $def;
+
+ # exclude defaults we don't want to display-- may need some additions here
+ if ( $class->column_type($col) =~ /^BOOL/i ) {
+ $def = $def ? 1 : 0; # allow 0 or 1 for bool cols
+ }
+ else {
+ $def = $def =~ /(^0000-00-00.*$|^0[0]*$|^0\.00$|CURRENT_TIMESTAMP|NULL)/i ? '' : $def ;
+
+ }
+ return $def;
+}
+
+
+
+=head2 get_classmetadata
+
+Gets class meta data *excluding cgi input* for the passed in class or the
+calling class. *NOTE* excludes cgi inputs. This method is handy to call from
+templates when you need some metadata for a related class.
+
+=cut
+
+sub get_classmetadata {
+ my ($self, $class) = @_; # class is class we want data for
+ $class ||= $self;
+ $class = ref $class || $class;
+
+ my %res;
+ $res{name} = $class;
+ $res{colnames} = {$class->column_names};
+ $res{columns} = [$class->display_columns];
+ $res{list_columns} = [$class->list_columns];
+ $res{moniker} = $class->moniker;
+ $res{plural} = $class->plural_moniker;
+ $res{table} = $class->table;
+ \%res;
+}
+
+
+1;
projects / maypole.git / blobdiff