#!/usr/bin/env perl
# -*- Perl -*-
#
######################################################################
# Provide a formatted output of data
######################################################################
#

require "ctime.pl";

$Version = '$Id: dbreport,v 2.17 2020/08/02 00:16:56 goeke Exp goeke $';

$PartsSource = "parts.cdb";     # The compressed data base
$PartsPublic = "parts.pdb";     # The list of easy viewing file suffixes
$WorkDir     = "./data/";
$WorkName    = "-data";
$LinkDir     = "./file_cabinet/";
$Itar        = "itar";          # A hard-wired sub-diretory of "$LinkDir"
$WebDir      = "./";
$Base        = "base.html";
$Tab         = "tabset";
$Spacing     = "parts.tdb";     # arguments for the "tabset" program

$Yellow = "rgb(255,255,102)";
# $Grey = "rgb(230,230,230)";
$White = "rgb(255,255,255)";
$Grey = $White;
$Color = $White;             # the first row is white
$Title = "Data Base Report";   # a default title for non-TSV reports

$MAXWORD = 30;       # Maximum length of unbroken HTML field contents

$Print = 0;          # Default is not to print
$Web = 1;            # Default is to do the web thing
$Tsv = 1;            # Default is to generate TSV output

# @FieldNames holds the database valid field descriptor names
# @Out        holds the selected field descriptor for output
# @Work       holds the records extracted for processing ($Start to $Stop)
# $All        incremented if no explicit $Start selected

######################################################################
# Primary control
######################################################################
&Setup;
&CollectData;
&PrePrint if $Print;
&Web if ($Web||$Tsv||$Print);
&Cleanup;
exit 0;

######################################################################
# Subroutines in alphabetic order
######################################################################

##################################################################
# Adds an HTML link to the drawing in PDF or TXT form if it exists
# Arguments: (Data, Link type)
# Returns: Data surrounded by an HTML link
#  NB drawing also gets an internal bookmark added to enable cross-references
# NB $Stuff{$Dwg} is in ##-#####.## form when it gets here
# NB for internal cross-ref, $_[0] points to Stuff{} requiring link
#   where link type = 0 for drawing, 
#                     1 for rev directory,
#                     2 for internal cross-reference
##################################################################
sub AddLinks() {

    my $retval;

    # Install an internal cross-reference
    if ($_[1] == 2) {
	$retval = "<a href=\"#$_[0]\">$_[0]</a>";
	return($retval);
    }

    my $LOC = "<a name=$Stuff{$Dwg}></a>"; # The internal cross-ref tag
    # This is just a quick exit if no rev, and hence no links, exist
    if ($_[1] == 0) {
	$retval = $LOC . $Stuff{$Dwg} ;     # putting it here for default
    } else {                                # the Rev case
	$retval = $Stuff{$Rev} ;
    }

    if ($_[1] == 0 && !$Stuff{$Rev} ) {
	return($retval);
    } elsif (!$Stuff{$Rev}) {      # just in case we are called for naught
	return("");
    }

#    my $DIR = "<a href=\"$WebDir/$dirref\">";      # The web address for directory

    my $dwgref = $Stuff{$Dwg};
    my $dirref;

    # First convert the drawing number into canonical e-file format
    $dwgref =~ s%[0-9]{2,3}-([0-9])([0-9]{2})([0-9]{2})([0-9.]*)%$1/$1$2$3/$1$2$3$4_r$Stuff{$Rev}% ;
    $dirref = $1 . "/" . $1 . $2 . $3;
    $dwgref =~ s/\./_/g ;

    # Link to the PDF type if available, then TXT, etc.
    printf "*** *** Rev is $Stuff{$Rev}\n" if ($Verbose>1);
    local $ii;
    foreach $ii (@PubSuf) {
	printf "*** *** Link test: $LinkDir/$dwgref$ii" if ($Verbose>1);
	if ( -r "$LinkDir/$dwgref$ii" ) {
	    printf " -- MATCH\n" if ($Verbose>1);
	    if ($_[1] == 0) {	# Link the $Dwg entry
		$retval = $LOC . 
		    "<a href=\"$WebDir/$dwgref$ii\">" . 
		    $Stuff{$Dwg} . 
		    "</a>";
	    } else {            # Link the $Rev entry
		$retval = "<a href=\"$WebDir/$dirref\">" .
		    $Stuff{$Rev} . 
		    "</a>";
	    }
	    last;               # Quit on first match
	} elsif ( -r "$LinkDir/$Itar/$dwgref$ii" ) {
	    printf " -- MATCH\n" if ($Verbose>1);
	    if ($_[1] == 0) {	# Link the $Dwg entry
		$retval = $LOC . 
		    "<a href=\"$WebDir/$Itar/$dwgref$ii\">" . 
		    $Stuff{$Dwg} . 
		    "</a>";
	    } else {            # Link the $Rev entry
		$retval = "<a href=\"$WebDir/$Itar/$dirref\">" .
		    $Stuff{$Rev} . 
		    "</a>";
	    }
	    last;               # Quit on first match
	}
	printf " -- fail\n" if ($Verbose>1);
    }
    return($retval);
}

