Modules are a great way to add functionality to your scripts without having
to do all the work yourself. After all, if somebody else has done the job
of figuring out how to read CGI input from a form, or calculate which of
two dates is the earlier one, why shouldn't you benefit from their work?

Here at Tripod, we've already done the work on a few modules that we think
might be useful to you. In this document, we'll go over the general way
these modules work, so you can start using them in your scripts. You'll
also want to read the instructional comments at the beginning of any module
that you decide to use, which will give you more specifics about the functions
the module provides.

Also, you can use modules written by other people (including yourself) in
your scripts, as long as you copy them into your cgi-bin directory.
Not all modules work the same way the Tripod modules do, so you may
need to do some additional work to figure them out.

To start using one of the Tripod modules in a script, you'll first want to
add this line of code to your script (for this example, we'll use the
TripodCGI module):

require TripodDate;

This lets the Perl interpreter know that you want to have access to the
functions in the module. Next, you can create an "object" that will
let you access those functions (if you know any object-oriented programming,
this should sound familiar - otherwise, just think of the object as a
simple way to get access to those functions). You do that like this:

$CGI = new TripodDate;

The variable $CGI is now a TripodDate object. With it, you can use
the functions in the TripodDate module. For example, you can use the
currentDate() function, which returns today's date, like this:

$todays_date = $CGI->currentDate();

This would assign the date to the $todays_date variable.

This should be enough to get you started using the Tripod modules in your
scripts. Remember to look at the more detailed commentary below to get
specifics on the modules you decide to use.

TRIPODCGI

TripodCGI is a module to help you deal with CGI input, which is the kind
of input your script can get from forms (as well as from specially-coded
links). When you have a form submit its information to your script,
you can use TripodCGI to grab some or all of the inputs that the form
provided, so that you can use them for your own nefarious ends ;)

Of the functions below, the only two that you are likely to need to pay
attention to are param() and redirect(). param() is the function which
lets you grab CGI input. If you specify the name of a particular input
that you want to grab, param() will grab the value associated with the
input of that name. So if I have a form with a text input box named
'address', and somebody types in '160 Water St.' and hits the submit
button, I can assign '160 Water St.' to the variable $form_address within
my form with this statement:

$form_address = $CGI->param('address');

If you just want to know all of the names of the inputs returned by
the form, don't specify an input, and the names of all the inputs will be
returned as an array - like this:

@all_inputs = $CGI->param();

The other function you might want to use is redirect(). redirect() lets
you specify the URL of a page or script that you want to move your
visitor to. You could use it like this:

$CGI->redirect('http://www.tripod.com');

TRIPODDATE

TripodDate is a module for dealing with dates. You can fetch the current
date (or part of it), modify the format of a date, see which of two dates
is more recent, and so on.

$formatted_date would then be equal to '09/06/1999'. Note that
massageDate() can handle dates using dashes or slashes, but the date needs
to be numerical, and it needs to be in the standard U.S. ordering of
month/day/year.

convertYearToYYYY() is another date formatter. It just takes a year and
converts it into a four-digit year. It should work well for years between
1931 and 2030. Just say this to convert $two_digit_year to a
$four_digit_year:

convertMonthNameToInt() and convertIntToMonthName() are sister functions,
used to convert back and forth between a month name (like 'January' or
'jan') and that month's number (in this case, '1'). Use them like this:

Our last functions are another pair: addNMonthsToDate() and
addNDaysToDate(). Both require a date and a number; that number is added
to the date to produce a new date. Note that the number can be negative,
so you can subtract as well. For example:

TripodInsert is a module to make it easier for you to include dynamic
inserts into your pages. It's very similar to TripodPage, and you should
read the comments for TripodPage before using this module - the comments
here will refer to it repeatedly.

There's only one function you should need to use in TripodInsert, and
that's fetchInsert(). fetchInsert() takes a text file, looks for
variables, fills in the variables with the contents of a variable hash,
and returns the result. This is very similar to how sendPage() from
TripodPage works - indeed, fetchInsert() essentially is sendPage(), except
that instead of sending its output to the web server along with an HTTP
header, it returns the filled-in template as a value to your script. From
there, you can do whatever you want with it - print it out, combine it
with other templates into a larger page, save it as a file, etc. Here's
an example:

