Free cgi widget dbi search software for linux

CGI::Widget::DBI::Search is a database search widget.

SYNOPSIS

use CGI::Widget::DBI::Search;

$ws = CGI::Widget::DBI::Search->new(q => $self->{q}, -dbh => $self->{dbh});

# the following shows a configuration for a car parts database search
$ws->{-sql_table} = Cars2Diagram AS c, Diagram AS d, Parts AS p, DiagramScheme AS s;
$ws->{-where_clause} = WHERE c.CarCode=? AND c.DiagramCode=d.DiagramCode AND d.Category=? AND d.DiagramCode=s.DiagramCode AND s.PartCode=p.PartCode;
$ws->{-bind_params} = [$carcode, $category];
$ws->{-sql_retrieve_columns} =
[qw(p.PartCode p.PartName p.Description p.UnitPrice p.CoreCharge),
(p.UnitPrice + p.CoreCharge) AS TotalCharge];
$ws->{-display_columns} =
{ PartCode => "Code ", PartName => "Name", Description => "Description",
UnitPrice => "Price", CoreCharge => "Core Charge", TotalCharge => "Total Charge",
};

$ws->{-numeric_columns} = { PartCode => 1 };
$ws->{-currency_columns} = { UnitPrice => 1, CoreCharge => 1 };
#$ws->{-display_table_padding} = 4;
$ws->{-no_persistent_object} = 1;
$ws->{-show_total_numresults} = 1;

# execute database search
$ws->search();

# output search results to browser
print $q->header;
print $q->start_html;
print $ws->display_results();
print $q->end_html;

Encapsulates a DBI search in a Perl class, including all SQL statements required for performing the search, query results, HTML display methods, and multi-column, sortable result set displayed page-by-page (using HTML navigation links).

Archive Search is an extension which displays an archived versions of the webpage.

Displays an archived versions of the webpage.

First click: Internet Archive
Second click: Google cache
Third click: Yahoo
Fourth click: MSN

HTML::Widget::DBIC is a subclass of HTML::Widgets for dealing with DBIx::Class.

SYNOPSIS

# create a widget coupled with a db record
my $widget = HTML::Widget::DBIC->create_from_config( $config, $resultset, $item );

# process a query
my $result = $widget->process ( $query );

# and save the values from the query to the database
$result->save_to_db();

METHODS

create_from_config

Method to create widget. The parameters are configuration for all the widget fields, a DBIC Resultset and optionally a DBIC record (item) - to fill in the current values in the form and as the target for saving the data, if not present when saving a new record will be created.

The config is a reference to a list of configuration for particular fields. Like: my $config = [ { foreign_class => Dvd, widget_element => [ Select, multiple => 1 ], name => dvds, label => Dvds, bridge_rel => dvdtags }, { widget_element => [ Textarea, rows => 5, cols => 60 ], constraints => [ { max => 255, constraint => Length, message => Should be shorten than 255 characters }, { constraint => All, message => The field is required } ], name => name, label => Name }, { primary_key => 1, name => id, label => Id } ];
process

Like HTML::Widget->process but produces HTML::Widget::Result::DBIC - with extra info for saving to database.

save_to_db

HTML::Widget::DBIC::Result method to save the data from widget to the database

HTML::Widget::SideBar can creates the HTML (and possibly some Javascript) for a navigational or otherwise active (hierarchical) sidebar for a web page.

SYNOPSYS

use HTML::Widget::SideBar;
use CGI; # Or something like that.

# We are going to create a sidebar in which only the active (clicked) branch
# is visible.
my $tree = HTML::Widget::SideBar->new;
$tree->setToggleAction;

foreach (1..3) {
my $list = $tree->append(value => "list$_");
$list->append(value => "aaa$_", URL => "http://localhost/$_");
$list->append(value => "bbb$_");
$list->append(value => "ccc$_");
}
$tree->getSubTree(3)->setActive;

print header, start_html(-style => $tree->buildCSS($tree->deepBlueCSS),
-script => $tree->baseJS);
print join "n", $tree->getHTML(styles => {bar => nav,
level0 => navlink,
level0Over => navover},
expand => 1
);
print end_html;

HTML::Widget::SideBar creates the HTML, and possibly some Javascript and CSS for a hirarchical side menu bar. It is very flexible, and allows you to create both simple navigational menus and complex dynamic sidebars with Javascript actions associated with items on the menu.

This module started as a hack on my Javascript::Menu, which makes them very similar, so if you got one of them, youll use the other with no sweat, I think.
The module supports the notion of an active item (usually the item denoting the page the user is viewing) and gives such item special treatment by marking it with a special CSS class and making it visible initially. It also has special support for selection menus where opening a branch closes all others.