######################################################################
# Since we aren't using working files, Cleanup() is simple
######################################################################
sub Cleanup {
    print "*** Done\n" if $Verbose;
}

#####################################################################
# Open the data source file and extract docs twixt $Start and $Stop
#   $PartsSource must contain valid file name for data source
#   Either $Start and $Stop must be set or $All must be set
# Set up and validate field names to extract
# Exits with extracted records in @Work
#####################################################################
sub CollectData {

    my ($ii,$jj,$kk);
    my @info = stat(CDB);
    $Datetag = ctime($info[10]);
    printf "*** Database last update: $Datetag" if $Verbose;

    $_ = <CDB>;            # get structure data from first line
    if (/(^.).*Field_names: +([A-z_,0-9]+) +Project: +(\S+)/) {
	$Sep = $1;    # get field name separator character
	@FieldNames = split(/,/,$2);  # get valid field names
	$Project = $3;
    } else {
	die "First line of $PartsSource is not in canonical form\n";
    }

    if ($Verbose) {
	printf "*** Field Separator: %s\tProject Number: %s\n", $Sep, $Project;
	print "*** Valid Field Names: ";
	foreach $ii (0..$#FieldNames) {
	    print "$FieldNames[$ii] ";
	}
	print "\n";
    }
    $Dwg = $FieldNames[0];
    $Rev = $FieldNames[1];
    print "*** Primary ort field: $Dwg      Secondary Field: $Rev\n" if ($Verbose);
    
    if ( !$Out[0] ) {
	@Out = @FieldNames;   # No field names specified; use all of them
	print "*** All Field Names selected by default\n" if $Verbose;
    } else {                  # else error check the requested list
LOOP:	foreach $jj (@Out) {
            foreach $ii (@FieldNames) {
		next LOOP if ($jj eq $ii);
	    }
	    die "Specified field name >$jj< not valid: ";
	}
        if ($Verbose) {
	    print "*** Selected Field Names: ";
	    foreach $ii (0 .. $#Out) {
		print "$Out[$ii] ";
	    }
	    print "\n";
	}
    }


    if ($Verbose && $All) {
	print "*** Extracting all records\n";
    } elsif ($Verbose) {
	print "*** Extracting $Start to $Stop\n";
    }

    $kk = 0;
    seek(CDB,0,0) || die "Problem respooling; $!";
    while ( <CDB> ) {
	if (/=dwg ([0-9.]+)/) {
	    next if ($1 < $Start);
	    last if (!$All && int($1) > int($Stop));
            # The "int()" statement collect all the .xxyy daughter documents
	    $Work[$kk++] = $_;
	}
    }
    $NoneSelected++ if ( ! $kk );

}

