[sitka/sitka-tools.git] / marc_export_custom / marc_export_custom

#!/usr/bin/perl
# vim:et:sw=4:ts=4:
use strict;
use warnings;
use bytes;

use OpenSRF::System;
use OpenSRF::EX qw/:try/;
use OpenSRF::AppSession;
use OpenSRF::Utils::JSON;
use OpenSRF::Utils::SettingsClient;
use OpenILS::Application::AppUtils;
use OpenILS::Utils::Fieldmapper;
use OpenILS::Utils::CStoreEditor;

use MARC::Record;
use MARC::File::XML;
use UNIVERSAL::require;

use Time::HiRes qw/time/;
use Getopt::Long;

use Config::Simple;
use Data::Dumper;

my @formats = qw/USMARC UNIMARC XML BRE ARE/;

my ($config,$format,$encoding,$location,$dollarsign,$idl,$help,$holdings,$timeout,$export_mfhd,$type,$all_records) = ('/openils/conf/opensrf_core.xml','USMARC','MARC8','','$',0,undef,undef,0,undef,'biblio',undef);
my ($exclusion_ini,$collapse_to_depth, $output_file);
my $cfg;
my $force901;

GetOptions(
        'help'       => \$help,
        'items'      => \$holdings,
        'mfhd'       => \$export_mfhd,
        'all'        => \$all_records,
        'location=s' => \$location,
        'money=s'    => \$dollarsign,
        'config=s'   => \$config,
        'format=s'   => \$format,
        'type=s'     => \$type,
        'xml-idl=s'  => \$idl,
        'encoding=s' => \$encoding,
        'timeout=i'  => \$timeout,
        'force901'  => \$force901,
        'exclusion_ini=s' => \$exclusion_ini,
        'collapse_to_depth=i' => \$collapse_to_depth,
	'output-file=s' => \$output_file,
);

if ($exclusion_ini) {
	die "exclusion ini file does not exist" unless (-r $exclusion_ini and -s $exclusion_ini);
	$cfg = new Config::Simple($exclusion_ini) 
}

if ($help) {
print <<"HELP";
This script exports MARC authority, bibliographic, and serial holdings
records from an Evergreen database. 

Input to this script can consist of a list of record IDs, with one record ID
per line, corresponding to the record ID in the Evergreen database table of
your requested record type.

Alternately, passing the --all option will attempt to export all records of
the specified type from the Evergreen database. The --all option starts at
record ID 1 and increments the ID by 1 until the largest ID in the database
is retrieved. This may not be very efficient for databases with large gaps
in their ID sequences.

Usage: $0 [options]
 --help or -h       This screen.
 --config or -c     Configuration file [/openils/conf/opensrf_core.xml]
 --format or -f     Output format (USMARC, UNIMARC, XML, BRE, ARE) [USMARC]
 --encoding or -e   Output encoding (UTF-8, ISO-8859-?, MARC8) [MARC8]
 --xml-idl or -x    Location of the IDL XML
 --timeout          Timeout for exporting a single record; increase if you
                    are using --holdings and are exporting records that
                    have a lot of items attached to them.
 --type or -t       Record type (BIBLIO, AUTHORITY) [BIBLIO]
 --all or -a        Export all records; ignores input list

 Additional options for type = 'BIBLIO':
 --items or -i      Include items (holdings) in the output
 --money            Currency symbol to use in item price field [\$]
 --mfhd             Export serial MFHD records for associated bib records
                    Not compatible with --format=BRE
 --location or -l   MARC Location Code for holdings from
                    http://www.loc.gov/marc/organizations/orgshome.html

Examples:

To export a set of USMARC records in a file named "output_file" based on the
IDs contained in a file named "list_of_ids":
  cat list_of_ids | $0 > output_file

To export a set of MARC21XML authority records in a file named "output.xml"
for all authority records in the database:
  $0 --format XML --type AUTHORITY --all > output.xml

HELP
    exit;
}

$type = lc($type);
$format = uc($format);
$encoding = uc($encoding);

my $outfh;
my $real_stdout;
open($real_stdout, ">&STDOUT") or die "Can't dup STDOUT: $!";
if($output_file) {
    open($outfh, '>', $output_file) or die "Can't open file for output $output_file: $!"; 
} else {
    $outfh = $real_stdout;
}

binmode($outfh, ':raw') if ($encoding ne 'UTF-8');
binmode($outfh, ':utf8') if ($encoding eq 'UTF-8');

if (!grep { $format eq $_ } @formats) {
    die "Please select a supported format.  ".
        "Right now that means one of [".
        join('|',@formats). "]\n";
}

if ($format ne 'XML') {
    my $type = 'MARC::File::' . $format;
    $type->require;
}

if ($timeout <= 0) {
    # set default timeout and/or correct silly user who 
    # supplied a negative timeout; default timeout of
    # 300 seconds if exporting items determined empirically.
    $timeout = $holdings ? 300 : 1;
}

OpenSRF::System->bootstrap_client( config_file => $config );

if (!$idl) {
    $idl = OpenSRF::Utils::SettingsClient->new->config_value("IDL");
}

Fieldmapper->import(IDL => $idl);

my $ses = OpenSRF::AppSession->create('open-ils.cstore');
OpenILS::Utils::CStoreEditor::init();
my $editor = OpenILS::Utils::CStoreEditor->new();

print $outfh <<HEADER if ($format eq 'XML');
<?xml version="1.0" encoding="$encoding"?>
<collection xmlns='http://www.loc.gov/MARC21/slim'>
HEADER

my %orgs;
my %shelves;
my %statuses;
my %outypes;

my $flesh = {};

if ($holdings) {
    get_bib_locations();
}

my $start = time;
my $last_time = time;
my %count = ('bib' => 0, 'did' => 0);
my $speed = 0;

if ($all_records) {
    my $top_record = 0;
    if ($type eq 'biblio') {
        $top_record = $editor->search_biblio_record_entry([
            {deleted => 'f'},
            {order_by => { 'bre' => 'id DESC' }, limit => 1}
        ])->[0]->id;
    } elsif ($type eq 'authority') {
        $top_record = $editor->search_authority_record_entry([
            {deleted => 'f'},
            {order_by => { 'are' => 'id DESC' }, limit => 1}
        ])->[0]->id;
    }
    for (my $i = 0; $i++ < $top_record;) {
        export_record($i);
    }
} else {
    while ( my $i = <> ) {
        export_record($i);
    }
}

