File: README

package info (click to toggle)
libclass-dbi-fromcgi-perl 1.00-5
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 100 kB
  • sloc: perl: 279; makefile: 2
file content (154 lines) | stat: -rw-r--r-- 5,377 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
NAME
    Class::DBI::FromCGI - Update Class::DBI data using CGI::Untaint

SYNOPSIS
      package Film;
      use Class::DBI::FromCGI;
      use base 'Class::DBI';
      # set up as any other Class::DBI class.

      __PACKAGE__->untaint_columns(
        printable => [qw/Title Director/],
        integer   => [qw/DomesticGross NumExplodingSheep/],
        date      => [qw/OpeningDate/],
      );

      # Later on, over in another package ...

      my $h = CGI::Untaint->new( ... );
      my $film = Film->retrieve('Godfather II');
         $film->update_from_cgi($h);

      my $new_film = Film->create_from_cgi($h);

      if (my %errors = $film->cgi_update_errors) {
        while (my ($field, $problem) = each %errors) {
          warn "Problem with $field: $problem\n";
        }
      }

      # or
      $film->update_from_cgi($h => @columns_to_update);

      # or
      $film->update_from_cgi($h => { ignore => \@cols_to_ignore,
                                     required => \@cols_needed,
                                     all => \@columns_which_may_be_empty });

      my $how = $film->untaint_type('Title'); # printable

DESCRIPTION
    Lots of times, Class::DBI is used in web-based applications. (In fact,
    coupled with a templating system that allows you to pass objects, such
    as Template::Toolkit, Class::DBI is very much your friend for these.)

    And, as we all know, one of the most irritating things about writing
    web-based applications is the monotony of writing much of the same stuff
    over and over again. And, where there's monotony there's a tendency to
    skip over stuff that we all know is really important, but is a pain to
    write - like Taint Checking and sensible input validation. (Especially
    as we can still show a 'working' application without it!). So, we now
    have CGI::Untaint to take care of a lot of that for us.

    It so happens that CGI::Untaint also plays well with Class::DBI.
    Class::DBI::FromCGI is a little wrapper that ties these two together.

METHODS
  untaint_columns
    All you need to do is to 'use Class::DBI::FromCGI' in your class (or in
    your local Class::DBI subclass that all your other classes inherit from.
    You do do that, don't you?).

    Then, in each class in which you want to use this, you declare how you
    want to untaint each column:

      __PACKAGE__->untaint_columns(
        printable => [qw/Title Director/],
        integer   => [qw/DomesticGross NumExplodingSheep/],
        date      => [qw/OpeningDate/],
      );

    (where the keys are the CGI::Untaint package to be used, and the values
    a listref of the relevant columns).

  update_from_cgi
    When you want to update based on the values coming in from a web-based
    form, you just call:

      $obj->update_from_cgi($h => @columns_to_update);

    If every value passed in gets through the CGI::Untaint process, the
    object will be updated (but not committed, in case you want to do
    anything else with it). Otherwise the update will fail (there are no
    partial updates), and $obj->cgi_update_errors will tell you what went
    wrong (as a hash of problem field => error from CGI::Untaint).

  create_from_cgi
    Similarly, if you wish to create a new object, then you can call:

      my $obj = Class->create_from_cgi($h => @columns_to_update);

    If this fails, $obj will be a defined object, containing the errors, as
    with an update, but will not contain the values submitted, nor have been
    written to the database.

  untaint_type
      my $how = $film->untaint_type('Title'); # printable

    This tells you how we're going to untaint a given column.

  cgi_update_errors
      if (my %errors = $film->cgi_update_errors) {
        while (my ($field, $problem) = each %errors) {
          warn "Problem with $field: $problem\n";
        }
      }

    This returns a hash of any errors when updating. Despite its name it
    also applies when inserting.

Column Auto-Detection
    As Class::DBI knows all its columns, you don't even have to say what
    columns you're interested in, unless it's a subset, as we can auto-fill
    these:

      $obj->update_from_cgi($h);

    You can also specify columns which must be present, or columns to be
    ignored even if they are present:

      $film->update_from_cgi($h => {
        all      => \@all_columns, # auto-filled if left blank
        ignore   => \@cols_to_ignore,
        required => \@cols_needed,
      });

    Doesn't this all make your life so much easier?

NOTE
    Don't try to update the value of your primary key. Class::DBI doesn't
    like that. If you try to do this it will be silently skipped.

ANOTHER NOTE
    If you haven't set up any 'untaint_column' information for a column
    which you later attempt to untaint, then we try to call
    $self->column_type to ascertain the default handler to use. Currently
    this will only use if you're using Class::DBI::mysql, and only for
    certain column types.

SEE ALSO
    Class::DBI. CGI::Untaint. Template.

AUTHOR
    Tony Bowden

BUGS and QUERIES
    Please direct all correspondence regarding this module to:
    bug-Class-DBI-FromCGI@rt.cpan.org

COPYRIGHT
    Copyright (C) 2001-2005 Kasei. All rights reserved.

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