This example works like the example given for sendPage(), except that here
each visitor's timezone, ip address, and browser are added to a log file
named 'my_log.txt', rather than being outputted as a web page.

TRIPODMAIL

TripodMail is a module that allows you to send out email messages with
your scripts. In order to use it you'll have to have a mail template in
your cgi-bin directory. The mail template will need to look something
like this:

You can add other email headers (Reply-To:, Errors-To:, etc), but To:
and From: are mandatory. You can customize your email by adding variables
wherever you would like to fill something in on the fly.
The sendMail method requires 2 parameters- the location of the mail
template file, and a reference to a hash of variables.
The keys of the varaible hash should correlate with the variables in the
mail template.

Note: In order to prevent spamming, you will be limited to sending out 240
mails per day.

TRIPODPAGE

TripodPage is a module that makes it easier for you to generate dynamic
pages from your scripts. TripodPage does two big things for you:

1. It generates an HTTP header for you, so you don't have to go to the
trouble of outputting a 'Content-Type: text/html\n\n' or all that
other stuff. This is especially helpful if, like a lot of people,
you don't know what an HTTP header is supposed to look like!
2. It lets you take an HTML template and fill in certain values that you
want to be dynamic. For example, if you wanted your script to output
a page that always showed the current time, you could do that easily
with TripodPage.

The functions you care about are:

* sendPage();
* sendNonCachedPage();
* printHeader();

sendPage() is the most important one. sendPage() takes an html file,
in any variables that it contains, and spits the page out to the web
server. It takes two arguments; the first is the location of the html
file, and the second is a reference to a hash of variables. If you aren't
familiar with hashes or with variables, just follow the example and you
should do fine. Here's the example - this one's long, with a couple of
parts to it:

The 'example.html' file referred to at the beginning might look something
like this:

Example Page

Example Page

You are coming in from this timezone: $timezone
You are using the $browser browser. Your ip address is $ip_address.

Together, this script and html file will output a page that shows the
viewer's browser, ip address, and timezone. First, the script specifies
the name of the html file that we will be using. Second, it creates a
hash which contains all the variables contained within the page - in this
case, 'timezone', 'ip_address', and 'browser' - and assigns values to each
of them. Note that in this case it is getting the values out of a special
hash called %ENV, which contains environment variables that all CGI
scripts have access to, but you could have different variables that get
their values from other places, like random numbers, the time or date,
input from a form, etc. Finally, the script calls sendPage() to take the
html file and fill in the variables with the contents of the hash.
sendPage() looks at the html and searches for words preceded by dollar
signs. In our example file, it finds $timezone, $browser, and
$ip_address. Each of these then gets replaced by the values from the
hash. So the output might look something like this:

Example Page

Example Page

You are coming in from this timezone: US/Eastern
You are using the Mozilla/4.61 [en] (Win98; U) browser. Your ip address
is 208.7.131.186.

That's what you'd see if you were using my personal computer at Tripod -
you'd see something quite different. This is what's cool about
sendPage() - it lets you present different information in your page under
different circumstances.

We can go over the last two functions quickly. sendNonCachedPage() works
just like sendPage(), except that it also tells the browser not to cache
the page that is sent. This is a good idea if the information you are
sending back changes from moment to moment, and you want to make sure that
a visitor who reloads the page always gets the newest information.

printHeader() just outputs the HTTP header that tells the browser you are
outputting an HTML page from your script. If your script is outputting
something besides HTML, you can also pass it the appropriate MIME-type for
your output, and it will change the header accordingly. You can use it
like this:

$PAGE->printHeader();
print "A really simple page.";
exit;

That will output a page which says 'A really simple page.' and nothing
else. You might want to use printHeader() instead of sendPage() if you
are creating such a dynamic web page that you need write all the HTML from
within your script, rather than using an HTML file as a template and
filling in variables.

CGI

CGI is not a Tripod-written module; rather, it's a module that
sees a lot of use among Perl programmers on the Web because it's very
useful and easy to install (because it doesn't depend upon other modules
in order to do its thing). Because of it's wide usage, particularly
in scripts offered in online script archives, we include CGI here. We're
assuming, though, that you will only be using it if you already know how it
works - CGI is a large module with too many functions to properly document
here!