lib/CXGN/Page/Form/ConfirmStore.pm

   1
   2 =head1 NAME
   3
   4 CXGN::Page::Form::ConfirmStore.pm -- classes to deal with user-modifiable web forms
   5
   6 =head1 DESCRIPTION
   7
   8 This is a subclass of L<CXGN::Page::Form::Static>, and overrides the functions therein to generate editable components in the form. For more information, see L<CXGN::Page::Form::Static>.
   9
  10 =head1 AUTHOR(S)
  11
  12 Lukas Mueller (lam87@cornell.edu)
  13
  14 =cut
  15
  16 use strict;
  17 use CXGN::Page;
  18 use CXGN::Page::Form::Static;
  19 use CXGN::Page::Form::Editable;
  20
  21 package CXGN::Page::Form::ConfirmStore;
  22
  23 use base qw / CXGN::Page::Form::Editable /;
  24
  25 sub new {
  26         my $class = shift;
  27         my $self = $class->SUPER::new(@_);
  28         $self->set_static_form(CXGN::Page::Form::Static->new()) ;
  29         $self->set_reset_button_text("Reset");
  30         $self->set_submit_button_text("Store");
  31         $self->set_submit_method(); #use hardcoded default
  32         return $self;
  33 }
  34
  35 =head2 is_editable
  36
  37 Whether the form can be filled in.
  38
  39 =cut
  40
  41 sub is_editable {
  42         return 0;
  43 }
  44
  45
  46
  47
  48 =head2 store
  49
  50  Usage:
  51  Desc:
  52  Ret:
  53  Args:
  54  Side Effects:
  55  Example:
  56
  57 =cut
  58
  59 sub store {
  60     my $self = shift;
  61     my %args = @_;
  62
  63     #print STDERR "args hash before in the store function: \n";
  64 #    while (my ($key, $value) = each(%args)) { print STDERR "$key $value\n"; }
  65     #print STDERR "STORING FORM DATA...\n";
  66
  67     $self->propagate_input(%args);
  68
  69
  70
  71     # commit the changes to the database using the store method on
  72     # each object
  73     #
  74     #print STDERR "STORING OBJECT...\n";
  75
  76     my %distinct_objects = $self->get_distinct_objects();
  77
  78
  79     # check the uniqueness constraints of the object
  80     #
  81     foreach my $k (keys(%distinct_objects)) {
  82                 my $obj = $distinct_objects{$k};
  83       if ($obj->can("exists_in_database")) {
  84           my $message = $obj->exists_in_database();
  85          if ($message) {
  86              my $text = "This object (" . ref($obj) . ") already seems to exist in the database and violates constraints. Please correct your input.";
  87              $message = "" unless ($message =~ /[a-zA-Z]/);
  88              CXGN::Page->new()->message_page($text, $message);
  89          }
  90       }
  91     }
  92     foreach my $k (keys %distinct_objects) {
  93         #print STDERR " DUMP:" .Data::Dumper::Dumper($distinct_objects{$k});
  94         #print STDERR " STORING OBJECT: ".ref($distinct_objects{$k})."\n";
  95
  96         my $id = $distinct_objects{$k}->store();
  97         $self->set_insert_id($k, $id);
  98     }
  99 }
 100
 101 =head2 add_field
 102
 103  Usage:
 104  Desc:
 105  Ret:
 106  Args:         a hash with the following keys:
 107                 screen_name
 108                 field_name
 109                 contents
 110                 length
 111                 object
 112                 getter
 113                 setter
 114                                          set_if
 115                                          validate
 116                required fields: field_name.
 117  Side Effects:
 118  Example:
 119
 120 =cut
 121
 122 sub add_field {
 123
 124     my $self = shift;
 125     my %args = @_;
 126     $self->get_static_form->add_field(%args);
 127     my $field = CXGN::Page::Form::Hidden->new(%args);
 128     if(exists $args{validate})
 129     {
 130         $field->set_validate($args{validate});
 131     }
 132     if (!exists($self->{fields})) { $self->{fields}=(); }
 133     push @{$self->{fields}}, $field;
 134 }
 135
 136
 137
 138 =head2 function add_textarea
 139
 140   Synopsis:
 141   Arguments:    a hash with the following keys:
 142                 screen_name
 143                 field_name
 144                 contents
 145                 length
 146                 object
 147                 getter
 148                 setter
 149                                          set_if
 150                                          validate
 151                 required fields: field_name.
 152   Returns:
 153   Side effects:
 154   Description:
 155
 156 =cut
 157
 158 sub add_textarea {
 159     my $self = shift;
 160     my %args = @_;
 161
 162     $self->get_static_form->add_textarea(%args);
 163     my $field = CXGN::Page::Form::Hidden->new(%args);
 164
 165     if(exists $args{validate})
 166     {
 167         $field->set_validate($args{validate});
 168     }
 169     $self->add_field_obj($field);
 170 }
 171
 172 =head2 add_select
 173
 174  Usage:
 175  Desc:
 176  Ret:
 177  Args:         display_name
 178                field_name
 179                contents
 180                length
 181                object
 182                getter
 183                setter
 184                                         set_if
 185                                         validate
 186                select_list_ref
 187                select_id_list_ref
 188
 189  Side Effects:
 190  Example:
 191
 192 =cut
 193
 194 sub add_select {
 195     my $self = shift;
 196     my %args = @_;
 197
 198     #foreach my $k (keys %args) { print "Args to add_select $k, $args{$k}\n<br />"; }
 199     $self->get_static_form->add_select(%args);
 200     my $select = CXGN::Page::Form::Hidden->new(%args);
 201
 202     if(exists $args{validate})
 203     {
 204         $select->set_validate($args{validate});
 205     }
 206     if (!exists($self->{fields})) { $self->{fields}=(); }
 207     push @{$self->{fields}}, $select;
 208 }
 209
 210 =head2 add_hidden
 211
 212  Usage:
 213  Desc:
 214  Ret:
 215  Args:
 216  Side Effects:
 217  Example:
 218
 219 =cut
 220
 221 sub add_hidden {
 222     my $self = shift;
 223     my %args = @_;
 224     $self->get_static_form->add_hidden(%args);
 225     my $hidden = CXGN::Page::Form::EditableHidden->new(%args);
 226
 227     if(exists $args{validate})
 228     {
 229         $hidden->set_validate($args{validate});
 230     }
 231     $self->add_field_obj($hidden);
 232 }
 233
 234 =head2 add_checkbox
 235
 236  Usage:
 237  Desc:
 238  Ret:
 239  Args:
 240  Side Effects:
 241  Example:
 242
 243 =cut
 244
 245 sub add_checkbox
 246 {
 247     my $self = shift;
 248     my %args = @_;
 249
 250     $self->get_static_form->add_checkbox(%args);
 251     my $checkbox = CXGN::Page::Form::Hidden->new(%args);
 252
 253     $self->add_field_obj($checkbox);
 254 }
 255
 256 =head2 add_radio_list
 257
 258  Usage:
 259  Desc:
 260  Ret:
 261  Args:
 262  Side Effects:
 263  Example:
 264
 265 =cut
 266
 267 sub add_radio_list
 268 {
 269     my $self = shift;
 270     my %args = @_;
 271
 272     $self->get_static_form->add_radio_list(%args);
 273     my $radio = CXGN::Page::Form::Hidden->new(%args);
 274
 275     $self->add_field_obj($radio);
 276 }
 277
 278 =head2 add_multiselect
 279
 280  Usage:
 281  Desc:
 282  Ret:
 283  Args:
 284  Side Effects:
 285  Example:
 286
 287 =cut
 288
 289 sub add_multiselect
 290 {
 291     my $self = shift;
 292     my %args = @_;
 293
 294     $self->get_static_form->add_multiselect(%args);
 295     my $radio = CXGN::Page::Form::Hidden->new(%args);
 296
 297     $self->add_field_obj($radio);
 298 }
 299
 300 sub get_form_start {
 301     my $self = shift;
 302     return "<form method=\"" . $self->get_submit_method() . "\" action=\"\">"; #must have action parameter for xhtml 1.0+ -- Evan, 1/7/07
 303 }
 304
 305 sub get_form_end {
 306     my $self = shift;
 307     return "<input type=\"submit\" value=\"" . $self->get_submit_button_text() . "\" />
 308
 309             </form>";
 310 }
 311
 312 =head2 get_submit_method
 313
 314 'get' or 'post'
 315
 316 =cut
 317
 318 sub get_submit_method
 319 {
 320         my $self = shift;
 321         return $self->{form_submit_method};
 322 }
 323
 324 =head2 set_submit_method
 325
 326 'get' or 'post' (case does not matter)
 327
 328 default is 'get' if no or invalid argument
 329
 330 =cut
 331
 332 sub set_submit_method
 333 {
 334         my ($self, $method) = @_;
 335         $method = 'get' if(!defined($method) or $method !~ /^get|post$/i);
 336         $self->{form_submit_method} = lc($method); #lowercase
 337 }
 338
 339 sub get_reset_button_text
 340 {
 341         my $self = shift;
 342         return $self->{reset_button_text};
 343 }
 344
 345 =head2 set_reset_button_text
 346
 347 Args: new button text (default is 'reset form')
 348
 349 [1 / 9 / 07] Not currently possible to remove the reset button.
 350
 351 =cut
 352
 353 sub set_reset_button_text
 354 {
 355         my ($self, $text) = @_;
 356         $self->{reset_button_text} = $text;
 357 }
 358
 359 sub get_submit_button_text
 360 {
 361         my $self = shift;
 362         return $self->{submit_button_text};
 363 }
 364
 365 =head2 set_submit_button_text
 366
 367  Args: new button text (default is 'store')
 368
 369 =cut
 370
 371 sub set_submit_button_text
 372 {
 373         my ($self, $text) = @_;
 374         $self->{submit_button_text} = $text;
 375 }
 376
 377 =head2 as_table_string
 378
 379  Usage:
 380  Desc:
 381  Ret:
 382  Args:
 383                Note: as table does not call validate itself to give some
 384                more control on the appearance (you don't wan't the
 385                new input field to appear with error messages).
 386  Side Effects:
 387  Example:
 388
 389 =cut
 390
 391 sub as_table_string {
 392     my $self = shift;
 393     my $string = "";
 394
 395
 396     # the static form
 397     my $static= $self->get_static_form();
 398
 399     $string .= $static->as_table_string();
 400
 401     ### the confirmStore form:
 402     my %error_hash = $self->get_error_hash();
 403     my %html = $self->get_field_hash();
 404     my $has_required_field=0;
 405
 406     $string .= $self->get_form_start();
 407     $string .=  qq { <table> };
 408     foreach my $f ($self->get_fields()) {
 409         my $error = "";
 410         if (exists($error_hash{$f->get_field_name()})) {
 411             $error=$self->get_error_message($error_hash{$f->get_field_name()})."<br />";
 412
 413         }
 414         my $required_field = "";
 415         if ($f->get_validate()) {
 416             $required_field = qq { <font color="red">*</font> };
 417             $has_required_field=1;
 418         }
 419
 420         # print everything except the hidden fields
 421         #
 422         if (ref($f)!~/hidden/i) {
 423             $string .= "<tr><td>$error".($f->get_display_name())."$required_field</td><td width=\"20\">&nbsp;</td><td>".($html{$f->get_field_name()})."</td></tr>\n";
 424
 425         }
 426     }
 427
 428     $string .= qq { <tr><td colspan="3" align="center"> };
 429
 430     # print the hidden fields
 431     #
 432     foreach my $f ($self->get_fields()) {
 433         if (ref($f)=~/hidden/i) {
 434             $string .= $html{$f->get_field_name()};
 435         }
 436     }
 437     if ($has_required_field) {
 438         $string .= qq { (<font color="red">*</font> denotes required field.)<br /><br /> };
 439     }
 440     $string .= qq { </td></tr></table> };
 441     $string .= $self->get_form_end();
 442
 443     $string .= $static->get_form_end();
 444
 445
 446     return $string;
 447 }
 448
 449 =head2 get_static_form
 450
 451  Usage:
 452  Desc:
 453  Ret:
 454  Args:
 455  Side Effects:
 456  Example:
 457
 458 =cut
 459
 460 sub get_static_form {
 461   my $self=shift;
 462   return $self->{static_form};
 463
 464 }
 465
 466 =head2 set_static_form
 467
 468  Usage:
 469  Desc:
 470  Ret:
 471  Args:
 472  Side Effects:
 473  Example:
 474
 475 =cut
 476
 477 sub set_static_form {
 478   my $self=shift;
 479   $self->{static_form}=shift;
 480 }
 481
 482
 483
 484 1;
 485