print $outfh "</collection>\n" if ($format eq 'XML');

$speed = $count{did} / (time - $start);
my $time = time - $start;
print STDERR <<DONE;

Exports Attempted : $count{bib}
Exports Completed : $count{did}
Overall Speed     : $speed
Total Time Elapsed: $time seconds

DONE

sub export_record {
    my $id = shift;

    my $bib; 

    my $r = $ses->request( "open-ils.cstore.direct.$type.record_entry.retrieve", $id, $flesh );
    my $s = $r->recv(timeout => $timeout);
    if (!$s) {
        warn "\n!!!!! Failed trying to read record $id\n";
        return;
    }
    if ($r->failed) {
        warn "\n!!!!!! Failed trying to read record $id: " . $r->failed->stringify . "\n";
        return;
    }
    if ($r->timed_out) {
        warn "\n!!!!!! Timed out trying to read record $id\n";
        return;
    }
    $bib = $s->content;
    $r->finish;

    $count{bib}++;
    return unless $bib;

    if ($format eq 'ARE' or $format eq 'BRE') {
        print $outfh OpenSRF::Utils::JSON->perl2JSON($bib);
        stats();
        $count{did}++;
        return;
    }

    try {

        my $r = MARC::Record->new_from_xml( $bib->marc, $encoding, $format );
        if ($type eq 'biblio') {
            add_bib_holdings($bib, $r);
        }

        if($force901){
            $r->delete_field( $r->field('901') );
            $r->append_fields(
                MARC::Field->new(
                    '901', ' ', ' ',
                    a => $bib->tcn_value,
                    b => $bib->tcn_source,
                    c => $bib->id
                )
            );
        }

        if ($format eq 'XML') {
            my $xml = $r->as_xml_record;
            $xml =~ s/^<\?.+?\?>$//mo;
            print $outfh $xml;
        } elsif ($format eq 'UNIMARC') {
            print $outfh $r->as_usmarc;
        } elsif ($format eq 'USMARC') {
            print $outfh $r->as_usmarc;
        }

        $count{did}++;

    } otherwise {
        my $e = shift;
        my $errorid = $id;
	chomp($errorid);
        chomp($e);
        warn "\nERROR ON RECORD $errorid: $e\n";
        import MARC::File::XML; # reset SAX parser so that one bad record doesn't kill the entire export
    };

    if ($export_mfhd and $type eq 'biblio') {
        my $mfhds = $editor->search_serial_record_entry({record => $id, deleted => 'f'});
        foreach my $mfhd (@$mfhds) {
            try {
                my $r = MARC::Record->new_from_xml( $mfhd->marc, $encoding, $format );

                if($force901){
                    $r->delete_field( $r->field('901') );
                    $r->append_fields(
                        MARC::Field->new(
                            '901', ' ', ' ',
                            a => $bib->tcn_value,
                            b => $bib->tcn_source,
                            c => $bib->id
                        )
                    );
                }

                if ($format eq 'XML') {
                    my $xml = $r->as_xml_record;
                    $xml =~ s/^<\?.+?\?>$//mo;
                    print $outfh $xml;
                } elsif ($format eq 'UNIMARC') {
                    print $outfh $r->as_usmarc;
                } elsif ($format eq 'USMARC') {
                    print $outfh $r->as_usmarc;
                }
            } otherwise {
                my $e = shift;
                my $errorid = chomp($id);
                chomp($e);
                warn "\nERROR ON MFHD RECORD $errorid: $e\n";
                import MARC::File::XML; # reset SAX parser so that one bad record doesn't kill the entire export
            };
        }
    }

    stats() if (! ($count{bib} % 50 ));
}

sub stats {
    try {
        no warnings;

        $speed = $count{did} / (time - $start);

        my $speed_now = ($count{did} - $count{did_last}) / (time - $count{time_last});
        my $cn_speed = $count{cn} / (time - $start);
        my $cp_speed = $count{cp} / (time - $start);

        printf STDERR "\r  $count{did} of $count{bib} @  \%0.4f/s ttl / \%0.4f/s rt ".
                "($count{cn} CNs @ \%0.4f/s :: $count{cp} CPs @ \%0.4f/s)\r",
                $speed,
                $speed_now,
                $cn_speed,
                $cp_speed;
    } otherwise {};
    $count{did_last} = $count{did};
    $count{time_last} = time;
}

sub get_bib_locations {
    print STDERR "Retrieving Org Units ... ";
    my $r = $ses->request( 'open-ils.cstore.direct.actor.org_unit.search', { id => { '!=' => undef } } );

    while (my $o = $r->recv) {
        die $r->failed->stringify if ($r->failed);
        $o = $o->content;
        last unless ($o);
        $orgs{$o->id} = $o;
    }
    $r->finish;
    print STDERR "OK\n";

    print STDERR "Retrieving Copy statuses ... ";
    $r = $ses->request( 'open-ils.cstore.direct.config.copy_status.search', { id => { '!=' => undef } } );

    while (my $sta = $r->recv) {
        die $r->failed->stringify if ($r->failed);
        $sta = $sta->content;
        last unless ($sta);
        $statuses{$sta->id} = $sta;
    }
    $r->finish;
    print STDERR "OK\n";

    print STDERR "Retrieving OU types ... ";
    $r = $ses->request( 'open-ils.cstore.direct.actor.org_unit_type.search', { id => { '!=' => undef } } );

    while (my $outy = $r->recv) {
        die $r->failed->stringify if ($r->failed);
        $outy = $outy->content;
        last unless ($outy);
        $outypes{$outy->id} = $outy;
    }
    $r->finish;
    print STDERR "OK\n";

    print STDERR "Retrieving Shelving locations ... ";
    $r = $ses->request( 'open-ils.cstore.direct.asset.copy_location.search', { id => { '!=' => undef } } );

    while (my $s = $r->recv) {
        die $r->failed->stringify if ($r->failed);
        $s = $s->content;
        last unless ($s);
        $shelves{$s->id} = $s;
    }
    $r->finish;
    print STDERR "OK\n";

    $flesh = { flesh => 2, flesh_fields => { bre => [ 'call_numbers' ], acn => [ 'copies' ] } };
}

