example search for Koha database

[webpac2] / run.pl

diff --git a/run.pl b/run.pl
index 01d3e77..ea744e9 100755 (executable)
--- a/run.pl
+++ b/run.pl
@@ -11,7 +11,7 @@ use WebPAC::Parser 0.08;
 use WebPAC::Input 0.16;
 use WebPAC::Store 0.15;
 use WebPAC::Normalize 0.22;
-use WebPAC::Output::TT;
+#use WebPAC::Output::TT;
 use WebPAC::Validate 0.11;
 use WebPAC::Output::MARC;
 use WebPAC::Config;
@@ -22,6 +22,7 @@ use File::Slurp;
 use Data::Dump qw/dump/;
 use Storable qw/dclone/;
 use Pod::Usage qw/pod2usage/;
+use LWP::Simple qw//;
 
 use POSIX ":sys_wait_h"; # imports WNOHANG
 
@@ -102,6 +103,10 @@ Create just links
 
 Create merged index of databases which have links
 
+=item --mirror http://www.example.com
+
+Tries to download input path files from mirror URI
+
 =back
 
 =cut
@@ -122,6 +127,7 @@ my $marc_dump = 0;
 my $parallel = 0;
 my $only_links = 0;
 my $merge = 0;
+my $mirror;
 my $help;
 
 my $log = _new WebPAC::Common()->_get_logger();
@@ -143,6 +149,7 @@ GetOptions(
        "parallel=i" => \$parallel,
        "only-links!" => \$only_links,
        "merge" => \$merge,
+       "mirror=s" => \$mirror,
        "help" => \$help,
 );
 
@@ -371,6 +378,11 @@ foreach my $database ( sort keys %{ $config->databases } ) {
 
                my $input_name = $input->{name} || $log->logdie("input without a name isn't valid: ",dump($input));
 
+               if ( $input->{skip} ) {
+                       $log->info("skip $input_name");
+                       next;
+               }
+
                next if ($only_input && ($input_name !~ m#$only_input#i && $input->{type} !~ m#$only_input#i));
 
                my $type = lc($input->{type});
@@ -398,6 +410,22 @@ foreach my $database ( sort keys %{ $config->databases } ) {
                        delete($input->{modify_file});
                }
 
+               if ( $mirror ) {
+                       my $path = $input->{path} || die "no input path in ",dump( $input );
+
+                       my $base = $path;
+                       $base =~ s{/[^/]+$}{};
+                       mkpath $base unless -e $base;
+
+                       my $rc = LWP::Simple::mirror( "$mirror/$path", $path );
+                       if (LWP::Simple::is_error( $rc )) {
+                               die "can't mirror $mirror/$path -> $path [$rc]";
+                       } else {
+                               $log->info( "mirror ", $path, " [$rc] ", -s $path, " bytes" );
+                       }
+                       
+               }
+
                my $input_db = new WebPAC::Input(
                        module => $input_module,
                        limit => $limit || $input->{limit},
@@ -485,7 +513,9 @@ foreach my $database ( sort keys %{ $config->databases } ) {
 
                my $report_fh;
                if ($stats || $validate) {
-                       my $path = "out/report/${database}-${input_name}.txt";
+                       my $out_report = 'out/report'; # FIXME move to config
+                       mkpath $out_report unless -e $out_report;
+                       my $path = "$out_report/${database}-${input_name}.txt";
                        open($report_fh, '>', $path) || $log->logdie("can't open $path: $!");
 
                        print $report_fh "Report for database '$database' input '$input_name' records ",
@@ -500,15 +530,22 @@ foreach my $database ( sort keys %{ $config->databases } ) {
 
                my $marc;
                if ($marc_generate && $parser->have_rules( 'marc', $database, $input_name )) {
+                       
+                       my $out_marc = 'out/marc'; # FIXME move to config
+                       mkpath $out_marc unless -e $out_marc;
+
                        $marc = new WebPAC::Output::MARC(
-                               path => "out/marc/${database}-${input_name}.marc",
+                               path => "$out_marc/${database}-${input_name}.marc",
                                lint => $marc_lint,
                                dump => $marc_dump,
                        );
                }
 
                my $rules = $parser->normalize_rules($database,$input_name);
-               $log->logwarn("no normalize rules for $database/$input_name") unless $rules;
+               if ( ! $rules ) {
+                       $log->logwarn("no normalize rules for $database/$input_name", $input_db->input_module->can('normalize') ? " using normalize from input module" : '');
+                       next;
+               }
 
                $log->debug("parsed normalize rules:\n$rules");
 
@@ -569,6 +606,9 @@ foreach my $database ( sort keys %{ $config->databases } ) {
                                push @{ $row->{'000'} }, $pos;
                        }
 
+                       foreach my $out ( @output_modules ) {
+                               $out->add_row( $mfn, $row ) if $out->can('add_row');
+                       }
 
                        if ($validate) {
                                if ( my $errors = $validate->validate_rec( $row, $input_db->dump_ascii ) ) {
@@ -579,9 +619,11 @@ foreach my $database ( sort keys %{ $config->databases } ) {
                                next;   # validation doesn't create any output
                        }
 
+                       my $ds;
+
                        if ($rules) {
 
-                               my $ds = WebPAC::Normalize::data_structure(
+                               $ds = WebPAC::Normalize::data_structure(
                                        row => $row,
                                        rules => $rules,
                                        lookup => $lookup_hash,
@@ -598,32 +640,33 @@ foreach my $database ( sort keys %{ $config->databases } ) {
                                        },
                                );
 
-                               $log->debug("ds = ", sub { dump($ds) });
-
-                               if ( $ds ) {
-
-                                       $store->save_ds(
-                                               database => $database,
-                                               input => $input_name,
-                                               id => $mfn,
-                                               ds => $ds,
-                                       ) if !$stats;
-
-                                       $indexer->add(
-                                               id => "${input_name}/${mfn}",
-                                               ds => $ds,
-                                               type => $config->get($indexer_config)->{type},
-                                       ) if $indexer;
+                       } elsif ( $input_db->input_module->can('normalize') ) {
+                               $ds = $input_db->input_module->normalize( $mfn );
+                       }
 
-                                       foreach my $out ( @output_modules ) {
-                                               $out->add( $mfn, $ds ) if $out->can('add');
-                                       }
+                       if ( $ds ) {
+                               $log->debug("ds = ", sub { dump($ds) });
 
-                               } else {
-                                       $log->warn("record $pos didn't produce any output after normalization rules!") unless $marc;
+                               $store->save_ds(
+                                       database => $database,
+                                       input => $input_name,
+                                       id => $mfn,
+                                       ds => $ds,
+                               ) if !$stats;
+
+                               $indexer->add(
+                                       id => "${input_name}/${mfn}",
+                                       ds => $ds,
+                                       type => $config->get($indexer_config)->{type},
+                               ) if $indexer;
+
+                               foreach my $out ( @output_modules ) {
+                                       $out->add( $mfn, $ds ) if $out->can('add');
                                }
-                       }
 
+                       } else {
+                               $log->warn("record $pos didn't produce any output after normalization rules!") unless $marc;
+                       }
                        if ($marc) {
                                my $i = 0;