... probably through a hash ...

Yep, you've got it. Here's one way to go about it. The following snippet assumes that the action to act upon is passed via the 'q' parameter (ie: index.pl?q=members):

#!/usr/bin/perl -w
use strict;
use CGI qw/:standard/;

sub main {
 print header(),
  start_html('Welcome'),
   p( strong('Welcome to my website!') ),
  end_html();
}

sub login {
 print header(),
  start_html('Member Login'),
   p( strong('Member Login') ),
   p('Login below:'),
  end_html();
}

sub members {
 print header(),
  start_html('I am a member-only page!'),
   p( strong('Members Page') ),
  end_html();
}

sub _invalid {
 print header(),
  start_html('Invalid Function'),
   p( strong('Invalid Script Function') ),
   p('That fucntion is not valid!'),
  end_html();
}



my $actions = {
 main     => \&main,
 login    => \&login,
 members  => \&members,
 _invalid => \&_invalid
};

my $q = param('q') || 'main';

$actions->{
 exists $actions->{$q} ? $q : '_invalid'
}->();
[download]

If the above content is missing any vital points or you feel that any of the information is misleading, incorrect or irrelevant, please feel free to downvote the post. At the same time, please reply to this node or /msg me to inform me as to what is wrong with the post, so that I may update the node to the best of my ability.

Both of them use my favorite Template Toolkit, and manage things like userbases and applications using related templates and components.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

I haven't played with OpenInteract, but I have played with SPOPS, which is the database layer OpenInteract is based on, and personally I found it rather undocumented, and not entirely bugfree. (For example,

$g = SPOPS::DBI->fetch(1);
$f = SPOPS::DBI->fetch(1);  # same as $g
$f->{field} = "oldvalue";
$g->{field} = "newvalue";
print $f->{field}; # prints "oldvalue"!
# now you have to guess which will be saved first :-(
[download]

)

andramoiennepemousapolutropon

#!/usr/bin/perl -T

package WebApp;

use strict;
use warnings;

use base qw(CGI::Application);
use CGI qw(:standard);

sub setup {
   my ($self) = @_;
   $self->start_mode('main');
   $self->mode_param('q');
   $self->run_modes(
      main     => 'main',
      login    => 'login',
      members  => 'members',
      AUTOLOAD => '_invalid',
   );
}

sub main {
   return start_html('Welcome')
      . p( strong('Welcome to my website!') )
      . end_html()
   ;
}

sub login {
   return start_html('Member Login')
      . p( strong('Member Login') )
      . p('Login below:')
      . end_html()
   ;
}

sub members {
   return start_html('I am a member-only page!')
      . p( strong('Members Page') )
      . end_html()
   ;
}

sub _invalid {
   return start_html('Invalid Function')
      . p( strong('Invalid Script Function') )
      . p('That fucntion is not valid!')
      . end_html()
   ;
}

package main;

use strict;
use warnings;

my $webapp = WebApp->new();
$webapp->run();
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

Right, now that's said, how's this for fun and giggles:

#!/usr/local/bin/perl -w
use strict;

sub a {
  print "Hi from a\n";
}

sub b {
  print "Hi from b\n";
}

doit('a');
doit('b');
$main::c=1;
$main::c++;
doit('c');

sub doit {
  my $func=shift;
  unless (exists($::{$func}) && defined(&{$::{$func}})) {    
    print "Invalid function called: $func\n";
    return 1;
  };
  no strict 'refs';
  &{$func};
}
__END__
Hi from a
Hi from b
Invalid function called: c
[download]

For educational purposes only. (And I admit, I did it to play around with symbol tables a bit, to get a feel for the things).

Update: Not only is this ugly, if called as a CGI (and the sub to call is provided as a parameter), it is also terribly insecure in this form: it's letting the CGI user call any function that is defined in your script. Bad programmer.

CU
Robartes-