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
use base qw(Maypole::Model::Base Class::DBI);
-use Maypole::Model::CDBI::AsForm;
-use CGI::Untaint::Maypole;
-
-use Class::DBI::FromCGI;
+#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 ();
-###############################################################################
-# Helper methods
+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.
-=item do_edit
+=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
my $config = $r->config;
my $table = $r->table;
- # handle cancel button hits
+ # 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 = $r->{config}{ $r->{table} }{ignore_cols} || [];
+ 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);
if (%errors) {
# Set it up as it was:
$r->template_args->{cgi_params} = $r->params;
- $r->template_args->{errors} = \%errors;
+
+ # 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};
+ }
+
+ 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';
+ }
undef $obj if $creating;
+
+ die "do_update failed with error : $fatal" if ($fatal);
$r->template("edit");
} else {
$r->template("view");
}
+
+
$r->objects( $obj ? [$obj] : []);
}
my $fatal;
my $creating = 0;
- my $h = CGI::Untaint::Maypole->new( %{$r->params} );
+
+ my $h = $self->Untainter->new( %{$r->params} );
# update or create
if ($obj) {
# We have something to edit
- eval { $obj->update_from_cgi( $h => {
+ 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( $h => {
+ eval {
+ $obj = $self->create_from_cgi( $r => {
required => $required_cols,
ignore => $ignored_cols,
- } )
- };
-
- if ($fatal = $@) {
- warn "$fatal" if $r->debug;
- }
- $creating++;
+ } );
+ };
+ $fatal = $@;
+ $creating++;
}
-
return $obj, $fatal, $creating;
}
+# 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.
sub delete : Exported {
my $self = shift;
my ($sub) = (caller(1))[3];
+ # So subclasses can still send delete down ...
$sub =~ /^(.+)::([^:]+)$/;
- # So subclasses can still send search down ...
- return ($1 ne "Maypole::Model::Base" && $2 ne "delete") ?
- $self->SUPER::search(@_) : $self->do_delete(@_);
+ 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
}
}
-#######################
-# _process_local_srch #
-#######################
-
-# Makes the local part of the db search query
-# Puts search prams local to this table in where array.
-# Returns a where array ref and search criteria string.
-# This is factored out of do_search so sub classes can override this part
-sub _process_local_srch {
- my ($self, $hashed) = @_;
- my %fields = map { $_ => 1 } $self->columns;
- my $moniker = $self->moniker;
- my %colnames = $self->column_names;
- my $srch_crit = '';
- my ($oper, $wc);
- my @where = map {
- # prelim
- $srch_crit .= ' '.$colnames{$_}." = '".$hashed->{$_}."'";
- $oper = $self->sql_search_oper($_);
- $wc = $oper =~ /LIKE/i ? '%':''; # match any substr
- "$moniker.$_ $oper '$wc" . $hashed->{$_} . "$wc'"; #the where clause
- }
- grep { defined $hashed->{$_} && length ($hashed->{$_}) && $fields{$_} }
- keys %$hashed;
-
- return (\@where, $srch_crit);
-}
-
-#########################
-# _process_foreign_srch #
-#########################
-
-# puts foreign search fields into select statement
-# changes @where by ref and return sel and srch_criteria string
-sub _process_foreign_srch {
- my ($self, $hashed, $sel, $where, $srch_crit) = @_;
- my %colnames = $self->column_names;
- my $moniker = $self->moniker;
- my %foreign;
- foreach (keys %$hashed) {
- $foreign{$_} = delete $hashed->{$_} if ref $hashed->{$_};
- }
- my %accssr_class = %{$self->accessor_classes};
- while (my ( $accssr, $prms) = each %foreign ) {
- my $fclass = $accssr_class{$accssr};
- my %fields = map { $_ => 1 } $fclass->columns;
- my %colnames = $fclass->column_names;
- my ($oper, $wc);
- my @this_where =
- # TODO make field name match in all cases in srch crit
- map {
- # prelim
- $srch_crit.= ' '.$colnames{$_}." = '".$prms->{$_}."'";
- $oper = $fclass->sql_search_oper($_);
- $wc = $oper =~ /LIKE/i ? '%':'';
- "$accssr.$_ $oper '$wc".$prms->{$_}."$wc'"; # the where
- }
- grep { defined $prms->{$_} && length ($prms->{$_}) && $fields{$_} }
- keys %$prms;
-
- next unless @this_where;
- $sel .= ", " . $fclass->table . " $accssr"; # add foreign tables to from
-
- # map relationships -- TODO use constraints in has_many and mhaves
- # and make general
- my $pk = $self->primary_column;
- if ($fclass->find_column('owner_id') && $fclass->find_column('owner_table') ) {
- unshift @this_where, ("$accssr.owner_id = $moniker.$pk",
- "$accssr.owner_table = '" . $self->table ."'");
- }
- # for has_own, has_a where foreign id is in self's table
- elsif ( my $fk = $self->find_column($fclass->primary_column) ) {
- unshift @this_where, "$accssr." . $fk->name . " = $moniker." . $fk->name;
- }
- push @$where, @this_where;
- }
- return ($sel, $srch_crit);
-}
-
###############################################################################
# Helper methods
}
}
-=head2 is_class
-
-Tell if action is a class method (See Maypole::Plugin::Menu)
-
-=cut
-
-sub is_class {
- my ( $self, $method, $attrs ) = @_;
- die "Usage: method must be passed as first arg" unless $method;
- $attrs = join(' ',$self->method_attrs($method)) unless ($attrs);
- return 1 if $attrs =~ /\bClass\b/i;
- return 1 if $method =~ /^list$/; # default class actions
- return 0;
-}
-
-=head2 is_object
-
-Tell if action is a object method (See Maypole::Plugin::Menu)
-
-=cut
-
-sub is_object {
- my ( $self, $method, $attrs ) = @_;
- die "Usage: method must be passed as first arg" unless $method;
- $attrs = join(' ',$self->method_attrs($method)) unless ($attrs);
- return 1 if $attrs =~ /\bObject\b/i;
- return 1 if $method =~ /(^view$|^edit$|^delete$)/; # default object actions
- return 0;
-}
-
=head2 related
}
-=head2 isa_class
-
-Returns class of a column inherited by is_a.
-
-=cut
-
-# Maybe put this in IsA?
-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 0; # col not in a is_a class
-}
-
-=head2 accessor_classes
-
-Returns hash ref of classes for accessors.
-
-This is an attempt at a more efficient method than calling "related_class()"
-a bunch of times when you need it for many relations.
-It may be good to call at startup and store in a global config.
-
-=cut
-
-sub accessor_classes {
- my ($self, $class) = @_; # can pass a class arg to get accssor classes for
- $class ||= $self;
- my $meta = $class->meta_info;
- my %res;
- foreach my $rel (keys %$meta) {
- my $rel_meta = $meta->{$rel};
- %res = ( %res, map { $_ => $rel_meta->{$_}->{foreign_class} }
- keys %$rel_meta );
- }
- return \%res;
-
- # 2 liner to get class of accessor for $name
- #my $meta = $class->meta_info;
- #my ($isa) = map $_->foreign_class, grep defined,
- # map $meta->{$_}->{$name}, keys %$meta;
-
-}
-
=head2 stringify_column
+ Returns the name of the column to use when stringifying
+ and object.
+
=cut
sub stringify_column {
=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 {
=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 {
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 {
);
$config->{classes} = [ $config->{loader}->classes ];
$config->{tables} = [ $config->{loader}->tables ];
- warn( 'Loaded tables: ' . join ',', @{ $config->{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); # why not find_class ?
}
+=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;
}
-###############################################################################
-# private / internal functions and classes
+
+
+=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 $class = shift;
- $class = ref $class || $class;
- no strict 'refs';
- return ${$class . '::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