source: gsdl/trunk/perllib/plugins/ArchivesInfPlugin.pm@ 17739

###########################################################################
#
# ArchivesInfPlugin.pm --
# A component of the Greenstone digital library software
# from the New Zealand Digital Library Project at the 
# University of Waikato, New Zealand.
#
# Copyright (C) 1999 New Zealand Digital Library Project
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
###########################################################################

# plugin which reads through an archives.inf file
# (i.e. the file generated in the archives directory
# when an import is done), processing each file it finds 

package ArchivesInfPlugin;

use util;
use PrintInfo;
use plugin;
use arcinfo;
use gsprintf;

use strict;
no strict 'refs'; # allow filehandles to be variables and viceversa

BEGIN {
    @ArchivesInfPlugin::ISA = ('PrintInfo');
}

my $arguments = [
         ];

my $options = { 'name'     => "ArchivesInfPlugin",
        'desc'     => "{ArchivesInfPlugin.desc}",
        'abstract' => "no",
        'inherits' => "yes" };
         
sub gsprintf
{
    return &gsprintf::gsprintf(@_);
}

sub new {
    my ($class) = shift (@_);
    my ($pluginlist,$inputargs,$hashArgOptLists) = @_;
    push(@$pluginlist, $class);

    push(@{$hashArgOptLists->{"ArgList"}},@{$arguments});
    push(@{$hashArgOptLists->{"OptList"}},$options);

    my $self = new PrintInfo($pluginlist, $inputargs, $hashArgOptLists);

    return bless $self, $class;
}

# called once, at the start of processing
sub init {
    my $self = shift (@_);
    my ($verbosity, $outhandle, $failhandle) = @_;

    # verbosity is passed through from the processor
    $self->{'verbosity'} = $verbosity;

    # as are the outhandle and failhandle
    $self->{'outhandle'} = $outhandle if defined $outhandle;
    $self->{'failhandle'} = $failhandle;

}

sub deinit {
    my ($self) = @_;

    my $archive_info = $self->{'archive_info'};

    if (defined $archive_info) {
    my $archive_info_filename = $self->{'archive_info_filename'};

        my $file_list = $archive_info->get_file_list();

    # change each file to "Been Indexed"

    foreach my $subfile (@$file_list) {
        my $doc_oid = $subfile->[1];
        # why do we get this when it is not used???
        my $index_status = $archive_info->get_status_info($doc_oid);
        $archive_info->set_status_info($doc_oid,"B");
    }

    $archive_info->save_info($archive_info_filename);
    }
}

# called at the beginning of each plugin pass (import has one, buildin has many)
sub begin {
    my $self = shift (@_);
    my ($pluginfo, $base_dir, $processor, $maxdocs) = @_;

}

# called at the end of each plugin pass
sub end {
    my ($self) = shift (@_);

}

# called if we are doing incremental building
sub set_incremental {
    my $self = shift(@_);
    my ($incremental) = @_;

    $self->{'incremental'} = $incremental;
}

# return 1 if this class might recurse using $pluginfo
sub is_recursive {
    my $self = shift (@_);

    return 1;
}


sub compile_stats {
    my $self = shift(@_);
    my ($stats) = @_;
}

# We don't do metadata_read
sub metadata_read {
    my $self = shift (@_);
    my ($pluginfo, $base_dir, $file, $block_hash, $extrametakeys, $extrametadata, $processor, $maxdocs, $gli) = @_;

    return undef;
}

# we don't do any file blocking
sub file_block_read {

    my $self = shift (@_);  
    my ($pluginfo, $base_dir, $file, $block_hash, $metadata, $gli) = @_;

    return undef;
}


# return number of files processed, undef if can't process
# Note that $base_dir might be "" and that $file might 
# include directories
sub read {
    my $self = shift (@_);
    my ($pluginfo, $base_dir, $file, $block_hash, $metadata, $processor, $maxdocs,$total_count, $gli) = @_;
    my $outhandle = $self->{'outhandle'};

    my $count = 0;

    # see if this has a archives information file within it
    my $archive_info_filename = &util::filename_cat($base_dir,$file,"archives.inf");

    if (-e $archive_info_filename) {

    # found an archives.inf file
    &gsprintf($outhandle, "ArchivesInfPlugin: {common.processing} $archive_info_filename\n") if $self->{'verbosity'} > 1;

    # read in the archives information file
    my $archive_info = new arcinfo ();
    $self->{'archive_info'} = $archive_info;
    $self->{'archive_info_filename'} = $archive_info_filename;

    $archive_info->load_info ($archive_info_filename);
    
    my $file_list = $archive_info->get_file_list();

    # process each file
    foreach my $subfile (@$file_list) {
        last if ($maxdocs != -1 && ($total_count + $count) >= $maxdocs);

        my $tmp = &util::filename_cat ($file, $subfile->[0]);
        next if $tmp eq $file;
        
        # We always process the file...
        my $process_file = 1;

        # ...unless the build processor is incremental capable and -incremental was specified
        if ($processor->is_incremental_capable() && $self->{'incremental'})
        {
            # We don't need to process the file if it has already been built
        my $doc_oid = $subfile->[1];
        my $index_status = $archive_info->get_status_info($doc_oid);
        if ($index_status eq "B")
        {
            # Don't process this file
            $process_file = 0;
        }
        }

        if ($process_file) {
        # note: metadata is not carried on to the next level
        $count += &plugin::read ($pluginfo, $base_dir, $tmp, $block_hash, {}, $processor, $maxdocs, ($total_count+$count), $gli);
        }

    }

    return $count;
    }

    # wasn't an archives directory, someone else will have to process it
    return undef;
}

1;