CGI::Pager performs the "dirty work" necessary to program paginated
data display in a web application.
Based on given resultset size, page size, and offset value sensed from
current URI, it constructs links for navigation between results pages.
It can be used conveniently from a templating system, has both OO and
functional interface, and can optionally generate necessary HTML
itself.
The core of every CGI application seems to be roughly the same:
- analyze the incoming parameters, cookies, and URLs to determine the
state of the application (let's call this "dispatch").
- based on the current state, analyze the incoming parameters to respond
to any form submitted ("respond").
- from there, decide what response page should be generated, and produce
it ("render").
CGI::Prototype creates a Class::Prototyped engine for doing all this,
with the right amount of callback hooks to customize the process.
CGI::Simple provides a relatively lightweight drop in replacement
for CGI.pm. It shares an identical OO interface to CGI.pm for
parameter parsing, file upload, cookie handling and header generation.
This module is entirely object oriented, however a complete functional
interface is available by using the CGI::Simple::Standard module.
CGI::Struct lets you transform CGI data keys that look like perl data
structures into actual perl data structures.
This module is a very lightweight parser of CGI forms. And it has a special
feature that it will return an array if the same key is used twice in the
form. You can force an array even if only one value returned to avoid
complications.
The hash %cgi_data will have all the form data from either a POST or GET form
and will also work for "multipart/form-data" forms necessary for uploading
files.
Dealing with large web based applications with multiple forms is a minefield.
It's often hard enough to ensure you validate all your input at all, without
having to worry about doing it in a consistent manner. If any of the validation
rules change, you often have to alter them in many different places. And, if
you want to operate taint-safe, then you're just adding even more headaches.
This module has been written to provide a simple and secure
manner by which to handle files uploaded in multipart/form-data
requests through a web browser. The primary advantage which this
module offers over existing modules is the single interface
which it provides for the most often required information
regarding files uploaded in this manner.
This module builds upon primarily the CGI and File::MMagic
modules and offers some tidy and succinct methods for the
handling of files uploaded via multipart/form-data requests.
CGI::XMLApplication is a CGI application class, that intends to enable
perl artists to implement CGIs that make use of XML/XSLT functionality,
without taking too much care about specialized errorchecking or even
care too much about XML itself. It provides the power of the
XML::LibXML/XML::LibXSLT module package for content deliverment.
As well CGI::XMLApplication is designed to support project management on
code level. The class allows to split web applications into several
simple parts. Through this most of the code stays simple and easy to
maintain. Throughout the whole lifetime of a script CGI::XMLApplication
tries to keep the application stable. As well a programmer has not to
bother about some of XML::LibXML/XML::LibXSLT transformation pitfalls.
You can use this module to decode form and query information, including file
uploads, as well as cookies in a very simple manner; you need not concern
yourself with the actual details behind the decoding process.
This module is a Perl extension that extends
REST::Client for use with the CIF-Framework REST interface