##################################################################
# Given a single record, select the fields and generate output
# Each @Work record is broken up in turn into %Stuff
##################################################################
sub Format {
    print "*** *** $_[0]" if ($Verbose>1);
    my $record = $_[0];
    my @fields = split(/$Sep/,$record);
    my ($ii,$jj,$fancy);

    # This is necessary in case @fields doesn't contain all the @Out entries
    foreach $ii ( @Out ) {
	$Stuff{$ii} = "";
    }

    foreach $ii ( @fields ) {   
        next if (!$ii);                # nothing before first $Sep
	$ii =~ /([A-z_]+) +(.*)/;
	my $name = $1; my $data = $2;  # all this to deal with both
	$data =~ s/ *$//;              # trailing space and null entries
	$data =~ s/\.\./   /g if ($Space); # substitute ".." -> hard_space
	$Stuff{$name} = $data;
    }

    die "$Dwg field contents missing: " if ( !$Stuff{$Dwg} );
    # We need to do this up front because we don't know the order of things
    #  and &Addlinks needs a cannonical form.
    my $plaindwg = $Stuff{$Dwg};
    $Stuff{$Dwg} = $Project . "-" . $Stuff{$Dwg};

    # Just to put a little space between the sections of a plain web dump
    if ($plaindwg =~ /[1-9]0{4}/ && $Web && $Plain) {
	printf HTML "<br>\n";
    }

    # NB that TSV is printed without $Project prefix and links
    foreach $jj ( @Out ) {
	if ($Tsv) {
	    printf TSV "%s\t", ($jj=~/$Dwg/) ? $plaindwg : $Stuff{$jj};
	}
        if ($Web) {
	    if ( $jj =~ /$Dwg/ ) {
		$fancy = &AddLinks(0,0) ;
	    } elsif ( $jj =~ /$Rev/ ) {
		$fancy = &AddLinks(0,1);
	    } elsif ( $Stuff{$jj} =~ /^$Project-[0-9]{5}/ ) {
		$fancy = &AddLinks($Stuff{$jj},2);
	    } else {
		$fancy = $Stuff{$jj};
	    }

	    if ( $Plain ) {
		printf HTML "%s\t", $fancy;
	    } else {
		printf HTML "        <td style=\"background-color: %s\">%s</td>\n", $Color, &Wrap($fancy);
	    }
	}
    }

    printf TSV "\n" if $Tsv;
    printf HTML "      </tr><tr>\n" if ($Web && !$Plain);
    printf HTML "\n" if $Web;
    if ($Color eq $White) {          # Generate grey bars in table
	$Color = $Grey;
    } else {
	$Color = $White;
    }
}

##################################################################
# The universal help message
##################################################################
sub Help {

    print STDERR "
Usage: $0 [-hpw] \\
               [-d dirname] [-f filename] [-l dirname] [-L dirname] [-v] [-w] \\
               [-n field1,field2,...] [-o filename] [-t filename] \\
               [-T document_title] [start_record [final_record]]
   -d{irectory] puts results in named directory;
            \"$WorkDir\" is the default output directory.
   -f[ile]  uses following file_name as data source;
            if file_name is \"-\", uses STDIN.
            './parts.cdb' is the default data source.
   -h[elp]  produces this help messagn.
   -l[ink]  following dir_name is top of the directory tree in Unix space for links;
            default is to use $LinkDir.
   -L[ink]  following dir name is top of the directory tree in Web space for links;
            default is to use $WebDir.
   -n[ames] outputs data only for the named fields;
            default is to output data for all fields
   -o[utput] uses following name for output files;
            default is \"##-data\", where ## is Project No.
   -p[lain] produces \"simple\" HTML output; i.e. no tables
   -t[abs]  sets tab spacing in plain output; default ./parts.tdb
   -T[itle] use following text string as report title.
   -v[erbose] produces diagnotics on STDOUT.
   -w[eb]   produces HTML and TSV output (default).
  If a file parts.pdb exists, it is read as a list of file suffixes for which
      document links are valid; if no such file exists, the default is PDF, TXT.
  If no record numbers are given, entire database is processed.
  If only one record number given, only that record and all its sub-records are processed.
  A tab-separated-value file is generated along with the HTML file.
";

    exit 0;

}


