1976 lines
63 KiB
Perl
1976 lines
63 KiB
Perl
package C4::ImportBatch;
|
|
|
|
# Copyright (C) 2007 LibLime, 2012 C & P Bibliography Services
|
|
#
|
|
# This file is part of Koha.
|
|
#
|
|
# Koha 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 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Koha 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 Koha; if not, see <https://www.gnu.org/licenses>.
|
|
|
|
use Modern::Perl;
|
|
use base 'Exporter';
|
|
|
|
BEGIN {
|
|
our @EXPORT_OK = qw(
|
|
GetZ3950BatchId
|
|
GetWebserviceBatchId
|
|
GetImportRecordMarc
|
|
AddImportBatch
|
|
GetImportBatch
|
|
AddAuthToBatch
|
|
AddBiblioToBatch
|
|
AddItemsToImportBiblio
|
|
ModAuthorityInBatch
|
|
|
|
BatchStageMarcRecords
|
|
BatchFindDuplicates
|
|
BatchCommitRecords
|
|
BatchRevertRecords
|
|
CleanBatch
|
|
DeleteBatch
|
|
|
|
GetAllImportBatches
|
|
GetStagedWebserviceBatches
|
|
GetImportBatchRangeDesc
|
|
GetNumberOfNonZ3950ImportBatches
|
|
GetImportBiblios
|
|
GetImportRecordsRange
|
|
GetItemNumbersFromImportBatch
|
|
|
|
GetImportBatchStatus
|
|
SetImportBatchStatus
|
|
GetImportBatchOverlayAction
|
|
SetImportBatchOverlayAction
|
|
GetImportBatchNoMatchAction
|
|
SetImportBatchNoMatchAction
|
|
GetImportBatchItemAction
|
|
SetImportBatchItemAction
|
|
GetImportBatchMatcher
|
|
SetImportBatchMatcher
|
|
GetImportRecordOverlayStatus
|
|
SetImportRecordOverlayStatus
|
|
GetImportRecordStatus
|
|
SetImportRecordStatus
|
|
SetMatchedBiblionumber
|
|
GetImportRecordMatches
|
|
SetImportRecordMatches
|
|
|
|
RecordsFromMARCXMLFile
|
|
RecordsFromISO2709File
|
|
RecordsFromMarcPlugin
|
|
);
|
|
}
|
|
|
|
use C4::Context;
|
|
use C4::Koha qw( GetNormalizedISBN );
|
|
use JSON qw( encode_json decode_json );
|
|
use C4::Biblio qw(
|
|
AddBiblio
|
|
DelBiblio
|
|
GetMarcFromKohaField
|
|
GetXmlBiblio
|
|
ModBiblio
|
|
TransformMarcToKoha
|
|
);
|
|
use C4::Items qw( AddItemFromMarc ModItemFromMarc );
|
|
use C4::Charset qw( MarcToUTF8Record SetUTF8Flag StripNonXmlChars );
|
|
use C4::AuthoritiesMarc
|
|
qw( AddAuthority GuessAuthTypeCode GetAuthorityXML ModAuthority DelAuthority GetAuthorizedHeading );
|
|
use C4::MarcModificationTemplates qw( ModifyRecordWithTemplate );
|
|
use Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue;
|
|
use Koha::Items;
|
|
use Koha::SearchEngine;
|
|
use Koha::SearchEngine::Indexer;
|
|
use Koha::Plugins::Handler;
|
|
use Koha::Logger;
|
|
|
|
=head1 NAME
|
|
|
|
C4::ImportBatch - manage batches of imported MARC records
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
use C4::ImportBatch;
|
|
|
|
=head1 FUNCTIONS
|
|
|
|
=head2 GetZ3950BatchId
|
|
|
|
my $batchid = GetZ3950BatchId($z3950server);
|
|
|
|
Retrieves the ID of the import batch for the Z39.50
|
|
reservoir for the given target. If necessary,
|
|
creates the import batch.
|
|
|
|
=cut
|
|
|
|
sub GetZ3950BatchId {
|
|
my ($z3950server) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare(
|
|
"SELECT import_batch_id FROM import_batches
|
|
WHERE batch_type = 'z3950'
|
|
AND file_name = ?"
|
|
);
|
|
$sth->execute($z3950server);
|
|
my $rowref = $sth->fetchrow_arrayref();
|
|
$sth->finish();
|
|
if ( defined $rowref ) {
|
|
return $rowref->[0];
|
|
} else {
|
|
my $batch_id = AddImportBatch(
|
|
{
|
|
overlay_action => 'create_new',
|
|
import_status => 'staged',
|
|
batch_type => 'z3950',
|
|
file_name => $z3950server,
|
|
}
|
|
);
|
|
return $batch_id;
|
|
}
|
|
|
|
}
|
|
|
|
=head2 GetWebserviceBatchId
|
|
|
|
my $batchid = GetWebserviceBatchId();
|
|
|
|
Retrieves the ID of the import batch for webservice.
|
|
If necessary, creates the import batch.
|
|
|
|
=cut
|
|
|
|
my $WEBSERVICE_BASE_QRY = <<EOQ;
|
|
SELECT import_batch_id FROM import_batches
|
|
WHERE batch_type = 'webservice'
|
|
AND import_status = 'staged'
|
|
EOQ
|
|
|
|
sub GetWebserviceBatchId {
|
|
my ($params) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sql = $WEBSERVICE_BASE_QRY;
|
|
my @args;
|
|
foreach my $field (qw(matcher_id overlay_action nomatch_action item_action)) {
|
|
if ( my $val = $params->{$field} ) {
|
|
$sql .= " AND $field = ?";
|
|
push @args, $val;
|
|
}
|
|
}
|
|
my $id = $dbh->selectrow_array( $sql, undef, @args );
|
|
return $id if $id;
|
|
|
|
$params->{batch_type} = 'webservice';
|
|
$params->{import_status} = 'staged';
|
|
return AddImportBatch($params);
|
|
}
|
|
|
|
=head2 GetImportRecordMarc
|
|
|
|
my ($marcblob, $encoding) = GetImportRecordMarc($import_record_id);
|
|
|
|
=cut
|
|
|
|
sub GetImportRecordMarc {
|
|
my ($import_record_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my ( $marc, $encoding ) = $dbh->selectrow_array(
|
|
q|
|
|
SELECT marc, encoding
|
|
FROM import_records
|
|
WHERE import_record_id = ?
|
|
|, undef, $import_record_id
|
|
);
|
|
|
|
return $marc, $encoding;
|
|
}
|
|
|
|
=head2 AddImportBatch
|
|
|
|
my $batch_id = AddImportBatch($params_hash);
|
|
|
|
=cut
|
|
|
|
sub AddImportBatch {
|
|
my ($params) = @_;
|
|
|
|
my ( @fields, @vals );
|
|
foreach (
|
|
qw( matcher_id template_id branchcode
|
|
overlay_action nomatch_action item_action
|
|
import_status batch_type file_name comments record_type )
|
|
)
|
|
{
|
|
if ( exists $params->{$_} ) {
|
|
push @fields, $_;
|
|
push @vals, $params->{$_};
|
|
}
|
|
}
|
|
my $dbh = C4::Context->dbh;
|
|
$dbh->do(
|
|
"INSERT INTO import_batches (" . join( ',', @fields ) . ")
|
|
VALUES (" . join( ',', map '?', @fields ) . ")",
|
|
undef,
|
|
@vals
|
|
);
|
|
return $dbh->{'mysql_insertid'};
|
|
}
|
|
|
|
=head2 GetImportBatch
|
|
|
|
my $row = GetImportBatch($batch_id);
|
|
|
|
Retrieve a hashref of an import_batches row.
|
|
|
|
=cut
|
|
|
|
sub GetImportBatch {
|
|
my ($batch_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare_cached(
|
|
"SELECT b.*, p.name as profile FROM import_batches b LEFT JOIN import_batch_profiles p ON p.id = b.profile_id WHERE import_batch_id = ?"
|
|
);
|
|
$sth->bind_param( 1, $batch_id );
|
|
$sth->execute();
|
|
my $result = $sth->fetchrow_hashref;
|
|
$sth->finish();
|
|
return $result;
|
|
|
|
}
|
|
|
|
=head2 AddBiblioToBatch
|
|
|
|
my $import_record_id = AddBiblioToBatch($batch_id, $record_sequence,
|
|
$marc_record, $encoding, $update_counts);
|
|
|
|
=cut
|
|
|
|
sub AddBiblioToBatch {
|
|
my $batch_id = shift;
|
|
my $record_sequence = shift;
|
|
my $marc_record = shift;
|
|
my $encoding = shift;
|
|
my $update_counts = @_ ? shift : 1;
|
|
|
|
my $import_record_id = _create_import_record(
|
|
$batch_id, $record_sequence, $marc_record, 'biblio', $encoding,
|
|
C4::Context->preference('marcflavour')
|
|
);
|
|
_add_biblio_fields( $import_record_id, $marc_record );
|
|
_update_batch_record_counts($batch_id) if $update_counts;
|
|
return $import_record_id;
|
|
}
|
|
|
|
=head2 AddAuthToBatch
|
|
|
|
my $import_record_id = AddAuthToBatch($batch_id, $record_sequence,
|
|
$marc_record, $encoding, $update_counts, [$marc_type]);
|
|
|
|
=cut
|
|
|
|
sub AddAuthToBatch {
|
|
my $batch_id = shift;
|
|
my $record_sequence = shift;
|
|
my $marc_record = shift;
|
|
my $encoding = shift;
|
|
my $update_counts = @_ ? shift : 1;
|
|
my $marc_type = shift || C4::Context->preference('marcflavour');
|
|
|
|
$marc_type = 'UNIMARCAUTH' if $marc_type eq 'UNIMARC';
|
|
|
|
my $import_record_id =
|
|
_create_import_record( $batch_id, $record_sequence, $marc_record, 'auth', $encoding, $marc_type );
|
|
_add_auth_fields( $import_record_id, $marc_record );
|
|
_update_batch_record_counts($batch_id) if $update_counts;
|
|
return $import_record_id;
|
|
}
|
|
|
|
=head2 BatchStageMarcRecords
|
|
|
|
( $batch_id, $num_records, $num_items, @invalid_records ) =
|
|
BatchStageMarcRecords(
|
|
$record_type, $encoding,
|
|
$marc_records, $file_name,
|
|
$marc_modification_template, $comments,
|
|
$branch_code, $parse_items,
|
|
$leave_as_staging, $progress_interval,
|
|
$progress_callback
|
|
);
|
|
|
|
=cut
|
|
|
|
sub BatchStageMarcRecords {
|
|
my $record_type = shift;
|
|
my $encoding = shift;
|
|
my $marc_records = shift;
|
|
my $file_name = shift;
|
|
my $marc_modification_template = shift;
|
|
my $comments = shift;
|
|
my $branch_code = shift;
|
|
my $parse_items = shift;
|
|
my $leave_as_staging = shift;
|
|
|
|
# optional callback to monitor status
|
|
# of job
|
|
my $progress_interval = 0;
|
|
my $progress_callback = undef;
|
|
if ( $#_ == 1 ) {
|
|
$progress_interval = shift;
|
|
$progress_callback = shift;
|
|
$progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
|
|
$progress_interval = 0 unless 'CODE' eq ref $progress_callback;
|
|
}
|
|
|
|
my $batch_id = AddImportBatch(
|
|
{
|
|
overlay_action => 'create_new',
|
|
import_status => 'staging',
|
|
batch_type => 'batch',
|
|
file_name => $file_name,
|
|
comments => $comments,
|
|
record_type => $record_type,
|
|
}
|
|
);
|
|
if ($parse_items) {
|
|
SetImportBatchItemAction( $batch_id, 'always_add' );
|
|
} else {
|
|
SetImportBatchItemAction( $batch_id, 'ignore' );
|
|
}
|
|
|
|
my $marc_type = C4::Context->preference('marcflavour');
|
|
$marc_type .= 'AUTH' if ( $marc_type eq 'UNIMARC' && $record_type eq 'auth' );
|
|
my @invalid_records = ();
|
|
my $num_valid = 0;
|
|
my $num_items = 0;
|
|
|
|
# FIXME - for now, we're dealing only with bibs
|
|
my $rec_num = 0;
|
|
foreach my $marc_record (@$marc_records) {
|
|
$rec_num++;
|
|
if ( $progress_interval and ( 0 == ( $rec_num % $progress_interval ) ) ) {
|
|
&$progress_callback($rec_num);
|
|
}
|
|
|
|
ModifyRecordWithTemplate( $marc_modification_template, $marc_record ) if ($marc_modification_template);
|
|
|
|
my $import_record_id;
|
|
if ( scalar( $marc_record->fields() ) == 0 ) {
|
|
push @invalid_records, $marc_record;
|
|
} else {
|
|
|
|
# Normalize the record so it doesn't have separated diacritics
|
|
SetUTF8Flag($marc_record);
|
|
|
|
$num_valid++;
|
|
if ( $record_type eq 'biblio' ) {
|
|
$import_record_id = AddBiblioToBatch( $batch_id, $rec_num, $marc_record, $encoding, 0 );
|
|
if ($parse_items) {
|
|
my @import_items_ids = AddItemsToImportBiblio( $batch_id, $import_record_id, $marc_record, 0 );
|
|
$num_items += scalar(@import_items_ids);
|
|
}
|
|
} elsif ( $record_type eq 'auth' ) {
|
|
$import_record_id = AddAuthToBatch( $batch_id, $rec_num, $marc_record, $encoding, 0, $marc_type );
|
|
}
|
|
}
|
|
}
|
|
unless ($leave_as_staging) {
|
|
SetImportBatchStatus( $batch_id, 'staged' );
|
|
}
|
|
|
|
# FIXME branch_code, number of bibs, number of items
|
|
_update_batch_record_counts($batch_id);
|
|
if ($progress_interval) {
|
|
&$progress_callback($rec_num);
|
|
}
|
|
|
|
return ( $batch_id, $num_valid, $num_items, @invalid_records );
|
|
}
|
|
|
|
=head2 AddItemsToImportBiblio
|
|
|
|
my @import_items_ids = AddItemsToImportBiblio($batch_id,
|
|
$import_record_id, $marc_record, $update_counts);
|
|
|
|
=cut
|
|
|
|
sub AddItemsToImportBiblio {
|
|
my $batch_id = shift;
|
|
my $import_record_id = shift;
|
|
my $marc_record = shift;
|
|
my $update_counts = @_ ? shift : 0;
|
|
|
|
my @import_items_ids = ();
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my ( $item_tag, $item_subfield ) = &GetMarcFromKohaField("items.itemnumber");
|
|
foreach my $item_field ( $marc_record->field($item_tag) ) {
|
|
my $item_marc = MARC::Record->new();
|
|
$item_marc->leader("00000 a "); # must set Leader/09 to 'a'
|
|
$item_marc->append_fields($item_field);
|
|
$marc_record->delete_field($item_field);
|
|
my $sth = $dbh->prepare_cached(
|
|
"INSERT INTO import_items (import_record_id, status, marcxml)
|
|
VALUES (?, ?, ?)"
|
|
);
|
|
$sth->bind_param( 1, $import_record_id );
|
|
$sth->bind_param( 2, 'staged' );
|
|
$sth->bind_param( 3, $item_marc->as_xml("USMARC") );
|
|
$sth->execute();
|
|
push @import_items_ids, $dbh->{'mysql_insertid'};
|
|
$sth->finish();
|
|
}
|
|
|
|
if ( $#import_items_ids > -1 ) {
|
|
_update_batch_record_counts($batch_id) if $update_counts;
|
|
}
|
|
return @import_items_ids;
|
|
}
|
|
|
|
=head2 BatchFindDuplicates
|
|
|
|
my $num_with_matches = BatchFindDuplicates($batch_id, $matcher,
|
|
$max_matches, $progress_interval, $progress_callback);
|
|
|
|
Goes through the records loaded in the batch and attempts to
|
|
find duplicates for each one. Sets the matching status
|
|
of each record to "no_match" or "auto_match" as appropriate.
|
|
|
|
The $max_matches parameter is optional; if it is not supplied,
|
|
it defaults to 10.
|
|
|
|
The $progress_interval and $progress_callback parameters are
|
|
optional; if both are supplied, the sub referred to by
|
|
$progress_callback will be invoked every $progress_interval
|
|
records using the number of records processed as the
|
|
singular argument.
|
|
|
|
=cut
|
|
|
|
sub BatchFindDuplicates {
|
|
my $batch_id = shift;
|
|
my $matcher = shift;
|
|
my $max_matches = @_ ? shift : 10;
|
|
|
|
# optional callback to monitor status
|
|
# of job
|
|
my $progress_interval = 0;
|
|
my $progress_callback = undef;
|
|
if ( $#_ == 1 ) {
|
|
$progress_interval = shift;
|
|
$progress_callback = shift;
|
|
$progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
|
|
$progress_interval = 0 unless 'CODE' eq ref $progress_callback;
|
|
}
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
|
|
my $sth = $dbh->prepare(
|
|
"SELECT import_record_id, record_type, marc
|
|
FROM import_records
|
|
WHERE import_batch_id = ?"
|
|
);
|
|
$sth->execute($batch_id);
|
|
my $num_with_matches = 0;
|
|
my $rec_num = 0;
|
|
while ( my $rowref = $sth->fetchrow_hashref ) {
|
|
$rec_num++;
|
|
if ( $progress_interval and ( 0 == ( $rec_num % $progress_interval ) ) ) {
|
|
&$progress_callback($rec_num);
|
|
}
|
|
my $marc_record = MARC::Record->new_from_usmarc( $rowref->{'marc'} );
|
|
my @matches = ();
|
|
if ( defined $matcher ) {
|
|
@matches = $matcher->get_matches( $marc_record, $max_matches );
|
|
}
|
|
if ( scalar(@matches) > 0 ) {
|
|
$num_with_matches++;
|
|
SetImportRecordMatches( $rowref->{'import_record_id'}, @matches );
|
|
SetImportRecordOverlayStatus( $rowref->{'import_record_id'}, 'auto_match' );
|
|
} else {
|
|
SetImportRecordMatches( $rowref->{'import_record_id'}, () );
|
|
SetImportRecordOverlayStatus( $rowref->{'import_record_id'}, 'no_match' );
|
|
}
|
|
}
|
|
|
|
if ($progress_interval) {
|
|
&$progress_callback($rec_num);
|
|
}
|
|
|
|
$sth->finish();
|
|
return $num_with_matches;
|
|
}
|
|
|
|
=head2 BatchCommitRecords
|
|
|
|
Takes a hashref containing params for committing the batch - optional parameters 'progress_interval' and
|
|
'progress_callback' will define code called every X records.
|
|
|
|
my ($num_added, $num_updated, $num_items_added, $num_items_replaced, $num_items_errored, $num_ignored) =
|
|
BatchCommitRecords({
|
|
batch_id => $batch_id,
|
|
framework => $framework,
|
|
overlay_framework => $overlay_framework,
|
|
progress_interval => $progress_interval,
|
|
progress_callback => $progress_callback,
|
|
});
|
|
=cut
|
|
|
|
sub BatchCommitRecords {
|
|
my $params = shift;
|
|
my $batch_id = $params->{batch_id};
|
|
my $framework = $params->{framework};
|
|
my $overlay_framework = $params->{overlay_framework};
|
|
my $progress_interval = $params->{progress_interval} // 0;
|
|
my $progress_callback = $params->{progress_callback};
|
|
$progress_interval = 0 unless $progress_interval && $progress_interval =~ /^\d+$/;
|
|
$progress_interval = 0 unless ref($progress_callback) eq 'CODE';
|
|
|
|
my $schema = Koha::Database->schema;
|
|
|
|
my $record_type;
|
|
my $num_added = 0;
|
|
my $num_updated = 0;
|
|
my $num_items_added = 0;
|
|
my $num_items_replaced = 0;
|
|
my $num_items_errored = 0;
|
|
my $num_ignored = 0;
|
|
|
|
# commit (i.e., save, all records in the batch)
|
|
my $overlay_action = GetImportBatchOverlayAction($batch_id);
|
|
my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
|
|
my $item_action = GetImportBatchItemAction($batch_id);
|
|
my $item_tag;
|
|
my $item_subfield;
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare(
|
|
"SELECT import_records.import_record_id, record_type, status, overlay_status, marc, encoding
|
|
FROM import_records
|
|
LEFT JOIN import_auths ON (import_records.import_record_id=import_auths.import_record_id)
|
|
LEFT JOIN import_biblios ON (import_records.import_record_id=import_biblios.import_record_id)
|
|
WHERE import_batch_id = ?"
|
|
);
|
|
$sth->execute($batch_id);
|
|
my $marcflavour = C4::Context->preference('marcflavour');
|
|
|
|
my $userenv = C4::Context->userenv;
|
|
my $logged_in_patron = Koha::Patrons->find( $userenv->{number} );
|
|
|
|
my $rec_num = 0;
|
|
my @biblio_ids;
|
|
my @updated_ids;
|
|
while ( my $rowref = $sth->fetchrow_hashref ) {
|
|
$schema->txn_begin;
|
|
$record_type = $rowref->{'record_type'};
|
|
|
|
$rec_num++;
|
|
|
|
if ( $progress_interval and ( 0 == ( $rec_num % $progress_interval ) ) ) {
|
|
|
|
# report progress
|
|
&$progress_callback($rec_num);
|
|
}
|
|
if ( $rowref->{'status'} eq 'error' or $rowref->{'status'} eq 'imported' ) {
|
|
$num_ignored++;
|
|
next;
|
|
}
|
|
|
|
my $marc_type;
|
|
if ( $marcflavour eq 'UNIMARC' && $record_type eq 'auth' ) {
|
|
$marc_type = 'UNIMARCAUTH';
|
|
} elsif ( $marcflavour eq 'UNIMARC' ) {
|
|
$marc_type = 'UNIMARC';
|
|
} else {
|
|
$marc_type = 'USMARC';
|
|
}
|
|
my $marc_record = MARC::Record->new_from_usmarc( $rowref->{'marc'} );
|
|
|
|
if ( $record_type eq 'biblio' ) {
|
|
|
|
# remove any item tags - rely on _batchCommitItems
|
|
( $item_tag, $item_subfield ) = &GetMarcFromKohaField("items.itemnumber");
|
|
foreach my $item_field ( $marc_record->field($item_tag) ) {
|
|
$marc_record->delete_field($item_field);
|
|
}
|
|
if ( C4::Context->preference('autoControlNumber') eq 'biblionumber' ) {
|
|
my @control_num = $marc_record->field('001');
|
|
$marc_record->delete_fields(@control_num);
|
|
}
|
|
}
|
|
|
|
my ( $record_result, $item_result, $record_match ) = _get_commit_action(
|
|
$overlay_action, $nomatch_action, $item_action,
|
|
$rowref->{'overlay_status'}, $rowref->{'import_record_id'}, $record_type
|
|
);
|
|
|
|
my $recordid;
|
|
my $query;
|
|
if ( $record_result eq 'create_new' ) {
|
|
$num_added++;
|
|
if ( $record_type eq 'biblio' ) {
|
|
my $biblioitemnumber;
|
|
( $recordid, $biblioitemnumber ) = AddBiblio( $marc_record, $framework, { skip_record_index => 1 } );
|
|
push @biblio_ids, $recordid if $recordid;
|
|
$query = "UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?"
|
|
; # FIXME call SetMatchedBiblionumber instead
|
|
if ( $item_result eq 'create_new' || $item_result eq 'replace' ) {
|
|
my ( $bib_items_added, $bib_items_replaced, $bib_items_errored ) =
|
|
_batchCommitItems( $rowref->{'import_record_id'}, $recordid, $item_result, $biblioitemnumber );
|
|
$num_items_added += $bib_items_added;
|
|
$num_items_replaced += $bib_items_replaced;
|
|
$num_items_errored += $bib_items_errored;
|
|
}
|
|
} else {
|
|
$recordid = AddAuthority( $marc_record, undef, GuessAuthTypeCode($marc_record) );
|
|
$query = "UPDATE import_auths SET matched_authid = ? WHERE import_record_id = ?";
|
|
}
|
|
my $sth = $dbh->prepare_cached($query);
|
|
$sth->execute( $recordid, $rowref->{'import_record_id'} );
|
|
$sth->finish();
|
|
SetImportRecordStatus( $rowref->{'import_record_id'}, 'imported' );
|
|
} elsif ( $record_result eq 'replace' ) {
|
|
$num_updated++;
|
|
$recordid = $record_match;
|
|
my $oldxml;
|
|
if ( $record_type eq 'biblio' ) {
|
|
my $oldbiblio = Koha::Biblios->find($recordid);
|
|
$oldxml = GetXmlBiblio($recordid);
|
|
|
|
# remove item fields so that they don't get
|
|
# added again if record is reverted
|
|
# FIXME: GetXmlBiblio output should not contain item info any more! So the next foreach should not be needed. Does not hurt either; may remove old 952s that should not have been there anymore.
|
|
my $old_marc =
|
|
MARC::Record->new_from_xml( StripNonXmlChars($oldxml), 'UTF-8', $rowref->{'encoding'}, $marc_type );
|
|
foreach my $item_field ( $old_marc->field($item_tag) ) {
|
|
$old_marc->delete_field($item_field);
|
|
}
|
|
$oldxml = $old_marc->as_xml($marc_type);
|
|
|
|
my $context = { source => 'batchimport' };
|
|
if ($logged_in_patron) {
|
|
$context->{categorycode} = $logged_in_patron->categorycode;
|
|
$context->{userid} = $logged_in_patron->userid;
|
|
}
|
|
|
|
ModBiblio(
|
|
$marc_record,
|
|
$recordid,
|
|
$overlay_framework // $oldbiblio->frameworkcode,
|
|
{
|
|
overlay_context => $context,
|
|
skip_record_index => 1,
|
|
skip_holds_queue => 1,
|
|
}
|
|
);
|
|
push @biblio_ids, $recordid;
|
|
push @updated_ids, $recordid;
|
|
$query = "UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?"
|
|
; # FIXME call SetMatchedBiblionumber instead
|
|
|
|
if ( $item_result eq 'create_new' || $item_result eq 'replace' ) {
|
|
my ( $bib_items_added, $bib_items_replaced, $bib_items_errored ) =
|
|
_batchCommitItems( $rowref->{'import_record_id'}, $recordid, $item_result );
|
|
$num_items_added += $bib_items_added;
|
|
$num_items_replaced += $bib_items_replaced;
|
|
$num_items_errored += $bib_items_errored;
|
|
}
|
|
} else {
|
|
$oldxml = GetAuthorityXML($recordid);
|
|
|
|
ModAuthority( $recordid, $marc_record, GuessAuthTypeCode($marc_record) );
|
|
$query = "UPDATE import_auths SET matched_authid = ? WHERE import_record_id = ?";
|
|
}
|
|
|
|
# Combine xml update, SetImportRecordOverlayStatus, and SetImportRecordStatus updates into a single update for efficiency, especially in a transaction
|
|
my $sth = $dbh->prepare_cached(
|
|
"UPDATE import_records SET marcxml_old = ?, status = ?, overlay_status = ? WHERE import_record_id = ?");
|
|
$sth->execute( $oldxml, 'imported', 'match_applied', $rowref->{'import_record_id'} );
|
|
$sth->finish();
|
|
my $sth2 = $dbh->prepare_cached($query);
|
|
$sth2->execute( $recordid, $rowref->{'import_record_id'} );
|
|
$sth2->finish();
|
|
} elsif ( $record_result eq 'ignore' ) {
|
|
$recordid = $record_match;
|
|
$num_ignored++;
|
|
if ( $record_type eq 'biblio'
|
|
and defined $recordid
|
|
and ( $item_result eq 'create_new' || $item_result eq 'replace' ) )
|
|
{
|
|
my ( $bib_items_added, $bib_items_replaced, $bib_items_errored ) =
|
|
_batchCommitItems( $rowref->{'import_record_id'}, $recordid, $item_result );
|
|
push @biblio_ids, $recordid if $bib_items_added || $bib_items_replaced;
|
|
$num_items_added += $bib_items_added;
|
|
$num_items_replaced += $bib_items_replaced;
|
|
$num_items_errored += $bib_items_errored;
|
|
|
|
# still need to record the matched biblionumber so that the
|
|
# items can be reverted
|
|
my $sth2 = $dbh->prepare_cached(
|
|
"UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?")
|
|
; # FIXME call SetMatchedBiblionumber instead
|
|
$sth2->execute( $recordid, $rowref->{'import_record_id'} );
|
|
SetImportRecordOverlayStatus( $rowref->{'import_record_id'}, 'match_applied' );
|
|
}
|
|
SetImportRecordStatus( $rowref->{'import_record_id'}, 'ignored' );
|
|
}
|
|
$schema->txn_commit;
|
|
}
|
|
|
|
if ($progress_interval) {
|
|
&$progress_callback($rec_num);
|
|
}
|
|
|
|
$sth->finish();
|
|
|
|
SetImportBatchStatus( $batch_id, 'imported' );
|
|
|
|
if (@biblio_ids) {
|
|
my $indexer = Koha::SearchEngine::Indexer->new( { index => $Koha::SearchEngine::BIBLIOS_INDEX } );
|
|
$indexer->index_records( \@biblio_ids, "specialUpdate", "biblioserver" );
|
|
}
|
|
Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue->new->enqueue( { biblio_ids => \@updated_ids } )
|
|
if ( @updated_ids && C4::Context->preference('RealTimeHoldsQueue') );
|
|
|
|
return ( $num_added, $num_updated, $num_items_added, $num_items_replaced, $num_items_errored, $num_ignored );
|
|
}
|
|
|
|
=head2 _batchCommitItems
|
|
|
|
($num_items_added, $num_items_errored) =
|
|
_batchCommitItems($import_record_id, $biblionumber, [$action, $biblioitemnumber]);
|
|
|
|
Private function for batch committing item changes. We do not trigger a re-index here, that is left to the caller.
|
|
|
|
=cut
|
|
|
|
sub _batchCommitItems {
|
|
my ( $import_record_id, $biblionumber, $action, $biblioitemnumber ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
|
|
my $num_items_added = 0;
|
|
my $num_items_errored = 0;
|
|
my $num_items_replaced = 0;
|
|
|
|
my $sth = $dbh->prepare( "
|
|
SELECT import_items_id, import_items.marcxml, encoding
|
|
FROM import_items
|
|
JOIN import_records USING (import_record_id)
|
|
WHERE import_record_id = ?
|
|
ORDER BY import_items_id
|
|
" );
|
|
$sth->bind_param( 1, $import_record_id );
|
|
$sth->execute();
|
|
|
|
while ( my $row = $sth->fetchrow_hashref() ) {
|
|
my $item_marc =
|
|
MARC::Record->new_from_xml( StripNonXmlChars( $row->{'marcxml'} ), 'UTF-8', $row->{'encoding'} );
|
|
|
|
# Delete date_due subfield as to not accidentally delete item checkout due dates
|
|
my ( $MARCfield, $MARCsubfield ) = GetMarcFromKohaField('items.onloan');
|
|
$item_marc->field($MARCfield)->delete_subfield( code => $MARCsubfield );
|
|
|
|
my $item =
|
|
TransformMarcToKoha( { record => $item_marc, kohafields => [ 'items.barcode', 'items.itemnumber' ] } );
|
|
|
|
my $item_match;
|
|
my $duplicate_barcode = exists( $item->{'barcode'} );
|
|
my $duplicate_itemnumber = exists( $item->{'itemnumber'} );
|
|
|
|
# We assume that when replacing items we do not want to move them - the onus is on the importer to
|
|
# ensure the correct items/records are being updated
|
|
my $updsth = $dbh->prepare(
|
|
"UPDATE import_items SET status = ?, itemnumber = ?, import_error = ? WHERE import_items_id = ?");
|
|
if ( $action eq "replace"
|
|
&& $duplicate_itemnumber
|
|
&& ( $item_match = Koha::Items->find( $item->{itemnumber} ) ) )
|
|
{
|
|
# Duplicate itemnumbers have precedence, that way we can update barcodes by overlaying
|
|
ModItemFromMarc( $item_marc, $item_match->biblionumber, $item->{itemnumber}, { skip_record_index => 1 } );
|
|
$updsth->bind_param( 1, 'imported' );
|
|
$updsth->bind_param( 2, $item->{itemnumber} );
|
|
$updsth->bind_param( 3, undef );
|
|
$updsth->bind_param( 4, $row->{'import_items_id'} );
|
|
$updsth->execute();
|
|
$updsth->finish();
|
|
$num_items_replaced++;
|
|
} elsif ( $action eq "replace"
|
|
&& $duplicate_barcode
|
|
&& ( $item_match = Koha::Items->find( { barcode => $item->{'barcode'} } ) ) )
|
|
{
|
|
ModItemFromMarc(
|
|
$item_marc, $item_match->biblionumber, $item_match->itemnumber,
|
|
{ skip_record_index => 1 }
|
|
);
|
|
$updsth->bind_param( 1, 'imported' );
|
|
$updsth->bind_param( 2, $item->{itemnumber} );
|
|
$updsth->bind_param( 3, undef );
|
|
$updsth->bind_param( 4, $row->{'import_items_id'} );
|
|
$updsth->execute();
|
|
$updsth->finish();
|
|
$num_items_replaced++;
|
|
} elsif (
|
|
|
|
# We aren't replacing, but the incoming file has a barcode, we need to check if it exists
|
|
$duplicate_barcode && ( $item_match = Koha::Items->find( { barcode => $item->{'barcode'} } ) )
|
|
)
|
|
{
|
|
$updsth->bind_param( 1, 'error' );
|
|
$updsth->bind_param( 2, undef );
|
|
$updsth->bind_param( 3, 'duplicate item barcode' );
|
|
$updsth->bind_param( 4, $row->{'import_items_id'} );
|
|
$updsth->execute();
|
|
$num_items_errored++;
|
|
} else {
|
|
|
|
# Remove the itemnumber if it exists, we want to create a new item
|
|
my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField("items.itemnumber");
|
|
$item_marc->field($itemtag)->delete_subfield( code => $itemsubfield );
|
|
|
|
my ( $item_biblionumber, $biblioitemnumber, $itemnumber ) = AddItemFromMarc(
|
|
$item_marc, $biblionumber,
|
|
{ biblioitemnumber => $biblioitemnumber, skip_record_index => 1 }
|
|
);
|
|
if ($itemnumber) {
|
|
$updsth->bind_param( 1, 'imported' );
|
|
$updsth->bind_param( 2, $itemnumber );
|
|
$updsth->bind_param( 3, undef );
|
|
$updsth->bind_param( 4, $row->{'import_items_id'} );
|
|
$updsth->execute();
|
|
$updsth->finish();
|
|
$num_items_added++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ( $num_items_added, $num_items_replaced, $num_items_errored );
|
|
}
|
|
|
|
=head2 BatchRevertRecords
|
|
|
|
my ($num_deleted, $num_errors, $num_reverted, $num_items_deleted,
|
|
$num_ignored) = BatchRevertRecords($batch_id);
|
|
|
|
=cut
|
|
|
|
sub BatchRevertRecords {
|
|
my $batch_id = shift;
|
|
|
|
my $logger = Koha::Logger->get( { category => 'C4.ImportBatch' } );
|
|
|
|
$logger->trace("C4::ImportBatch::BatchRevertRecords( $batch_id )");
|
|
|
|
my $record_type;
|
|
my $num_deleted = 0;
|
|
my $num_errors = 0;
|
|
my $num_reverted = 0;
|
|
my $num_ignored = 0;
|
|
my $num_items_deleted = 0;
|
|
|
|
# commit (i.e., save, all records in the batch)
|
|
SetImportBatchStatus( $batch_id, 'reverting' );
|
|
my $overlay_action = GetImportBatchOverlayAction($batch_id);
|
|
my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare(
|
|
"SELECT import_records.import_record_id, record_type, status, overlay_status, marcxml_old, encoding, matched_biblionumber, matched_authid
|
|
FROM import_records
|
|
LEFT JOIN import_auths ON (import_records.import_record_id=import_auths.import_record_id)
|
|
LEFT JOIN import_biblios ON (import_records.import_record_id=import_biblios.import_record_id)
|
|
WHERE import_batch_id = ?"
|
|
);
|
|
$sth->execute($batch_id);
|
|
my $marc_type;
|
|
my $marcflavour = C4::Context->preference('marcflavour');
|
|
|
|
while ( my $rowref = $sth->fetchrow_hashref ) {
|
|
$record_type = $rowref->{'record_type'};
|
|
if ( $rowref->{'status'} eq 'error' or $rowref->{'status'} eq 'reverted' ) {
|
|
$num_ignored++;
|
|
next;
|
|
}
|
|
if ( $marcflavour eq 'UNIMARC' && $record_type eq 'auth' ) {
|
|
$marc_type = 'UNIMARCAUTH';
|
|
} elsif ( $marcflavour eq 'UNIMARC' ) {
|
|
$marc_type = 'UNIMARC';
|
|
} else {
|
|
$marc_type = 'USMARC';
|
|
}
|
|
|
|
my $record_result = _get_revert_action( $overlay_action, $rowref->{'overlay_status'}, $rowref->{'status'} );
|
|
|
|
if ( $record_result eq 'delete' ) {
|
|
my $error = undef;
|
|
if ( $record_type eq 'biblio' ) {
|
|
$num_items_deleted +=
|
|
BatchRevertItems( $rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'} );
|
|
$error = DelBiblio( $rowref->{'matched_biblionumber'} );
|
|
} else {
|
|
DelAuthority( { authid => $rowref->{'matched_authid'} } );
|
|
}
|
|
if ( defined $error ) {
|
|
$num_errors++;
|
|
} else {
|
|
$num_deleted++;
|
|
SetImportRecordStatus( $rowref->{'import_record_id'}, 'reverted' );
|
|
}
|
|
} elsif ( $record_result eq 'restore' ) {
|
|
$num_reverted++;
|
|
my $old_record = MARC::Record->new_from_xml(
|
|
StripNonXmlChars( $rowref->{'marcxml_old'} ), 'UTF-8',
|
|
$rowref->{'encoding'}, $marc_type
|
|
);
|
|
if ( $record_type eq 'biblio' ) {
|
|
my $biblionumber = $rowref->{'matched_biblionumber'};
|
|
my $oldbiblio = Koha::Biblios->find($biblionumber);
|
|
|
|
$logger->info(
|
|
"C4::ImportBatch::BatchRevertRecords: Biblio record $biblionumber does not exist, restoration of this record was skipped"
|
|
) unless $oldbiblio;
|
|
next unless $oldbiblio; # Record has since been deleted. Deleted records should stay deleted.
|
|
|
|
$num_items_deleted +=
|
|
BatchRevertItems( $rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'} );
|
|
ModBiblio( $old_record, $biblionumber, $oldbiblio->frameworkcode );
|
|
} else {
|
|
my $authid = $rowref->{'matched_authid'};
|
|
ModAuthority( $authid, $old_record, GuessAuthTypeCode($old_record) );
|
|
}
|
|
SetImportRecordStatus( $rowref->{'import_record_id'}, 'reverted' );
|
|
} elsif ( $record_result eq 'ignore' ) {
|
|
if ( $record_type eq 'biblio' ) {
|
|
$num_items_deleted +=
|
|
BatchRevertItems( $rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'} );
|
|
}
|
|
SetImportRecordStatus( $rowref->{'import_record_id'}, 'reverted' );
|
|
}
|
|
my $query;
|
|
if ( $record_type eq 'biblio' ) {
|
|
|
|
# remove matched_biblionumber only if there is no 'imported' item left
|
|
$query =
|
|
"UPDATE import_biblios SET matched_biblionumber = NULL WHERE import_record_id = ?"; # FIXME Remove me
|
|
$query =
|
|
"UPDATE import_biblios SET matched_biblionumber = NULL WHERE import_record_id = ? AND NOT EXISTS (SELECT * FROM import_items WHERE import_items.import_record_id=import_biblios.import_record_id and status='imported')";
|
|
} else {
|
|
$query = "UPDATE import_auths SET matched_authid = NULL WHERE import_record_id = ?";
|
|
}
|
|
my $sth2 = $dbh->prepare_cached($query);
|
|
$sth2->execute( $rowref->{'import_record_id'} );
|
|
}
|
|
|
|
$sth->finish();
|
|
SetImportBatchStatus( $batch_id, 'reverted' );
|
|
return ( $num_deleted, $num_errors, $num_reverted, $num_items_deleted, $num_ignored );
|
|
}
|
|
|
|
=head2 BatchRevertItems
|
|
|
|
my $num_items_deleted = BatchRevertItems($import_record_id, $biblionumber);
|
|
|
|
=cut
|
|
|
|
sub BatchRevertItems {
|
|
my ( $import_record_id, $biblionumber ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $num_items_deleted = 0;
|
|
|
|
my $sth = $dbh->prepare_cached(
|
|
"SELECT import_items_id, itemnumber
|
|
FROM import_items
|
|
JOIN items USING (itemnumber)
|
|
WHERE import_record_id = ?"
|
|
);
|
|
$sth->bind_param( 1, $import_record_id );
|
|
$sth->execute();
|
|
while ( my $row = $sth->fetchrow_hashref() ) {
|
|
my $item = Koha::Items->find( $row->{itemnumber} );
|
|
if ( $item->safe_delete ) {
|
|
my $updsth = $dbh->prepare("UPDATE import_items SET status = ? WHERE import_items_id = ?");
|
|
$updsth->bind_param( 1, 'reverted' );
|
|
$updsth->bind_param( 2, $row->{'import_items_id'} );
|
|
$updsth->execute();
|
|
$updsth->finish();
|
|
$num_items_deleted++;
|
|
} else {
|
|
next;
|
|
}
|
|
}
|
|
$sth->finish();
|
|
return $num_items_deleted;
|
|
}
|
|
|
|
=head2 CleanBatch
|
|
|
|
CleanBatch($batch_id)
|
|
|
|
Deletes all staged records from the import batch
|
|
and sets the status of the batch to 'cleaned'. Note
|
|
that deleting a stage record does *not* affect
|
|
any record that has been committed to the database.
|
|
|
|
=cut
|
|
|
|
sub CleanBatch {
|
|
my $batch_id = shift;
|
|
return unless defined $batch_id;
|
|
|
|
C4::Context->dbh->do( 'DELETE FROM import_records WHERE import_batch_id = ?', {}, $batch_id );
|
|
SetImportBatchStatus( $batch_id, 'cleaned' );
|
|
}
|
|
|
|
=head2 DeleteBatch
|
|
|
|
DeleteBatch($batch_id)
|
|
|
|
Deletes the record from the database. This can only be done
|
|
once the batch has been cleaned.
|
|
|
|
=cut
|
|
|
|
sub DeleteBatch {
|
|
my $batch_id = shift;
|
|
return unless defined $batch_id;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare('DELETE FROM import_batches WHERE import_batch_id = ?');
|
|
$sth->execute($batch_id);
|
|
}
|
|
|
|
=head2 GetAllImportBatches
|
|
|
|
my $results = GetAllImportBatches();
|
|
|
|
Returns a references to an array of hash references corresponding
|
|
to all import_batches rows (of batch_type 'batch'), sorted in
|
|
ascending order by import_batch_id.
|
|
|
|
=cut
|
|
|
|
sub GetAllImportBatches {
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare_cached(
|
|
"SELECT * FROM import_batches
|
|
WHERE batch_type IN ('batch', 'webservice')
|
|
ORDER BY import_batch_id ASC"
|
|
);
|
|
|
|
my $results = [];
|
|
$sth->execute();
|
|
while ( my $row = $sth->fetchrow_hashref ) {
|
|
push @$results, $row;
|
|
}
|
|
$sth->finish();
|
|
return $results;
|
|
}
|
|
|
|
=head2 GetStagedWebserviceBatches
|
|
|
|
my $batch_ids = GetStagedWebserviceBatches();
|
|
|
|
Returns a references to an array of batch id's
|
|
of batch_type 'webservice' that are not imported
|
|
|
|
=cut
|
|
|
|
my $PENDING_WEBSERVICE_BATCHES_QRY = <<EOQ;
|
|
SELECT import_batch_id FROM import_batches
|
|
WHERE batch_type = 'webservice'
|
|
AND import_status = 'staged'
|
|
EOQ
|
|
|
|
sub GetStagedWebserviceBatches {
|
|
my $dbh = C4::Context->dbh;
|
|
return $dbh->selectcol_arrayref($PENDING_WEBSERVICE_BATCHES_QRY);
|
|
}
|
|
|
|
=head2 GetImportBatchRangeDesc
|
|
|
|
my $results = GetImportBatchRangeDesc($offset, $results_per_group);
|
|
|
|
Returns a reference to an array of hash references corresponding to
|
|
import_batches rows (sorted in descending order by import_batch_id)
|
|
start at the given offset.
|
|
|
|
=cut
|
|
|
|
sub GetImportBatchRangeDesc {
|
|
my ( $offset, $results_per_group ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $query = "SELECT b.*, p.name as profile FROM import_batches b
|
|
LEFT JOIN import_batch_profiles p
|
|
ON b.profile_id = p.id
|
|
WHERE b.batch_type IN ('batch', 'webservice')
|
|
ORDER BY b.import_batch_id DESC";
|
|
my @params;
|
|
if ($results_per_group) {
|
|
$query .= " LIMIT ?";
|
|
push( @params, $results_per_group );
|
|
}
|
|
if ($offset) {
|
|
$query .= " OFFSET ?";
|
|
push( @params, $offset );
|
|
}
|
|
my $sth = $dbh->prepare_cached($query);
|
|
$sth->execute(@params);
|
|
my $results = $sth->fetchall_arrayref( {} );
|
|
$sth->finish();
|
|
return $results;
|
|
}
|
|
|
|
=head2 GetItemNumbersFromImportBatch
|
|
|
|
my @itemsnos = GetItemNumbersFromImportBatch($batch_id);
|
|
|
|
=cut
|
|
|
|
sub GetItemNumbersFromImportBatch {
|
|
my ($batch_id) = @_;
|
|
my $dbh = C4::Context->dbh;
|
|
my $sql = q|
|
|
SELECT itemnumber FROM import_items
|
|
INNER JOIN items USING (itemnumber)
|
|
INNER JOIN import_records USING (import_record_id)
|
|
WHERE import_batch_id = ?|;
|
|
my $sth = $dbh->prepare($sql);
|
|
$sth->execute($batch_id);
|
|
my @items;
|
|
while ( my ($itm) = $sth->fetchrow_array ) {
|
|
push @items, $itm;
|
|
}
|
|
return @items;
|
|
}
|
|
|
|
=head2 GetNumberOfImportBatches
|
|
|
|
my $count = GetNumberOfImportBatches();
|
|
|
|
=cut
|
|
|
|
=head2 GetNumberOfNonZ3950ImportBatches
|
|
|
|
Missing POD for GetNumberOfNonZ3950ImportBatches.
|
|
|
|
=cut
|
|
|
|
sub GetNumberOfNonZ3950ImportBatches {
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("SELECT COUNT(*) FROM import_batches WHERE batch_type != 'z3950'");
|
|
$sth->execute();
|
|
my ($count) = $sth->fetchrow_array();
|
|
$sth->finish();
|
|
return $count;
|
|
}
|
|
|
|
=head2 GetImportBiblios
|
|
|
|
my $results = GetImportBiblios($importid);
|
|
|
|
=cut
|
|
|
|
sub GetImportBiblios {
|
|
my ($import_record_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $query = "SELECT * FROM import_biblios WHERE import_record_id = ?";
|
|
return $dbh->selectall_arrayref(
|
|
$query,
|
|
{ Slice => {} },
|
|
$import_record_id
|
|
);
|
|
|
|
}
|
|
|
|
=head2 GetImportRecordsRange
|
|
|
|
my $results = GetImportRecordsRange($batch_id, $offset, $results_per_group);
|
|
|
|
Returns a reference to an array of hash references corresponding to
|
|
import_biblios/import_auths/import_records rows for a given batch
|
|
starting at the given offset.
|
|
|
|
=cut
|
|
|
|
sub GetImportRecordsRange {
|
|
my ( $batch_id, $offset, $results_per_group, $status, $parameters ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
|
|
my $order_by = $parameters->{order_by} || 'import_record_id';
|
|
($order_by) =
|
|
grep( { $_ eq $order_by } qw( import_record_id title status overlay_status ) ) ? $order_by : 'import_record_id';
|
|
|
|
my $order_by_direction = uc( $parameters->{order_by_direction} // 'ASC' ) eq 'DESC' ? 'DESC' : 'ASC';
|
|
|
|
$order_by .= " $order_by_direction, authorized_heading" if $order_by eq 'title';
|
|
|
|
my $query = "SELECT title, author, isbn, issn, authorized_heading, import_records.import_record_id,
|
|
record_sequence, status, overlay_status,
|
|
matched_biblionumber, matched_authid, record_type
|
|
FROM import_records
|
|
LEFT JOIN import_auths ON (import_records.import_record_id=import_auths.import_record_id)
|
|
LEFT JOIN import_biblios ON (import_records.import_record_id=import_biblios.import_record_id)
|
|
WHERE import_batch_id = ?";
|
|
my @params;
|
|
push( @params, $batch_id );
|
|
if ($status) {
|
|
$query .= " AND status=?";
|
|
push( @params, $status );
|
|
}
|
|
|
|
$query .= " ORDER BY $order_by $order_by_direction";
|
|
|
|
if ($results_per_group) {
|
|
$query .= " LIMIT ?";
|
|
push( @params, $results_per_group );
|
|
}
|
|
if ($offset) {
|
|
$query .= " OFFSET ?";
|
|
push( @params, $offset );
|
|
}
|
|
my $sth = $dbh->prepare_cached($query);
|
|
$sth->execute(@params);
|
|
my $results = $sth->fetchall_arrayref( {} );
|
|
$sth->finish();
|
|
return $results;
|
|
|
|
}
|
|
|
|
=head2 GetBestRecordMatch
|
|
|
|
my $record_id = GetBestRecordMatch($import_record_id);
|
|
|
|
=cut
|
|
|
|
sub GetBestRecordMatch {
|
|
my ($import_record_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare(
|
|
"SELECT candidate_match_id
|
|
FROM import_record_matches
|
|
JOIN import_records ON ( import_record_matches.import_record_id = import_records.import_record_id )
|
|
LEFT JOIN biblio ON ( candidate_match_id = biblio.biblionumber )
|
|
LEFT JOIN auth_header ON ( candidate_match_id = auth_header.authid )
|
|
WHERE import_record_matches.import_record_id = ? AND
|
|
( (import_records.record_type = 'biblio' AND biblio.biblionumber IS NOT NULL) OR
|
|
(import_records.record_type = 'auth' AND auth_header.authid IS NOT NULL) )
|
|
AND chosen = 1
|
|
ORDER BY score DESC, candidate_match_id DESC"
|
|
);
|
|
$sth->execute($import_record_id);
|
|
my ($record_id) = $sth->fetchrow_array();
|
|
$sth->finish();
|
|
return $record_id;
|
|
}
|
|
|
|
=head2 GetImportBatchStatus
|
|
|
|
my $status = GetImportBatchStatus($batch_id);
|
|
|
|
=cut
|
|
|
|
sub GetImportBatchStatus {
|
|
my ($batch_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("SELECT import_status FROM import_batches WHERE import_batch_id = ?");
|
|
$sth->execute($batch_id);
|
|
my ($status) = $sth->fetchrow_array();
|
|
$sth->finish();
|
|
return $status;
|
|
|
|
}
|
|
|
|
=head2 SetImportBatchStatus
|
|
|
|
SetImportBatchStatus($batch_id, $new_status);
|
|
|
|
=cut
|
|
|
|
sub SetImportBatchStatus {
|
|
my ( $batch_id, $new_status ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("UPDATE import_batches SET import_status = ? WHERE import_batch_id = ?");
|
|
$sth->execute( $new_status, $batch_id );
|
|
$sth->finish();
|
|
|
|
}
|
|
|
|
=head2 SetMatchedBiblionumber
|
|
|
|
SetMatchedBiblionumber($import_record_id, $biblionumber);
|
|
|
|
=cut
|
|
|
|
sub SetMatchedBiblionumber {
|
|
my ( $import_record_id, $biblionumber ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
$dbh->do(
|
|
q|UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?|,
|
|
undef, $biblionumber, $import_record_id
|
|
);
|
|
}
|
|
|
|
=head2 GetImportBatchOverlayAction
|
|
|
|
my $overlay_action = GetImportBatchOverlayAction($batch_id);
|
|
|
|
=cut
|
|
|
|
sub GetImportBatchOverlayAction {
|
|
my ($batch_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("SELECT overlay_action FROM import_batches WHERE import_batch_id = ?");
|
|
$sth->execute($batch_id);
|
|
my ($overlay_action) = $sth->fetchrow_array();
|
|
$sth->finish();
|
|
return $overlay_action;
|
|
|
|
}
|
|
|
|
=head2 SetImportBatchOverlayAction
|
|
|
|
SetImportBatchOverlayAction($batch_id, $new_overlay_action);
|
|
|
|
=cut
|
|
|
|
sub SetImportBatchOverlayAction {
|
|
my ( $batch_id, $new_overlay_action ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("UPDATE import_batches SET overlay_action = ? WHERE import_batch_id = ?");
|
|
$sth->execute( $new_overlay_action, $batch_id );
|
|
$sth->finish();
|
|
|
|
}
|
|
|
|
=head2 GetImportBatchNoMatchAction
|
|
|
|
my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
|
|
|
|
=cut
|
|
|
|
sub GetImportBatchNoMatchAction {
|
|
my ($batch_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("SELECT nomatch_action FROM import_batches WHERE import_batch_id = ?");
|
|
$sth->execute($batch_id);
|
|
my ($nomatch_action) = $sth->fetchrow_array();
|
|
$sth->finish();
|
|
return $nomatch_action;
|
|
|
|
}
|
|
|
|
=head2 SetImportBatchNoMatchAction
|
|
|
|
SetImportBatchNoMatchAction($batch_id, $new_nomatch_action);
|
|
|
|
=cut
|
|
|
|
sub SetImportBatchNoMatchAction {
|
|
my ( $batch_id, $new_nomatch_action ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("UPDATE import_batches SET nomatch_action = ? WHERE import_batch_id = ?");
|
|
$sth->execute( $new_nomatch_action, $batch_id );
|
|
$sth->finish();
|
|
|
|
}
|
|
|
|
=head2 GetImportBatchItemAction
|
|
|
|
my $item_action = GetImportBatchItemAction($batch_id);
|
|
|
|
=cut
|
|
|
|
sub GetImportBatchItemAction {
|
|
my ($batch_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("SELECT item_action FROM import_batches WHERE import_batch_id = ?");
|
|
$sth->execute($batch_id);
|
|
my ($item_action) = $sth->fetchrow_array();
|
|
$sth->finish();
|
|
return $item_action;
|
|
|
|
}
|
|
|
|
=head2 SetImportBatchItemAction
|
|
|
|
SetImportBatchItemAction($batch_id, $new_item_action);
|
|
|
|
=cut
|
|
|
|
sub SetImportBatchItemAction {
|
|
my ( $batch_id, $new_item_action ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("UPDATE import_batches SET item_action = ? WHERE import_batch_id = ?");
|
|
$sth->execute( $new_item_action, $batch_id );
|
|
$sth->finish();
|
|
|
|
}
|
|
|
|
=head2 GetImportBatchMatcher
|
|
|
|
my $matcher_id = GetImportBatchMatcher($batch_id);
|
|
|
|
=cut
|
|
|
|
sub GetImportBatchMatcher {
|
|
my ($batch_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("SELECT matcher_id FROM import_batches WHERE import_batch_id = ?");
|
|
$sth->execute($batch_id);
|
|
my ($matcher_id) = $sth->fetchrow_array();
|
|
$sth->finish();
|
|
return $matcher_id;
|
|
|
|
}
|
|
|
|
=head2 SetImportBatchMatcher
|
|
|
|
SetImportBatchMatcher($batch_id, $new_matcher_id);
|
|
|
|
=cut
|
|
|
|
sub SetImportBatchMatcher {
|
|
my ( $batch_id, $new_matcher_id ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("UPDATE import_batches SET matcher_id = ? WHERE import_batch_id = ?");
|
|
$sth->execute( $new_matcher_id, $batch_id );
|
|
$sth->finish();
|
|
|
|
}
|
|
|
|
=head2 GetImportRecordOverlayStatus
|
|
|
|
my $overlay_status = GetImportRecordOverlayStatus($import_record_id);
|
|
|
|
=cut
|
|
|
|
sub GetImportRecordOverlayStatus {
|
|
my ($import_record_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("SELECT overlay_status FROM import_records WHERE import_record_id = ?");
|
|
$sth->execute($import_record_id);
|
|
my ($overlay_status) = $sth->fetchrow_array();
|
|
$sth->finish();
|
|
return $overlay_status;
|
|
|
|
}
|
|
|
|
=head2 SetImportRecordOverlayStatus
|
|
|
|
SetImportRecordOverlayStatus($import_record_id, $new_overlay_status);
|
|
|
|
=cut
|
|
|
|
sub SetImportRecordOverlayStatus {
|
|
my ( $import_record_id, $new_overlay_status ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("UPDATE import_records SET overlay_status = ? WHERE import_record_id = ?");
|
|
$sth->execute( $new_overlay_status, $import_record_id );
|
|
$sth->finish();
|
|
|
|
}
|
|
|
|
=head2 GetImportRecordStatus
|
|
|
|
my $status = GetImportRecordStatus($import_record_id);
|
|
|
|
=cut
|
|
|
|
sub GetImportRecordStatus {
|
|
my ($import_record_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("SELECT status FROM import_records WHERE import_record_id = ?");
|
|
$sth->execute($import_record_id);
|
|
my ($status) = $sth->fetchrow_array();
|
|
$sth->finish();
|
|
return $status;
|
|
|
|
}
|
|
|
|
=head2 SetImportRecordStatus
|
|
|
|
SetImportRecordStatus($import_record_id, $new_status);
|
|
|
|
=cut
|
|
|
|
sub SetImportRecordStatus {
|
|
my ( $import_record_id, $new_status ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare("UPDATE import_records SET status = ? WHERE import_record_id = ?");
|
|
$sth->execute( $new_status, $import_record_id );
|
|
$sth->finish();
|
|
|
|
}
|
|
|
|
=head2 GetImportRecordMatches
|
|
|
|
my $results = GetImportRecordMatches($import_record_id, $best_only);
|
|
|
|
=cut
|
|
|
|
sub GetImportRecordMatches {
|
|
my $import_record_id = shift;
|
|
my $best_only = @_ ? shift : 0;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
|
|
# FIXME currently biblio only
|
|
my $sth = $dbh->prepare_cached(
|
|
"SELECT title, author, biblionumber,
|
|
candidate_match_id, score, composite_scores, record_type,
|
|
chosen
|
|
FROM import_records
|
|
JOIN import_record_matches USING (import_record_id)
|
|
LEFT JOIN biblio ON (biblionumber = candidate_match_id)
|
|
WHERE import_record_id = ?
|
|
ORDER BY score DESC, biblionumber DESC"
|
|
);
|
|
$sth->bind_param( 1, $import_record_id );
|
|
my $results = [];
|
|
$sth->execute();
|
|
while ( my $row = $sth->fetchrow_hashref ) {
|
|
if ( $row->{'record_type'} eq 'auth' ) {
|
|
$row->{'authorized_heading'} = GetAuthorizedHeading( { authid => $row->{'candidate_match_id'} } );
|
|
}
|
|
next if ( $row->{'record_type'} eq 'biblio' && not $row->{'biblionumber'} );
|
|
$row->{'composite_scores'} =
|
|
$row->{'composite_scores'}
|
|
? decode_json( $row->{'composite_scores'} )
|
|
: {};
|
|
push @$results, $row;
|
|
last if $best_only;
|
|
}
|
|
$sth->finish();
|
|
|
|
return $results;
|
|
|
|
}
|
|
|
|
=head2 SetImportRecordMatches
|
|
|
|
SetImportRecordMatches($import_record_id, @matches);
|
|
|
|
=cut
|
|
|
|
sub SetImportRecordMatches {
|
|
my $import_record_id = shift;
|
|
my @matches = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $delsth = $dbh->prepare("DELETE FROM import_record_matches WHERE import_record_id = ?");
|
|
$delsth->execute($import_record_id);
|
|
$delsth->finish();
|
|
|
|
my $sth = $dbh->prepare(
|
|
"INSERT INTO import_record_matches (import_record_id, candidate_match_id, score, composite_scores, chosen)
|
|
VALUES (?, ?, ?, ?, ?)"
|
|
);
|
|
my $chosen = 1; #The first match is defaulted to be chosen
|
|
foreach my $match (@matches) {
|
|
my $composite_json =
|
|
$match->{'composite_scores'}
|
|
? encode_json( $match->{'composite_scores'} )
|
|
: undef;
|
|
$sth->execute( $import_record_id, $match->{'record_id'}, $match->{'score'}, $composite_json, $chosen );
|
|
$chosen = 0; #After the first we do not default to other matches
|
|
}
|
|
}
|
|
|
|
=head2 RecordsFromISO2709File
|
|
|
|
my ($errors, $records) = C4::ImportBatch::RecordsFromISO2709File($input_file, $record_type, $encoding);
|
|
|
|
Reads ISO2709 binary porridge from the given file and creates MARC::Record-objects out of it.
|
|
|
|
@PARAM1, String, absolute path to the ISO2709 file.
|
|
@PARAM2, String, see stage_file.pl
|
|
@PARAM3, String, should be utf8
|
|
|
|
Returns two array refs.
|
|
|
|
=cut
|
|
|
|
sub RecordsFromISO2709File {
|
|
my ( $input_file, $record_type, $encoding ) = @_;
|
|
my @errors;
|
|
|
|
my $marc_type = C4::Context->preference('marcflavour');
|
|
$marc_type .= 'AUTH' if ( $marc_type eq 'UNIMARC' && $record_type eq 'auth' );
|
|
|
|
open my $fh, '<', $input_file or die "$0: cannot open input file $input_file: $!\n";
|
|
my @marc_records;
|
|
$/ = "\035";
|
|
while (<$fh>) {
|
|
s/^\s+//;
|
|
s/\s+$//;
|
|
next unless $_; # skip if record has only whitespace, as might occur
|
|
# if file includes newlines between each MARC record
|
|
my ( $marc_record, $charset_guessed, $char_errors ) = MarcToUTF8Record( $_, $marc_type, $encoding );
|
|
push @marc_records, $marc_record;
|
|
if ( $charset_guessed ne $encoding ) {
|
|
push @errors,
|
|
"Unexpected charset $charset_guessed, expecting $encoding";
|
|
}
|
|
}
|
|
close $fh;
|
|
return ( \@errors, \@marc_records );
|
|
}
|
|
|
|
=head2 RecordsFromMARCXMLFile
|
|
|
|
my ($errors, $records) = C4::ImportBatch::RecordsFromMARCXMLFile($input_file, $encoding);
|
|
|
|
Creates MARC::Record-objects out of the given MARCXML-file.
|
|
|
|
@PARAM1, String, absolute path to the MARCXML file.
|
|
@PARAM2, String, should be utf8
|
|
|
|
Returns two array refs.
|
|
|
|
=cut
|
|
|
|
sub RecordsFromMARCXMLFile {
|
|
my ( $filename, $encoding ) = @_;
|
|
my $batch = MARC::File::XML->in($filename);
|
|
my ( @marcRecords, @errors, $record );
|
|
do {
|
|
eval { $record = $batch->next($encoding); };
|
|
if ($@) {
|
|
push @errors, $@;
|
|
}
|
|
push @marcRecords, $record if $record;
|
|
} while ($record);
|
|
return ( \@errors, \@marcRecords );
|
|
}
|
|
|
|
=head2 RecordsFromMarcPlugin
|
|
|
|
Converts text of input_file into array of MARC records with to_marc plugin
|
|
|
|
=cut
|
|
|
|
sub RecordsFromMarcPlugin {
|
|
my ( $input_file, $plugin_class, $encoding ) = @_;
|
|
my ( $text, @return );
|
|
return \@return if !$input_file || !$plugin_class;
|
|
|
|
# Read input file
|
|
open my $fh, '<', $input_file or die "$0: cannot open input file $input_file: $!\n";
|
|
$/ = "\035";
|
|
while (<$fh>) {
|
|
s/^\s+//;
|
|
s/\s+$//;
|
|
next unless $_;
|
|
$text .= $_;
|
|
}
|
|
close $fh;
|
|
|
|
# Convert to large MARC blob with plugin
|
|
$text = Koha::Plugins::Handler->run(
|
|
{
|
|
class => $plugin_class,
|
|
method => 'to_marc',
|
|
params => { data => $text },
|
|
}
|
|
) if $text;
|
|
|
|
# Convert to array of MARC records
|
|
if ($text) {
|
|
my $marc_type = C4::Context->preference('marcflavour');
|
|
foreach my $blob ( split( /\x1D/, $text ) ) {
|
|
next if $blob =~ /^\s*$/;
|
|
my ($marcrecord) = MarcToUTF8Record( $blob, $marc_type, $encoding );
|
|
push @return, $marcrecord;
|
|
}
|
|
}
|
|
return \@return;
|
|
}
|
|
|
|
# internal functions
|
|
|
|
=head2 _create_import_record
|
|
|
|
my $import_record_id = _create_import_record($batch_id, $record_sequence,
|
|
$marc_record, $record_type, $encoding, $marc_type);
|
|
|
|
Inserts a new row into C<import_records> for the given MARC record and returns
|
|
the new C<import_record_id>.
|
|
|
|
=cut
|
|
|
|
sub _create_import_record {
|
|
my ( $batch_id, $record_sequence, $marc_record, $record_type, $encoding, $marc_type ) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare(
|
|
"INSERT INTO import_records (import_batch_id, record_sequence, marc, marcxml, marcxml_old,
|
|
record_type, encoding)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)"
|
|
);
|
|
$sth->execute(
|
|
$batch_id, $record_sequence, $marc_record->as_usmarc(), $marc_record->as_xml($marc_type), '',
|
|
$record_type, $encoding
|
|
);
|
|
my $import_record_id = $dbh->{'mysql_insertid'};
|
|
$sth->finish();
|
|
return $import_record_id;
|
|
}
|
|
|
|
=head2 _add_auth_fields
|
|
|
|
_add_auth_fields($import_record_id, $marc_record);
|
|
|
|
Extracts authority-specific fields from C<$marc_record> and stores them
|
|
in C<import_auths>.
|
|
|
|
=cut
|
|
|
|
sub _add_auth_fields {
|
|
my ( $import_record_id, $marc_record ) = @_;
|
|
|
|
my $controlnumber;
|
|
if ( $marc_record->field('001') ) {
|
|
$controlnumber = $marc_record->field('001')->data();
|
|
}
|
|
my $authorized_heading = GetAuthorizedHeading( { record => $marc_record } );
|
|
my $dbh = C4::Context->dbh;
|
|
my $sth = $dbh->prepare(
|
|
"INSERT INTO import_auths (import_record_id, control_number, authorized_heading) VALUES (?, ?, ?)");
|
|
$sth->execute( $import_record_id, $controlnumber, $authorized_heading );
|
|
$sth->finish();
|
|
}
|
|
|
|
=head2 _add_biblio_fields
|
|
|
|
_add_biblio_fields($import_record_id, $marc_record);
|
|
|
|
Extracts bibliographic fields (title, author, ISBN) from C<$marc_record> and
|
|
inserts them into C<import_biblios>.
|
|
|
|
=cut
|
|
|
|
sub _add_biblio_fields {
|
|
my ( $import_record_id, $marc_record ) = @_;
|
|
|
|
my ( $title, $author, $isbn, $issn ) = _parse_biblio_fields($marc_record);
|
|
my $dbh = C4::Context->dbh;
|
|
|
|
# FIXME no controlnumber, originalsource
|
|
$isbn = C4::Koha::GetNormalizedISBN($isbn);
|
|
my $sth = $dbh->prepare(
|
|
"INSERT INTO import_biblios (import_record_id, title, author, isbn, issn) VALUES (?, ?, ?, ?, ?)");
|
|
$sth->execute( $import_record_id, $title, $author, $isbn, $issn ) or die $sth->errstr;
|
|
$sth->finish();
|
|
|
|
}
|
|
|
|
=head2 _update_biblio_fields
|
|
|
|
_update_biblio_fields($import_record_id, $marc_record);
|
|
|
|
Updates the C<import_biblios> row for an already-staged bibliographic record
|
|
with freshly parsed field values.
|
|
|
|
=cut
|
|
|
|
sub _update_biblio_fields {
|
|
my ( $import_record_id, $marc_record ) = @_;
|
|
|
|
my ( $title, $author, $isbn, $issn ) = _parse_biblio_fields($marc_record);
|
|
my $dbh = C4::Context->dbh;
|
|
|
|
# FIXME no controlnumber, originalsource
|
|
# FIXME 2 - should regularize normalization of ISBN wherever it is done
|
|
$isbn =~ s/\(.*$//;
|
|
$isbn =~ tr/ -_//;
|
|
$isbn = uc $isbn;
|
|
my $sth = $dbh->prepare(
|
|
"UPDATE import_biblios SET title = ?, author = ?, isbn = ?, issn = ?
|
|
WHERE import_record_id = ?"
|
|
);
|
|
$sth->execute( $title, $author, $isbn, $issn, $import_record_id );
|
|
$sth->finish();
|
|
}
|
|
|
|
=head2 _parse_biblio_fields
|
|
|
|
my ($title, $author, $isbn, $issn, $lccn, $biblionumber) =
|
|
_parse_biblio_fields($marc_record);
|
|
|
|
Extracts key bibliographic fields from a MARC::Record object and returns
|
|
them as a list.
|
|
|
|
=cut
|
|
|
|
sub _parse_biblio_fields {
|
|
my ($marc_record) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my $bibliofields = TransformMarcToKoha(
|
|
{
|
|
record => $marc_record,
|
|
kohafields => [ 'biblio.title', 'biblio.author', 'biblioitems.isbn', 'biblioitems.issn' ]
|
|
}
|
|
);
|
|
return ( $bibliofields->{'title'}, $bibliofields->{'author'}, $bibliofields->{'isbn'}, $bibliofields->{'issn'} );
|
|
|
|
}
|
|
|
|
=head2 _update_batch_record_counts
|
|
|
|
_update_batch_record_counts($batch_id);
|
|
|
|
Recalculates and updates the record-count summary columns on the
|
|
C<import_batches> row for C<$batch_id>.
|
|
|
|
=cut
|
|
|
|
sub _update_batch_record_counts {
|
|
my ($batch_id) = @_;
|
|
|
|
my $dbh = C4::Context->dbh;
|
|
my ($num_records) = $dbh->selectrow_array(
|
|
q|
|
|
SELECT COUNT(*)
|
|
FROM import_records
|
|
WHERE import_batch_id = ?
|
|
|, undef, $batch_id
|
|
);
|
|
my ($num_items) = $dbh->selectrow_array(
|
|
q|
|
|
SELECT COUNT(*)
|
|
FROM import_records
|
|
JOIN import_items USING (import_record_id)
|
|
WHERE import_batch_id = ? AND record_type = 'biblio'
|
|
|, undef, $batch_id
|
|
);
|
|
$dbh->do(
|
|
"UPDATE import_batches SET num_records=?, num_items=? WHERE import_batch_id=?",
|
|
undef,
|
|
$num_records,
|
|
$num_items,
|
|
$batch_id,
|
|
);
|
|
}
|
|
|
|
=head2 _get_commit_action
|
|
|
|
my ($biblio_action, $item_action, $match_id) =
|
|
_get_commit_action($overlay_action, $nomatch_action, $item_action,
|
|
$overlay_status, $import_record_id, $record_type);
|
|
|
|
Determines the appropriate commit action (C<create_new>, C<replace>,
|
|
C<ignore>) for a record based on the batch overlay/nomatch settings and
|
|
the record's current overlay status.
|
|
|
|
=cut
|
|
|
|
sub _get_commit_action {
|
|
my ( $overlay_action, $nomatch_action, $item_action, $overlay_status, $import_record_id, $record_type ) = @_;
|
|
|
|
if ( $record_type eq 'biblio' ) {
|
|
my ( $bib_result, $bib_match, $item_result );
|
|
|
|
$bib_match = GetBestRecordMatch($import_record_id);
|
|
if ( $overlay_status ne 'no_match' && defined($bib_match) ) {
|
|
|
|
$bib_result = $overlay_action;
|
|
|
|
if ( $item_action eq 'always_add' or $item_action eq 'add_only_for_matches' ) {
|
|
$item_result = 'create_new';
|
|
} elsif ( $item_action eq 'replace' ) {
|
|
$item_result = 'replace';
|
|
} else {
|
|
$item_result = 'ignore';
|
|
}
|
|
|
|
} else {
|
|
$bib_result = $nomatch_action;
|
|
$item_result =
|
|
( $item_action eq 'always_add' or $item_action eq 'add_only_for_new' ) ? 'create_new' : 'ignore';
|
|
}
|
|
return ( $bib_result, $item_result, $bib_match );
|
|
} else { # must be auths
|
|
my ( $auth_result, $auth_match );
|
|
|
|
$auth_match = GetBestRecordMatch($import_record_id);
|
|
if ( $overlay_status ne 'no_match' && defined($auth_match) ) {
|
|
$auth_result = $overlay_action;
|
|
} else {
|
|
$auth_result = $nomatch_action;
|
|
}
|
|
|
|
return ( $auth_result, undef, $auth_match );
|
|
|
|
}
|
|
}
|
|
|
|
=head2 _get_revert_action
|
|
|
|
my ($bib_result, $item_result) =
|
|
_get_revert_action($overlay_action, $overlay_status, $status);
|
|
|
|
Determines the appropriate revert action for a record based on the batch
|
|
overlay action and the record's current overlay/import status.
|
|
|
|
=cut
|
|
|
|
sub _get_revert_action {
|
|
my ( $overlay_action, $overlay_status, $status ) = @_;
|
|
|
|
my $bib_result;
|
|
|
|
if ( $status eq 'ignored' ) {
|
|
$bib_result = 'ignore';
|
|
} else {
|
|
if ( $overlay_action eq 'create_new' ) {
|
|
$bib_result = 'delete';
|
|
} else {
|
|
$bib_result = ( $overlay_status eq 'match_applied' ) ? 'restore' : 'delete';
|
|
}
|
|
}
|
|
return $bib_result;
|
|
}
|
|
|
|
1;
|
|
__END__
|
|
|
|
=head1 AUTHOR
|
|
|
|
Koha Development Team <https://koha-community.org/>
|
|
|
|
Galen Charlton <galen.charlton@liblime.com>
|
|
|
|
=cut
|