sub add_bib_holdings {
    my $bib = shift;
    my $r = shift;

    my $cn_list = $bib->call_numbers;
    if ($cn_list && @$cn_list) {

        $count{cn} += @$cn_list;
    
        my $cp_list = [ map { @{ $_->copies } } @$cn_list ];
        if ($cp_list && @$cp_list) {

            my %cn_map;
            push @{$cn_map{$_->call_number}}, $_ for (@$cp_list);
                            
            for my $cn ( @$cn_list ) {
                my $cn_map_list = $cn_map{$cn->id};

                COPYMAP: for my $cp ( @$cn_map_list ) {
                    $count{cp}++;


                    my $owninglib = $cn->owning_lib;
                    my $circlib = $cp->circ_lib;
                    my $printlib = $cp->circ_lib;

                    if($cfg){
                        my $thisorg = $orgs{$circlib};

                        if($collapse_to_depth){
                            while ( $outypes{ $thisorg->ou_type }->depth > $collapse_to_depth ){
                                my $localcfg = $cfg->param(-block=> $thisorg->shortname);
                                if( $localcfg->{'DontCollapse'} ){
                                    last;
                                }
                                if($thisorg->parent_ou){
                                    $thisorg = $orgs{$thisorg->parent_ou};
                                    $printlib = $thisorg->id;
                                }
                            }
                        }

                        $thisorg = $orgs{$circlib};


                        while( $thisorg ){
                            # load the local config from the .ini file for exclusions
                            my $localcfg = $cfg->param(-block=> $thisorg->shortname);
                            my $cfgparam;

                            # if we see this setting, just skip that org

                            $cfgparam = 'ExcludeEntireOrg'; 
                            if( $localcfg->{$cfgparam} ) 
                            { skipnote($bib->id, $cfgparam); next COPYMAP; } 

                            # what follows are exclusion rules
                    
                            # Excluded Flags
                            $cfgparam = 'Flags'; 
                            if($localcfg->{$cfgparam}){
                                # this little line is just forcing scalars into an array so we can 'use strict' with Config::Simple
                                my @flags = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}));
                                if( grep { $_ eq 'reference' } @flags && $cp->ref eq 't')
                                { skipnote($bib->id,"Flags: reference"); next COPYMAP; } 
                                elsif( grep { $_ eq 'unholdable' } @flags && $cp->holdable eq 'f')
                                { skipnote($bib->id,"Flags: unholdable"); next COPYMAP; } 
                                elsif( grep { $_ eq 'circulate' } @flags && $cp->circulate eq 'f')
                                { skipnote($bib->id,"Flags: circulate"); next COPYMAP; } 
                                elsif( grep { $_ eq 'hidden' } @flags && $cp->opac_visible eq 'f')
                                { skipnote($bib->id,"Flags: hidden"); next COPYMAP; } 
                            }

                            # Excluded Circ Modifiers
                            $cfgparam = 'CircMods'; 
                            if($localcfg->{$cfgparam}){
                                my $circmod = $cp->circ_modifier || "";
                                my @circmods = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
                                if( grep { $_ eq $circmod } @circmods && @circmods)
                                { skipnote($bib->id,$cfgparam); next COPYMAP; } 
                            }
                            # Inverse rule -- only include specified Circ Mods
                            $cfgparam = 'OnlyIncludeCircMods'; 
                            if($localcfg->{$cfgparam}){
                                my $circmod = $cp->circ_modifier || "";
                                my @circmods = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
                                unless( grep { $_ and $_ eq $circmod } @circmods && @circmods)
                                { skipnote($bib->id,$cfgparam); next COPYMAP; } 
                            }
                            # Excluded Copy Statuses
                            $cfgparam = 'Statuses'; 
                            if($localcfg->{$cfgparam}){
                                my @statuses = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
                                if( grep { $_ eq $statuses{$cp->status}->name } @statuses && @statuses)
                                { skipnote($bib->id,$cfgparam); next COPYMAP; } 
                            }
                            # Excluded Locations
                            $cfgparam = 'Locations'; 
                            if($localcfg->{$cfgparam}){
                                my @locations = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
                                if( grep { $_ eq $shelves{$cp->location}->name } @locations && @locations)
                                { skipnote($bib->id,$cfgparam); next COPYMAP; }
                            }
                            # Inverse rule - Only use the specified locations
                            $cfgparam = 'OnlyIncludeLocations'; 
                            if($localcfg->{$cfgparam}){
                                my @locations = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{'Locations'}) );
                                unless( grep { $_ eq $shelves{$cp->location}->name } @locations && @locations)
                                { skipnote($bib->id,$cfgparam); next COPYMAP; } 
                            }
                            # exclude based on a regex match to location names
                            $cfgparam = 'LocationRegex'; 
                            if($localcfg->{$cfgparam}){
                                my @locregex = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
                                my $reg = $localcfg->{$cfgparam};
                                if( grep { $shelves{$cp->location}->name =~ m/($reg)/ } @locregex && @locregex)
                                { skipnote($bib->id,$cfgparam); next COPYMAP; }
                            }
                            # include based on a regex match to location names
                            $cfgparam = 'OnlyIncludeLocationRegex'; 
                            if($localcfg->{$cfgparam}){
                                my @locregex = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
                                my $reg = $localcfg->{$cfgparam};
                                unless( grep { $shelves{$cp->location}->name =~ m/($reg)/ } @locregex && @locregex)
                                { skipnote($bib->id,$cfgparam); next COPYMAP; } 
                            }
                            # Exclude based on a callno regex
                            $cfgparam = 'CallNoRegex'; 
                            if($localcfg->{$cfgparam}){
                                my @callnoregex = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
                                my $reg = $localcfg->{$cfgparam};
                                if( grep { $cn->label =~ m/($reg)/ } @callnoregex && @callnoregex)
                                { skipnote($bib->id,$cfgparam); next COPYMAP; }
                            }
                            # Include based on a callno regex
                            $cfgparam = 'OnlyIncludeCallNoRegex'; 
                            if($localcfg->{$cfgparam}){
                                my @callnoregex = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
                                my $reg = $localcfg->{$cfgparam};
                                unless( grep { $cn->label =~ m/($reg)/ } @callnoregex && @callnoregex)
                                { skipnote($bib->id,$cfgparam); next COPYMAP; } 
                            }

                            # Trim call number to a float and exclude based on Dewey Range
                            if($localcfg->{'DeweyGT'} || $localcfg->{'DeweyLT'}){
                                my $gt = $localcfg->{'DeweyGT'};
                                my $lt = $localcfg->{'DeweyLT'};

                                # FIXME if either config has an array just ditch for now
                                if (ref($gt) eq "ARRAY" or ref($lt) eq "ARRAY")
                                { skipnote($bib->id,""); next COPYMAP; } 
                                $gt =~ s/[^0-9\.]//g if $gt; #trim off anything not deweyish
                                $lt =~ s/[^0-9\.]//g if $lt; #trim off anything not deweyish

                                my $callno = $cn->label;
                                $callno =~ s/[^0-9\.]//g; #trim off anything not deweyish
                                print STDERR $callno;
                                #note that we are making big assumptions about the call numbers in the db 

                                # we have a range, exclude what's inbetween
                                if($lt && $gt){
                                    if($callno > $gt and $callno < $lt)
                                    { skipnote($bib->id,"Dewey LTGT"); next COPYMAP; } 
                                # we only have a top threshold, exclude everything below it
                                } elsif ($lt){
                                    if($callno < $lt)
                                    { skipnote($bib->id,"Dewey LT"); next COPYMAP; }
                                # we only have a bottom threshold, exclude everything above it
                                } elsif ($gt){
                                    if($callno > $gt)
                                    { skipnote($bib->id,"Dewey GT"); next COPYMAP; } 
                                }
                            }

                            if($thisorg->parent_ou){
                                 $thisorg = $orgs{$thisorg->parent_ou}
                            } else {
                                $thisorg = ();
                            }
                            
                        }
                    }

                    $r->append_fields(
                        MARC::Field->new(
                            852, '4', '', 
                            a => $location,
                            b => $orgs{$printlib}->shortname,
                            #b => $orgs{$owninglib}->shortname,
                            #b => $orgs{$circlib}->shortname,
                            c => $shelves{$cp->location}->name,
                            j => $cn->label,
                            ($cp->circ_modifier ? ( g => $cp->circ_modifier ) : ()),
                            p => $cp->barcode,
                            ($cp->price ? ( y => $dollarsign.$cp->price ) : ()),
                            ($cp->copy_number ? ( t => $cp->copy_number ) : ()),
                            ($cp->ref eq 't' ? ( x => 'reference' ) : ()),
                            ($cp->holdable eq 'f' ? ( x => 'unholdable' ) : ()),
                            ($cp->circulate eq 'f' ? ( x => 'noncirculating' ) : ()),
                            ($cp->opac_visible eq 'f' ? ( x => 'hidden' ) : ()),
                            z => $statuses{$cp->status}->name,
                        )
                    );


                    stats() if (! ($count{cp} % 100 ));
                } # COPYMAP: for my $cp ( @$cn_map_list )
            } # for my $cn ( @$cn_list )
        } # if ($cp_list && @$cp_list)
    } # if ($cn_list && @$cn_list) 
} # sub