###################################################################
# Sets up the formats and collects the data necessary to set up the
# printer-ready stream using "enscript"
###################################################################
sub PrePrint {

    my @fields = split(/$Sep/,$_[0]);
    foreach $ii ( 1..$#fields ) {   # nothing before first $Sep
	$fields[$ii] =~ /([A-z_]+) +(.*)/;
	my $name = $1; my $data = $2;
	my $len = length($Stuff{$name});
	    if ( --$len > $Length{$name} ) {
		$Length{$name} = $len;
	    }
    }

    $format = "format PRN = \n";
    for $ii ( 0..$#Out ) {
	$format = $format . "@" . "<" x $Length{$Out[$ii]} . "  " ;
    }
    $format = $format . "\n.\n";
    print *** $format if $Verbose;
    eval $format;


}

###################################################################
# Initial processing of arguments
# Defaults: get all items in data base, contents of all fields
#           -w is assumed if neither -p or -t is selected
###################################################################

sub Setup() {
    my $funk = my $foo = $Verbose = 0;
    while ( $funk = shift(@ARGV) ) {
	if ( $funk =~ /^-d/ ) {
	    if ( ! ($WorkDir = shift(@ARGV)) ) {
		print STDERR "-d flag must be followed by a directory name\n";
		&Help;
	    }
	    if ( ! -x $WorkDir ) {
		print STDERR "Cannot write to output work directory $WorkDir\n";
		&Help;
	    }
	    next;
	}
	if ( $funk =~ /^-f/ ) {
	    if ( ! ($PartsSource = shift(@ARGV)) ) {
		print STDERR "-f flag must be followed by a file name\n";
		&Help;
	    }
	    next;
	}
	if ( $funk =~ /^-h/ ) {
	    &Help;
	}
	if ( $funk =~ /^-l/ ) {
	    if ( ! ($LinkDir = shift(@ARGV)) ) {
		print STDERR "-l flag must be followed by a directory name\n";
		&Help;
	    }
	    if ( ! -x $LinkDir ) {
		print STDERR "Cannot find link directory $LinkDir\n";
		&Help;
	    }
	    next;
	}
	if ( $funk =~ /^-L/ ) {
	    if ( ! ($WebDir = shift(@ARGV)) ) {
		print STDERR "-L flag must be followed by a directory name\n";
		&Help;
	    }
	    next;
	}
	if ( $funk =~ /^-n/ ) {
	    if ( ! ($foo = shift(@ARGV)) | ($foo =~ /^-/) ) {
		print STDERR "-n flag must be followed by a comma separated list of field names";
		&Help;
	    }
	    @Out = split(/,/,$foo);
	    if ( ! $#Out ) {   # if single field given, this is no comma case
		$Out[0] = $foo;
	    }
	    next;
	}
	if ( $funk =~ /^-o/ ) {
	    if ( ! ($foo = shift(@ARGV)) | ($foo =~ /^-/) ) {
		print STDERR "-o flag must be followed by an ASCII string";
		&Help;
	    }
	    $Outfile = $foo;
	    next;
	}
	if ( $funk =~ /^-p/ ) {
	    $Plain++; $Tsv = 0;
	    print "*** Setting up for plain\n" if ($Verbose);
	    next;
	}
	if ( $funk =~ /^-s/ ) {
	    $Space++; 
	    print "*** Substituting hard spaces for .." if ($Verbose);
	    next;
	}
	if ( $funk =~ /^-t/ ) {
	    if ( ! ($Spacing = shift(@ARGV)) ) {
		print STDERR "-t flag must be followed by a file name\n";
		&Help;
	    }
	    if ( ! -r $Spacing ) {
		print STDERR "Tab spacing file \"$Spacing\" could not be read\n";
		&Help;
	    }
	    next;
	}
	if ( $funk =~ /^-T/ ) {
	    if ( ! ($Title = shift(@ARGV)) ) {
		print STDERR "-T flag must be followed by a text string\n";
		&Help;
	    }
	    next;
	}
	if ( $funk =~ /^-v/ ) {
	    $Verbose++;
	    next;
	}
	if ( $funk =~ /^-V/ ) {
	    print "$Version\n";
	    exit 0;
	}
	if ( $funk =~ /^-w/ ) {
	    $Web++; $Tsv++;
	    next;
	}
	if ( $funk =~ /^-/ ) {
	    print STDERR "Unknown flag: $funk \n";
	    &Help;
	}
	if ( $funk =~ /^[0-9.]+$/ ) {
	    if (!$Start) {
		$Start = $funk;
	    } else {
		$Stop = $funk;
		if ( $Stop < $Start) {   # Error check
		    printf STDERR "Ending record number $Stop must be greater than starting number $Start\n\n";
		    &Help;
		}
	    }
	    next;
	} else {
	    print STDERR "Unknown argument: $funk";
	    &Help;
	}
    }

    if (!$Start) {
	$Start = $Stop = 0;                # Need to set values
	$All++;
    } elsif (!$Stop) {
	$Stop = $Start;
	@foo = split(//,$Start);           # All this is necessary to
	if ( $foo[4] == 0 ) {              # get $Stop set to the next
	    $Stop += 9;                    # record /of the same level/
	    if ( $foo[3] == 0 ) {          # as the $Start
		$Stop += 90;
		if ( $foo[2] == 0 ) {
		    $Stop += 900;
		    if ( $foo[1] == 0 ) {
			$Stop += 9000;
		    }
		}
	    }
	}
    }

    $Web++ if ( ! $Print & ! $Tsv);   # use HTML output as default

    print "$Version\n" if ($Verbose);

    if ( -r $PartsPublic ) {
	open(PDB,"$PartsPublic") || die "Could not read $PartsPublic";
	local $ii;
	while (<PDB>) {
	    next if ($_ =~ /^\s*$/);  # blank line
	    next if ($_ =~ /^\s*\#/); # comment
	    if ($_ =~ /^[^.]/) {      # force suffix to have dot leading
		$_ = "." . $_;
	    }
	    chop($_);
	    $PubSuf[$ii++] = $_;
	}
	close(PDB);
     } else {
	 $PubSuf[0] = ".PDF";         # default suffixes
	 $PubSuf[1] = ".TXT";
     }
     if ($Verbose) {
	 printf "*** Public display suffixes: ";
	 foreach $ii (@PubSuf) {
	     printf "${ii} ";
	 }
	 printf "\n";
     }

    print "*** Open database: $PartsSource\n" if ($Verbose);
    open(CDB,"$PartsSource") || die "Could not read $PartsSource";

    if ( 1 ) {
	print "*** Finding $Base\n" if ($Verbose);
	if ( -r $Base ) {
	} elsif ( -r "bin/$Base" ) {
	    $Base = "bin/" . $Base;
	} elsif ( -r "lib/$Base" ) {
	    $Base = "lib/" . $Base;
	} else {
	    die "Could not find $Base for first page of HTML output: ";
	}
	open (BASE,"$Base") || die "Could not open $Base: ";
    }
    if ( $Plain ) {      # see if tab spacing file exists
	print "*** Finding $Spacing\n" if ($Verbose);
	if ( -r $Spacing ) {
	    open(TABARG,"$Spacing") ||
	         die "Could not open $Spacing file";
	    while (<TABARG>) {
		 next if (/^#.*/);    # skip comments
		 next if (/^\s*$/);   # skip empty lines
		 $Tabargs = $_;       # we only take single line!
		 chop($Tabargs);      # don't want the trailing \n
		      }
		 print "*** For tabset using >>>  $Tabargs\n" if ($Verbose);
	}         # We use $Tabs in pipe when we open $HTML later
    }
}

#######################################################################
# Generates both HTML and TSV files in parallel
#    Assumes all (sorted) data in in @Work
#    Puts error notice in output data files if no records were selected 
# NB file names cannot be constructed before $Project is extracted
#    from the input database file
#######################################################################
sub Web {

    my ($ii,$kk);

    if ( ! $Outfile ) {
	$Outfile = "$Project" . "$WorkName";
    }
    $HTML = "$WorkDir/$Outfile.html";
    $TSV  = "$WorkDir/$Outfile.tsv";

    if ($Tsv) {
	print "*** Writing TSV file $TSV\n" if ($Verbose);
	open(TSV,">$TSV") || die "Could not open $TSV to write output";
    }
    if ($Web) {
	print "*** writing HTML file $HTML\n" if ($Verbose);
	if ($Plain) {
	    open(HTML,"| $Tab $Tabargs >$HTML") || die "Could not open $HTML to write output"; 
	} else {
	    open(HTML,">$HTML") || die "Could not open $HTML to write output";
	}
    }

    if ( $Web ) {
	printf HTML "
<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\">
<html>
<head>
<meta http-equiv=\"Content-Type\" content=\"text/html\";></meta>
<title>$Title</title>

<style type=\"text/css\">
    tbody {font-size:12; padding:0cm}
</style>

</head>
<body>

<h2 align=\"center\">$Title</h2>
<h3 align=\"center\"><i>Last Database Update: $Datetag</i></h3><br>
";
	while (<BASE>) {
	    print HTML;
	}
	print HTML "<a href=$Outfile.tsv>Tab Separated Value report</a></h3>
<br><br>";

	if ( $Plain ) {
	    print HTML "<pre>";
	    print HTML "<b>";
	} else {
	    print HTML "
<table cellpadding=\"2\" border=\"0\">
  <thead>
    <tr align=\"center\"> ";
	}

	foreach $kk ( @Out ) {

	    my $caps = $kk;
	    $caps =~ tr/[a-z]/[A-Z]/;
	    if ($Plain) {
		printf HTML "$caps\t";
	    } else {
		printf HTML "        <td style=\"background-color: %s\"><b>%s</b></td>\n",$Yellow,$caps;
	    }
	}
	if ($Plain) {
	    printf HTML "</b><br>\n";
	} else {
	    printf HTML "      </tr></thead>\n<tbody>\n<tr>";
	}
	# So we leave off here waiting for data fill into table
    }

    if ( $Tsv ) {
	$EDIT = "*EDIT*";
	printf TSV "### Last Data Base Update: $Datetag";
	printf TSV "### EDIT column must contain A (append), C (change), D (delete), or N (no change)\n";
	foreach $kk ( 0 .. $#Out ) {
	    my $caps = $Out[$kk];
	    $caps =~ tr/[a-z]/[A-Z]/;
	    printf TSV "%s\t",$caps;
	}
	printf TSV "$EDIT\n";
    }

#    if ( $Print ) {
#	print "*** Writing PRN file $PRN\n" if ($Verbose);
#	open(PRN,">$PRN") || die "Could not open $PRN to write output";
#	foreach $jj ( 1..$#Fields ) {     # set the %Length array to 0
#	    $Length{$Fields[$jj]} = 0;
#	}
#    }

    #################################################################
    # This is the major branch to fill the table
    #################################################################
    if (!$NoneSelected) {
	foreach $ii (0 .. $#Work) {
	    &Format($Work[$ii]);
	}
    } else {
	if ( $Web ) {
	    printf HTML "<h3>No documents were selected<br>\n</h3>";
	    printf TSV "\nNo documents were selected\n";
	} 
    }

    printf HTML "</tr></tbody></table>\n" if ($Web && !$Plain);
    printf HTML "<!--#include virtual=\"/Footer.html\"-->";
    printf HTML "</body>\n</html>\n" if ( $Web );
    chmod(0755, "$HTML") if ( $Web );   # req. for include to work
}

#######################################################################
# HTML readers only wrap lines on blank space, so guarantee some
# A line is passed in, a line with perhaps extra blank space is returned
# (Adding extra space doesn't affect HTML commands/formatting at all!)
#######################################################################

sub Wrap {

    my $rets = $_[0];
    my $halfmax = $MAXWORD*2/3;
    my $splits = '.,;:-';

    return $rets if ($rets !~ /\S{$MAXWORD},/);

    $rets =~ s/(\S{$halfmax}[^$splits]*[$splits])/$1 /g;
    return $rets if ($rets !~ /\S{$MAXWORD,}/);

    $rets =~ s/(\S{$MAXWORD})/$1 /g;
    return $rets;
}

######################################################################
# Pod follows
# NB the CSS addition makes possible the desired indent with
#   =over/=item...=item/=back construct when used in an HTML context
########################################################################

=for html 
<style type="text/css">
dl {margin-left: 2cm;}
</style>

=head2 NAME

dbreport -- Extracts data froom a compressed data base according to a template

=head2 USAGE

    dbreport [-hpw] [-d dirname] [-f filename] [-l dirname] [-L dirname]
             [-n field1,field2,...] [-o filename] [-t filename]
             [-T document_title] [start_record [final_record]

=head2 FLAGS

   -d[irecotry] puts results in the named directory;
                "./data/" is the default output directory
   -f[ile]      uses the follwoing file name as the data source;
                if file_name is "-", uses STDIN;
                "./parts.cdb" is the detault data source
   -h[elp]	produces this help message
   -l[ink]	following dir_name is top of the directory tree in Unix space for links;
		default is to use "./file_cabinet/"
   -L[ink]	following dir name is top of the directory tree in Web space for links;
		default is to use "./"
   -n[names]	outputs data only for the named fields;
		default is to output data for all fields
   -o[utput]	uses following name for output files;
		default is "##-data", where ## is the Project No.
   -p[lain]	produes "simple" HTML output; i.e.: no tables
   -s[paces]    substitues hard spaces for each ".." in text 
   -t[abs]      file contains tab spacing for use in plain output
                default is "./parts.tdb"
   -T[itle]	use the following text string as a report title
   -v[ervose]	produces diagnostics on STDOUT
   -w[eb]	produces HTML and TSV output files (default)

   If a file parts.pdb exists, it is read as a list of file suffixes
   for which document links are valid; if no such file exists, the
   default is PDF, TXT.

   In generating an HTML file for the output, after some
   preliiminaries the contents of the file C<base.html> is copied to
   the output prior to the actual record data being written.

   If no record number is given, the entire data base is processed

   If one one record number is given, only that record and all its
   sub-records are processed.

=head2 DESCRIPTION

Subject to all the flags listed above, by default this program takes a
set of data records from a file C<parts.idb> and generates an
HTML-formatted file displaying the contents of the data base.  Links
to all available displayable documents are placed on the primary
document numbers.  Links to the sub-directories containing all the
relevant documents are placed on the revision field.

If the search for a link fails for a given document, a parallel 
universe of the data base prefaced by "itar" will be scanned.

The program C<tabsset> is called in "plain" mode to generate explicit
no-break-spaces for HTML in lieu of tabs.  C<tabset> is passed the 
contents of "parts.tdb" as arguments if available. (The default 
output mode is to produce one long HTML table.)

In parallel with the HTML output, a tab-separated-value file is
generated, suitable for importing into spreadsheet programs.

=head2 BUGS

Alternatives to the file C<base.html> should be available via a flag
on the command line.

=head2 SEE ALSO

=head4 High Level programs

dbnormal

=head4 Low Level programs/files

base.html
parts.cdb
parts.tdb
tabset

=head2 AUTHOR

Bob Goeke

=head2 RCS Information

$Id: dbreport,v 2.17 2020/08/02 00:16:56 goeke Exp goeke $

=cut


######################################################################

######################################################################
# History
######################################################################
# $Log: dbreport,v $
# Revision 2.17  2020/08/02 00:16:56  goeke
# Added required Accessibility footer to web output
#
# Revision 2.16  2018/09/11 18:00:16  goeke
# Substitute 3 hard spaces for each ".." (plain only)
#
# Revision 2.15  2017/12/20 16:45:25  goeke
# Allow for 3-digit project ID when scanning for HTML links
#
# Revision 2.14  2014/04/10 18:19:56  goeke
# Added links to paralell itar directory under "file_cabinet"
#
# Revision 2.13  2014/04/10 14:54:33  goeke
# Edit regex check on Field_names
#
# Revision 2.12  2013/07/22 14:44:46  goeke
# Fixed bug in not displaying link to TSV file in plain output
# Updated pod & help to reference the TSV file
#
# Revision 2.11  2013/07/22 13:12:29  goeke
# Modified call to tabset to read parts.tdb for args
#
# Revision 2.10  2013/07/22 00:26:53  goeke
# Add pod
#
# Revision 2.9  2013/07/17 19:24:55  goeke
# Clean up display of table formatted database
#
# Revision 2.8  2013/04/10 15:40:48  goeke
# Add *EDIT* column and comment to TSV output for use in editing
#
# Revision 2.7  2007/06/04 14:41:40  goeke
# Minor info updates; use /usr/bin/env on first line
#
# Revision 2.6  2006/05/25 19:20:49  goeke
# Cleaned up logic in AddLinks() to fix bug in use of *pdb files
#
# Revision 2.5  2006/01/13 15:15:45  goeke
# Use *.pdb file to define those file suffixes which will link to a drawing
# number for one-click display -- default to *.pdf and *.txt
#
# Revision 2.4  2005/11/17 16:29:20  goeke
# Added EASM files as special case
# Fixed bug in html output on database update line
#
# Revision 2.3  2005/09/15 18:45:01  goeke
# Added handlers for *.easm files
# Added blank lines between major drawing numbers in web/plain output
#
# Revision 2.2  2005/01/06 16:32:31  goeke
# Added -L flag to separate out Unix and Web file spaces
#
# Revision 2.1  2004/12/30 16:01:26  goeke
# Typo in printf statement for TSV output
#
# Revision 2.0  2004/12/29 16:45:27  goeke
# Clean up script for adding prefix to drawing number;
# Fix bug in display of rev when drawing not in the file cabinet
#
# Revision 1.15  2004/12/28 21:39:29  goeke
# Bug fixes and cleanup
#
# Revision 1.14  2004/12/23 19:11:40  goeke
# Fixed bug in cross-link tags
#
# Revision 1.13  2004/12/21 21:57:59  goeke
# Internal cross-ref links implemented
#
# Revision 1.12  2004/12/21 13:54:39  goeke
# Fixed link pick up (though ref links aren't working yet).
#
# Revision 1.11  2004/12/20 20:07:05  goeke
# Allow generation of plain (non-table) HTML file
#
# Revision 1.10  2004/12/20 15:47:59  goeke
# Formatted verbose messages to start with "***" string
#
# Revision 1.9  2004/12/20 14:15:29  goeke
# Add explicit line wrap on table cells
#
# Revision 1.8  2004/12/14 16:29:55  goeke
# A large variety of bug fixes for use as a general database dumper
#
# Revision 1.7  2004/09/28 19:13:45  goeke
# Fix bug in adding link to .txt files
#
# Revision 1.6  2004/07/08 14:36:58  goeke
# Moved position of data base date in TSV output
#
# Revision 1.5  2004/06/29 01:14:52  goeke
# Added links to HTML version
# Fixed bug in single drawing select
#
# Revision 1.3  2004/06/23 19:15:54  goeke
# Add/modify logic to output all daughter documents if only one number given.
#
# Revision 1.2  2004/06/21 16:08:10  goeke
# Accept explicit output file names
# Merge -t flag into -w[eb]
#
# Revision 1.1  2004/06/18 19:21:54  goeke
# Pass title text in; add cdb file date to reports
#
# Revision 1.0  2004/06/18 15:24:25  goeke
# Both HTML and TSV files being generated
#
# Revision 0.5  2004/06/18 13:44:12  goeke
# Fixed various bugs in hash in &Format
#
# Revision 0.4  2004/06/17 19:56:47  goeke
# Hash field contents, only for requested output data
#
# Revision 0.3  2004/06/17 17:56:23  goeke
# Add working directory arg; changed single field logic
#
# Revision 0.2  2004/06/17 15:50:05  goeke
# Fixed bugs in field name select and tsv and web select
#
# Revision 0.1  2004/06/17 15:17:53  goeke
# Just status; only TSV is functional
#
#
# 
######################################################################
######################################################################