What should you expect to see?

This depends greatly on your style definitions and action assignment (if you use that feature). Basically youll have a vertical bar (which will take up as much of the screen as your CSS will allow). Inside that bar youll have a tree of nested lists, and you can define the style for each level. When an item is clicked - its action is performed. A special predefined action allows you to show/hide child lists.
By default only the active branch (the branch containing the active item) and the top level list will be visible. You can override this (see getHTML).

Some naming rules

The sidebar will get an HTML id attribute. The default is sidebar but this is changeable through getHTML, as other naming rules.
Every list will be of class list unless another class is given through getHTML.
Every item in every list will be of the same class as all other items on the same level. The default is item for all items, but you can set each level separately through getHTML.

The active items class name is its levels class name, appended with Active.
Optionally, you may also set a mouseover style. For those of you who design for Mozilla, you really dont need that, just use the CSS pseudo-class :hover. For others, this will set the onMouseOver and onMouseOut attributes of an item to switch to and from that class.

Setting up the supporting code.

The sidebar created by this menu is formatted by CSS only. This means youll have to supply it. I included a class method called buildCSS which takes a datastructure (described below) and turns it into CSS, and an example of a sidebar design in such datastructure (I used this design in production).

You may also want to use the toggling support (described below), and in this case youll need some Javascript. This is given directly through baseJS. You can use it straight or dump to a file and tweak it to suit you best.

Fandango.com Widget Theme is for quickly searching for movies and theaters in your area from fandango.com.

Ive included the krita file for the background in case you wish to change its appearance. Im afraid Im not that great of artist. Oh, and this is my first theme, so please be kind.

Class::DBI::ConceptSearch is a Perl module to retrieve Class::DBI aggregates from high-level conceptual searches.

SYNOPSIS

my $cs = Class::DBI::ConceptSearch->new(xml => $config); #see CONFIGURATION
$cs->use_wildcards(1);
$cs->use_implicit_wildcards(1);
$cs->use_search_ilike(1);
$cs->use_search_lower(1);

my(@tracks) = $cs->search( albums => Britney );

Given the example Class::DBI classes (Music::CD, Music::Artist, Music::Track), lets add another one, Music::Dbxref, which contains external database accessions outside our control. Music::Dbxref includes things like UPC IDs, ASIN and ISBN numbers, vendor and manufacturer part numbers, person IDs (for artists), etc.

HTML::Widget is a Perl module with HTML Widget And Validation Framework.

SYNOPSIS

use HTML::Widget;

# Create a widget
my $w = HTML::Widget->new(widget)->method(get)->action(/);

# Add a fieldset to contain the elements
my $fs = $w->element( Fieldset, user )->legend(User Details);

# Add some elements
$fs->element( Textfield, age )->label(Age)->size(3);
$fs->element( Textfield, name )->label(Name)->size(60);
$fs->element( Submit, ok )->value(OK);

# Add some constraints
$w->constraint( Integer, age )->message(No integer.);
$w->constraint( Not_Integer, name )->message(Integer.);
$w->constraint( All, age, name )->message(Missing value.);

# Add some filters
$w->filter(Whitespace);

# Process
my $result = $w->process;
my $result = $w->process($query);


# Check validation results
my @valid_fields = $result->valid;
my $is_valid = $result->valid(foo);
my @invalid_fields = $result->have_errors;
my $is_invalid = $result->has_errors(foo);;

# CGI.pm-compatible! (read-only)
my $value = $result->param(foo);
my @params = $result->param;

# Catalyst::Request-compatible
my $value = $result->params->{foo};
my @params = keys %{ $result->params };

# Merge widgets (constraints and elements will be appended)
$widget->merge($other_widget);

# Embed widgets (as fieldset)
$widget->embed($other_widget);

# Get list of elements
my @elements = $widget->get_elements;

# Get list of constraints
my @constraints = $widget->get_constraints;

# Get list of filters
my @filters = $widget->get_filters;

Create easy to maintain HTML widgets!

Everything is optional, use validation only or just generate forms, you can embed and merge them later.

The API was designed similar to other popular modules like Data::FormValidator and FormValidator::Simple, HTML::FillInForm is also built in (and much faster).

This Module is very powerful, dont misuse it as a template system!

CGI::Builder::Magic Perl module contains CGI::Builder and Template::Magic integration.

SYNOPSIS

# just include it in your build

use CGI::Builder
qw| CGI::Builder::Magic
|;