sub skipnote { 
	my $id = shift;
	my $note = shift;
	my $outf = *STDERR;
	$outf = *STDOUT if($output_file) ;
	printf($outf "Skipped %s due to config: %s\n",$id,$note); 
}
Commit	Line	Data
456d236e JF	1	#!/usr/bin/perl
	2	# vim:et:sw=4:ts=4:
	3	use strict;
	4	use warnings;
	5	use bytes;
	6
	7	use OpenSRF::System;
	8	use OpenSRF::EX qw/:try/;
	9	use OpenSRF::AppSession;
	10	use OpenSRF::Utils::JSON;
	11	use OpenSRF::Utils::SettingsClient;
	12	use OpenILS::Application::AppUtils;
	13	use OpenILS::Utils::Fieldmapper;
	14	use OpenILS::Utils::CStoreEditor;
	15
	16	use MARC::Record;
	17	use MARC::File::XML;
	18	use UNIVERSAL::require;
	19
	20	use Time::HiRes qw/time/;
	21	use Getopt::Long;
	22
	23	use Config::Simple;
	24	use Data::Dumper;
	25
	26	my @formats = qw/USMARC UNIMARC XML BRE ARE/;
	27
	28	my ($config,$format,$encoding,$location,$dollarsign,$idl,$help,$holdings,$timeout,$export_mfhd,$type,$all_records) = ('/openils/conf/opensrf_core.xml','USMARC','MARC8','','$',0,undef,undef,0,undef,'biblio',undef);
48566282	29	my ($exclusion_ini,$collapse_to_depth, $output_file);
456d236e	30	my $cfg;
5eb3fcb8	31	my $force901;
456d236e JF	32
	33	GetOptions(
	34	'help' => \$help,
	35	'items' => \$holdings,
	36	'mfhd' => \$export_mfhd,
	37	'all' => \$all_records,
	38	'location=s' => \$location,
	39	'money=s' => \$dollarsign,
	40	'config=s' => \$config,
	41	'format=s' => \$format,
	42	'type=s' => \$type,
	43	'xml-idl=s' => \$idl,
	44	'encoding=s' => \$encoding,
	45	'timeout=i' => \$timeout,
5eb3fcb8	46	'force901' => \$force901,
456d236e JF	47	'exclusion_ini=s' => \$exclusion_ini,
456d236e JF	48	'collapse_to_depth=i' => \$collapse_to_depth,
48566282	49	'output-file=s' => \$output_file,
456d236e JF	50	);
456d236e JF	51
8a28571b RJ	52	if ($exclusion_ini) {
	53	die "exclusion ini file does not exist" unless (-r $exclusion_ini and -s $exclusion_ini);
	54	$cfg = new Config::Simple($exclusion_ini)
	55	}
456d236e JF	56
	57	if ($help) {
	58	print <<"HELP";
	59	This script exports MARC authority, bibliographic, and serial holdings
	60	records from an Evergreen database.
	61
	62	Input to this script can consist of a list of record IDs, with one record ID
	63	per line, corresponding to the record ID in the Evergreen database table of
	64	your requested record type.
	65
	66	Alternately, passing the --all option will attempt to export all records of
	67	the specified type from the Evergreen database. The --all option starts at
	68	record ID 1 and increments the ID by 1 until the largest ID in the database
	69	is retrieved. This may not be very efficient for databases with large gaps
	70	in their ID sequences.
	71
	72	Usage: $0 [options]
	73	--help or -h This screen.
	74	--config or -c Configuration file [/openils/conf/opensrf_core.xml]
	75	--format or -f Output format (USMARC, UNIMARC, XML, BRE, ARE) [USMARC]
	76	--encoding or -e Output encoding (UTF-8, ISO-8859-?, MARC8) [MARC8]
	77	--xml-idl or -x Location of the IDL XML
	78	--timeout Timeout for exporting a single record; increase if you
	79	are using --holdings and are exporting records that
	80	have a lot of items attached to them.
	81	--type or -t Record type (BIBLIO, AUTHORITY) [BIBLIO]
	82	--all or -a Export all records; ignores input list
	83
	84	Additional options for type = 'BIBLIO':
	85	--items or -i Include items (holdings) in the output
	86	--money Currency symbol to use in item price field [\$]
	87	--mfhd Export serial MFHD records for associated bib records
	88	Not compatible with --format=BRE
	89	--location or -l MARC Location Code for holdings from
	90	http://www.loc.gov/marc/organizations/orgshome.html
	91
	92	Examples:
	93
	94	To export a set of USMARC records in a file named "output_file" based on the
	95	IDs contained in a file named "list_of_ids":
	96	cat list_of_ids \| $0 > output_file
	97
	98	To export a set of MARC21XML authority records in a file named "output.xml"
	99	for all authority records in the database:
	100	$0 --format XML --type AUTHORITY --all > output.xml
	101
	102	HELP
	103	exit;
	104	}
	105
	106	$type = lc($type);
	107	$format = uc($format);
	108	$encoding = uc($encoding);
	109
48566282 RJ	110	my $outfh;
	111	my $real_stdout;
	112	open($real_stdout, ">&STDOUT") or die "Can't dup STDOUT: $!";
	113	if($output_file) {
	114	open($outfh, '>', $output_file) or die "Can't open file for output $output_file: $!";
	115	} else {
	116	$outfh = $real_stdout;
	117	}
	118
	119	binmode($outfh, ':raw') if ($encoding ne 'UTF-8');
	120	binmode($outfh, ':utf8') if ($encoding eq 'UTF-8');
456d236e JF	121
	122	if (!grep { $format eq $_ } @formats) {
	123	die "Please select a supported format. ".
	124	"Right now that means one of [".
	125	join('\|',@formats). "]\n";
	126	}
	127
	128	if ($format ne 'XML') {
	129	my $type = 'MARC::File::' . $format;
	130	$type->require;
	131	}
	132
	133	if ($timeout <= 0) {
	134	# set default timeout and/or correct silly user who
	135	# supplied a negative timeout; default timeout of
	136	# 300 seconds if exporting items determined empirically.
	137	$timeout = $holdings ? 300 : 1;
	138	}
	139
	140	OpenSRF::System->bootstrap_client( config_file => $config );
	141
	142	if (!$idl) {
	143	$idl = OpenSRF::Utils::SettingsClient->new->config_value("IDL");
	144	}
	145
	146	Fieldmapper->import(IDL => $idl);
	147
	148	my $ses = OpenSRF::AppSession->create('open-ils.cstore');
	149	OpenILS::Utils::CStoreEditor::init();
	150	my $editor = OpenILS::Utils::CStoreEditor->new();
	151
48566282	152	print $outfh <<HEADER if ($format eq 'XML');
456d236e JF	153	<?xml version="1.0" encoding="$encoding"?>
	154	<collection xmlns='http://www.loc.gov/MARC21/slim'>
	155	HEADER
	156
	157	my %orgs;
	158	my %shelves;
	159	my %statuses;
	160	my %outypes;
	161
	162	my $flesh = {};
	163
	164	if ($holdings) {
	165	get_bib_locations();
	166	}
	167
	168	my $start = time;
	169	my $last_time = time;
	170	my %count = ('bib' => 0, 'did' => 0);
	171	my $speed = 0;
	172
	173	if ($all_records) {
	174	my $top_record = 0;
	175	if ($type eq 'biblio') {
	176	$top_record = $editor->search_biblio_record_entry([
	177	{deleted => 'f'},
	178	{order_by => { 'bre' => 'id DESC' }, limit => 1}
	179	])->[0]->id;
	180	} elsif ($type eq 'authority') {
	181	$top_record = $editor->search_authority_record_entry([
	182	{deleted => 'f'},
	183	{order_by => { 'are' => 'id DESC' }, limit => 1}
	184	])->[0]->id;
	185	}
	186	for (my $i = 0; $i++ < $top_record;) {
	187	export_record($i);
	188	}
	189	} else {
	190	while ( my $i = <> ) {
	191	export_record($i);
	192	}
	193	}
	194
48566282	195	print $outfh "</collection>\n" if ($format eq 'XML');
456d236e JF	196
	197	$speed = $count{did} / (time - $start);
	198	my $time = time - $start;
	199	print STDERR <<DONE;
	200
	201	Exports Attempted : $count{bib}
	202	Exports Completed : $count{did}
	203	Overall Speed : $speed
	204	Total Time Elapsed: $time seconds
	205
	206	DONE
	207
	208	sub export_record {
	209	my $id = shift;
	210
	211	my $bib;
	212
	213	my $r = $ses->request( "open-ils.cstore.direct.$type.record_entry.retrieve", $id, $flesh );
	214	my $s = $r->recv(timeout => $timeout);
	215	if (!$s) {
	216	warn "\n!!!!! Failed trying to read record $id\n";
	217	return;
	218	}
	219	if ($r->failed) {
	220	warn "\n!!!!!! Failed trying to read record $id: " . $r->failed->stringify . "\n";
	221	return;
	222	}
	223	if ($r->timed_out) {
	224	warn "\n!!!!!! Timed out trying to read record $id\n";
	225	return;
	226	}
	227	$bib = $s->content;
	228	$r->finish;
	229
	230	$count{bib}++;
	231	return unless $bib;
	232
	233	if ($format eq 'ARE' or $format eq 'BRE') {
48566282	234	print $outfh OpenSRF::Utils::JSON->perl2JSON($bib);
456d236e JF	235	stats();
	236	$count{did}++;
	237	return;
	238	}
	239
	240	try {
	241
	242	my $r = MARC::Record->new_from_xml( $bib->marc, $encoding, $format );
	243	if ($type eq 'biblio') {
	244	add_bib_holdings($bib, $r);
	245	}
	246
6f8820ad JF	247	if($force901){
	248	$r->delete_field( $r->field('901') );
	249	$r->append_fields(
	250	MARC::Field->new(
	251	'901', ' ', ' ',
	252	a => $bib->tcn_value,
	253	b => $bib->tcn_source,
	254	c => $bib->id
	255	)
	256	);
	257	}
	258
456d236e JF	259	if ($format eq 'XML') {
	260	my $xml = $r->as_xml_record;
	261	$xml =~ s/^<\?.+?\?>$//mo;
48566282	262	print $outfh $xml;
456d236e	263	} elsif ($format eq 'UNIMARC') {
48566282	264	print $outfh $r->as_usmarc;
456d236e	265	} elsif ($format eq 'USMARC') {
48566282	266	print $outfh $r->as_usmarc;
456d236e JF	267	}
	268
	269	$count{did}++;
	270
	271	} otherwise {
	272	my $e = shift;
28ab66e8	273	my $errorid = $id;
7ac3e65f	274	chomp($errorid);
e759b05b JF	275	chomp($e);
e759b05b JF	276	warn "\nERROR ON RECORD $errorid: $e\n";
456d236e JF	277	import MARC::File::XML; # reset SAX parser so that one bad record doesn't kill the entire export
	278	};
	279
	280	if ($export_mfhd and $type eq 'biblio') {
	281	my $mfhds = $editor->search_serial_record_entry({record => $id, deleted => 'f'});
	282	foreach my $mfhd (@$mfhds) {
	283	try {
	284	my $r = MARC::Record->new_from_xml( $mfhd->marc, $encoding, $format );
	285
6f8820ad JF	286	if($force901){
	287	$r->delete_field( $r->field('901') );
	288	$r->append_fields(
	289	MARC::Field->new(
	290	'901', ' ', ' ',
	291	a => $bib->tcn_value,
	292	b => $bib->tcn_source,
	293	c => $bib->id
	294	)
	295	);
	296	}
	297
456d236e JF	298	if ($format eq 'XML') {
	299	my $xml = $r->as_xml_record;
	300	$xml =~ s/^<\?.+?\?>$//mo;
48566282	301	print $outfh $xml;
456d236e	302	} elsif ($format eq 'UNIMARC') {
48566282	303	print $outfh $r->as_usmarc;
456d236e	304	} elsif ($format eq 'USMARC') {
48566282	305	print $outfh $r->as_usmarc;
456d236e JF	306	}
	307	} otherwise {
	308	my $e = shift;
e759b05b JF	309	my $errorid = chomp($id);
	310	chomp($e);
	311	warn "\nERROR ON MFHD RECORD $errorid: $e\n";
456d236e JF	312	import MARC::File::XML; # reset SAX parser so that one bad record doesn't kill the entire export
	313	};
	314	}
	315	}
	316
	317	stats() if (! ($count{bib} % 50 ));
	318	}
	319
	320	sub stats {
	321	try {
	322	no warnings;
	323
	324	$speed = $count{did} / (time - $start);
	325
	326	my $speed_now = ($count{did} - $count{did_last}) / (time - $count{time_last});
	327	my $cn_speed = $count{cn} / (time - $start);
	328	my $cp_speed = $count{cp} / (time - $start);
	329
	330	printf STDERR "\r $count{did} of $count{bib} @ \%0.4f/s ttl / \%0.4f/s rt ".
	331	"($count{cn} CNs @ \%0.4f/s :: $count{cp} CPs @ \%0.4f/s)\r",
	332	$speed,
	333	$speed_now,
	334	$cn_speed,
	335	$cp_speed;
	336	} otherwise {};
	337	$count{did_last} = $count{did};
	338	$count{time_last} = time;
	339	}
	340
	341	sub get_bib_locations {
	342	print STDERR "Retrieving Org Units ... ";
	343	my $r = $ses->request( 'open-ils.cstore.direct.actor.org_unit.search', { id => { '!=' => undef } } );
	344
	345	while (my $o = $r->recv) {
	346	die $r->failed->stringify if ($r->failed);
	347	$o = $o->content;
	348	last unless ($o);
	349	$orgs{$o->id} = $o;
	350	}
	351	$r->finish;
	352	print STDERR "OK\n";
	353
	354	print STDERR "Retrieving Copy statuses ... ";
	355	$r = $ses->request( 'open-ils.cstore.direct.config.copy_status.search', { id => { '!=' => undef } } );
	356
	357	while (my $sta = $r->recv) {
	358	die $r->failed->stringify if ($r->failed);
	359	$sta = $sta->content;
	360	last unless ($sta);
	361	$statuses{$sta->id} = $sta;
	362	}
	363	$r->finish;
	364	print STDERR "OK\n";
	365
	366	print STDERR "Retrieving OU types ... ";
	367	$r = $ses->request( 'open-ils.cstore.direct.actor.org_unit_type.search', { id => { '!=' => undef } } );
	368
	369	while (my $outy = $r->recv) {
	370	die $r->failed->stringify if ($r->failed);
	371	$outy = $outy->content;
	372	last unless ($outy);
	373	$outypes{$outy->id} = $outy;
	374	}
	375	$r->finish;
376	print STDERR "OK\n";
377
378	print STDERR "Retrieving Shelving locations ... ";
379	$r = $ses->request( 'open-ils.cstore.direct.asset.copy_location.search', { id => { '!=' => undef } } );
380
381	while (my $s = $r->recv) {
382	die $r->failed->stringify if ($r->failed);
383	$s = $s->content;
384	last unless ($s);
385	$shelves{$s->id} = $s;
386	}
387	$r->finish;
388	print STDERR "OK\n";
389
390	$flesh = { flesh => 2, flesh_fields => { bre => [ 'call_numbers' ], acn => [ 'copies' ] } };
391	}
392
393	sub add_bib_holdings {
394	my $bib = shift;
395	my $r = shift;
396
397	my $cn_list = $bib->call_numbers;
398	if ($cn_list && @$cn_list) {
399
400	$count{cn} += @$cn_list;
401
402	my $cp_list = [ map { @{ $_->copies } } @$cn_list ];
403	if ($cp_list && @$cp_list) {
404
405	my %cn_map;
406	push @{$cn_map{$_->call_number}}, $_ for (@$cp_list);
407
408	for my $cn ( @$cn_list ) {
409	my $cn_map_list = $cn_map{$cn->id};
410
411	COPYMAP: for my $cp ( @$cn_map_list ) {
412	$count{cp}++;
413
414
415	my $owninglib = $cn->owning_lib;
416	my $circlib = $cp->circ_lib;
417	my $printlib = $cp->circ_lib;
418
419	if($cfg){
420	my $thisorg = $orgs{$circlib};
421
422	if($collapse_to_depth){
423	while ( $outypes{ $thisorg->ou_type }->depth > $collapse_to_depth ){
424	my $localcfg = $cfg->param(-block=> $thisorg->shortname);
425	if( $localcfg->{'DontCollapse'} ){
426	last;
427	}
428	if($thisorg->parent_ou){
429	$thisorg = $orgs{$thisorg->parent_ou};
430	$printlib = $thisorg->id;
431	}
432	}
433	}
434
435	$thisorg = $orgs{$circlib};
436
806177d6	437
456d236e	438	while( $thisorg ){
456d236e JF	439	# load the local config from the .ini file for exclusions
456d236e JF	440	my $localcfg = $cfg->param(-block=> $thisorg->shortname);
0cd9cd7d	441	my $cfgparam;
456d236e JF	442
	443	# if we see this setting, just skip that org
	444
0cd9cd7d RJ	445	$cfgparam = 'ExcludeEntireOrg';
	446	if( $localcfg->{$cfgparam} )
	447	{ skipnote($bib->id, $cfgparam); next COPYMAP; }
456d236e JF	448
456d236e JF	449	# what follows are exclusion rules
806177d6	450
456d236e	451	# Excluded Flags
0cd9cd7d RJ	452	$cfgparam = 'Flags';
0cd9cd7d RJ	453	if($localcfg->{$cfgparam}){
456d236e	454	# this little line is just forcing scalars into an array so we can 'use strict' with Config::Simple
0cd9cd7d	455	my @flags = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}));
48566282 RJ	456	if( grep { $_ eq 'reference' } @flags && $cp->ref eq 't')
	457	{ skipnote($bib->id,"Flags: reference"); next COPYMAP; }
	458	elsif( grep { $_ eq 'unholdable' } @flags && $cp->holdable eq 'f')
	459	{ skipnote($bib->id,"Flags: unholdable"); next COPYMAP; }
	460	elsif( grep { $_ eq 'circulate' } @flags && $cp->circulate eq 'f')
	461	{ skipnote($bib->id,"Flags: circulate"); next COPYMAP; }
	462	elsif( grep { $_ eq 'hidden' } @flags && $cp->opac_visible eq 'f')
	463	{ skipnote($bib->id,"Flags: hidden"); next COPYMAP; }
456d236e	464	}
0cd9cd7d	465
456d236e	466	# Excluded Circ Modifiers
0cd9cd7d RJ	467	$cfgparam = 'CircMods';
0cd9cd7d RJ	468	if($localcfg->{$cfgparam}){
806177d6	469	my $circmod = $cp->circ_modifier \|\| "";
0cd9cd7d	470	my @circmods = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
48566282	471	if( grep { $_ eq $circmod } @circmods && @circmods)
0cd9cd7d	472	{ skipnote($bib->id,$cfgparam); next COPYMAP; }
456d236e	473	}
3add9381	474	# Inverse rule -- only include specified Circ Mods
0cd9cd7d RJ	475	$cfgparam = 'OnlyIncludeCircMods';
0cd9cd7d RJ	476	if($localcfg->{$cfgparam}){
806177d6	477	my $circmod = $cp->circ_modifier \|\| "";
0cd9cd7d RJ	478	my @circmods = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
	479	unless( grep { $_ and $_ eq $circmod } @circmods && @circmods)
	480	{ skipnote($bib->id,$cfgparam); next COPYMAP; }
3add9381	481	}
456d236e	482	# Excluded Copy Statuses
0cd9cd7d RJ	483	$cfgparam = 'Statuses';
	484	if($localcfg->{$cfgparam}){
	485	my @statuses = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
48566282	486	if( grep { $_ eq $statuses{$cp->status}->name } @statuses && @statuses)
0cd9cd7d	487	{ skipnote($bib->id,$cfgparam); next COPYMAP; }
456d236e JF	488	}
456d236e JF	489	# Excluded Locations
0cd9cd7d RJ	490	$cfgparam = 'Locations';
	491	if($localcfg->{$cfgparam}){
	492	my @locations = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
48566282	493	if( grep { $_ eq $shelves{$cp->location}->name } @locations && @locations)
0cd9cd7d	494	{ skipnote($bib->id,$cfgparam); next COPYMAP; }
456d236e JF	495	}
456d236e JF	496	# Inverse rule - Only use the specified locations
0cd9cd7d RJ	497	$cfgparam = 'OnlyIncludeLocations';
	498	if($localcfg->{$cfgparam}){
	499	my @locations = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{'Locations'}) );
48566282	500	unless( grep { $_ eq $shelves{$cp->location}->name } @locations && @locations)
0cd9cd7d	501	{ skipnote($bib->id,$cfgparam); next COPYMAP; }
456d236e JF	502	}
456d236e JF	503	# exclude based on a regex match to location names
0cd9cd7d RJ	504	$cfgparam = 'LocationRegex';
	505	if($localcfg->{$cfgparam}){
	506	my @locregex = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
	507	my $reg = $localcfg->{$cfgparam};
48566282	508	if( grep { $shelves{$cp->location}->name =~ m/($reg)/ } @locregex && @locregex)
0cd9cd7d	509	{ skipnote($bib->id,$cfgparam); next COPYMAP; }
456d236e JF	510	}
456d236e JF	511	# include based on a regex match to location names
0cd9cd7d RJ	512	$cfgparam = 'OnlyIncludeLocationRegex';
	513	if($localcfg->{$cfgparam}){
	514	my @locregex = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
	515	my $reg = $localcfg->{$cfgparam};
48566282	516	unless( grep { $shelves{$cp->location}->name =~ m/($reg)/ } @locregex && @locregex)
0cd9cd7d	517	{ skipnote($bib->id,$cfgparam); next COPYMAP; }
456d236e JF	518	}
456d236e JF	519	# Exclude based on a callno regex
0cd9cd7d RJ	520	$cfgparam = 'CallNoRegex';
	521	if($localcfg->{$cfgparam}){
	522	my @callnoregex = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
	523	my $reg = $localcfg->{$cfgparam};
48566282	524	if( grep { $cn->label =~ m/($reg)/ } @callnoregex && @callnoregex)
0cd9cd7d	525	{ skipnote($bib->id,$cfgparam); next COPYMAP; }
456d236e JF	526	}
456d236e JF	527	# Include based on a callno regex
0cd9cd7d RJ	528	$cfgparam = 'OnlyIncludeCallNoRegex';
	529	if($localcfg->{$cfgparam}){
	530	my @callnoregex = ( (ref($localcfg->{$cfgparam}) eq "ARRAY") ? @{$localcfg->{$cfgparam}} : ($localcfg->{$cfgparam}) );
	531	my $reg = $localcfg->{$cfgparam};
48566282	532	unless( grep { $cn->label =~ m/($reg)/ } @callnoregex && @callnoregex)
0cd9cd7d	533	{ skipnote($bib->id,$cfgparam); next COPYMAP; }
456d236e	534	}
806177d6	535
456d236e JF	536	# Trim call number to a float and exclude based on Dewey Range
	537	if($localcfg->{'DeweyGT'} \|\| $localcfg->{'DeweyLT'}){
	538	my $gt = $localcfg->{'DeweyGT'};
	539	my $lt = $localcfg->{'DeweyLT'};
	540
	541	# FIXME if either config has an array just ditch for now
48566282 RJ	542	if (ref($gt) eq "ARRAY" or ref($lt) eq "ARRAY")
48566282 RJ	543	{ skipnote($bib->id,""); next COPYMAP; }
456d236e JF	544	$gt =~ s/[^0-9\.]//g if $gt; #trim off anything not deweyish
	545	$lt =~ s/[^0-9\.]//g if $lt; #trim off anything not deweyish
	546
	547	my $callno = $cn->label;
	548	$callno =~ s/[^0-9\.]//g; #trim off anything not deweyish
	549	print STDERR $callno;
	550	#note that we are making big assumptions about the call numbers in the db
	551
	552	# we have a range, exclude what's inbetween
	553	if($lt && $gt){
48566282 RJ	554	if($callno > $gt and $callno < $lt)
48566282 RJ	555	{ skipnote($bib->id,"Dewey LTGT"); next COPYMAP; }
456d236e JF	556	# we only have a top threshold, exclude everything below it
456d236e JF	557	} elsif ($lt){
48566282 RJ	558	if($callno < $lt)
48566282 RJ	559	{ skipnote($bib->id,"Dewey LT"); next COPYMAP; }
456d236e JF	560	# we only have a bottom threshold, exclude everything above it
456d236e JF	561	} elsif ($gt){
48566282 RJ	562	if($callno > $gt)
48566282 RJ	563	{ skipnote($bib->id,"Dewey GT"); next COPYMAP; }
456d236e JF	564	}
	565	}
	566
456d236e JF	567	if($thisorg->parent_ou){
	568	$thisorg = $orgs{$thisorg->parent_ou}
	569	} else {
	570	$thisorg = ();
	571	}
	572
	573	}
	574	}
	575
	576	$r->append_fields(
	577	MARC::Field->new(
	578	852, '4', '',
	579	a => $location,
	580	b => $orgs{$printlib}->shortname,
	581	#b => $orgs{$owninglib}->shortname,
	582	#b => $orgs{$circlib}->shortname,
	583	c => $shelves{$cp->location}->name,
	584	j => $cn->label,
	585	($cp->circ_modifier ? ( g => $cp->circ_modifier ) : ()),
	586	p => $cp->barcode,
	587	($cp->price ? ( y => $dollarsign.$cp->price ) : ()),
	588	($cp->copy_number ? ( t => $cp->copy_number ) : ()),
	589	($cp->ref eq 't' ? ( x => 'reference' ) : ()),
	590	($cp->holdable eq 'f' ? ( x => 'unholdable' ) : ()),
	591	($cp->circulate eq 'f' ? ( x => 'noncirculating' ) : ()),
	592	($cp->opac_visible eq 'f' ? ( x => 'hidden' ) : ()),
	593	z => $statuses{$cp->status}->name,
	594	)
	595	);
	596
5eb3fcb8	597
5eb3fcb8	598
456d236e	599	stats() if (! ($count{cp} % 100 ));
0cd9cd7d RJ	600	} # COPYMAP: for my $cp ( @$cn_map_list )
	601	} # for my $cn ( @$cn_list )
	602	} # if ($cp_list && @$cp_list)
	603	} # if ($cn_list && @$cn_list)
456d236e	604	} # sub
48566282 RJ	605
48566282 RJ	606	sub skipnote {
8a28571b RJ	607	my $id = shift;
	608	my $note = shift;
	609	my $outf = *STDERR;
	610	$outf = *STDOUT if($output_file) ;
	611	printf($outf "Skipped %s due to config: %s\n",$id,$note);
48566282	612	}