1 package C4::ImportBatch;
3 # Copyright (C) 2007 LibLime, 2012 C & P Bibliography Services
5 # This file is part of Koha.
7 # Koha is free software; you can redistribute it and/or modify it
8 # under the terms of the GNU General Public License as published by
9 # the Free Software Foundation; either version 3 of the License, or
10 # (at your option) any later version.
12 # Koha is distributed in the hope that it will be useful, but
13 # WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU General Public License for more details.
17 # You should have received a copy of the GNU General Public License
18 # along with Koha; if not, see <http://www.gnu.org/licenses>.
24 use C4::Koha qw( GetNormalizedISBN );
33 use C4::Items qw( AddItemFromMarc ModItemFromMarc );
34 use C4::Charset qw( MarcToUTF8Record SetUTF8Flag StripNonXmlChars );
35 use C4::AuthoritiesMarc qw( AddAuthority GuessAuthTypeCode GetAuthorityXML ModAuthority DelAuthority );
36 use C4::MarcModificationTemplates qw( ModifyRecordWithTemplate );
38 use Koha::SearchEngine;
39 use Koha::SearchEngine::Indexer;
40 use Koha::Plugins::Handler;
43 our (@ISA, @EXPORT_OK);
51 GetImportRecordMarcXML
52 GetRecordFromImportBiblio
57 AddItemsToImportBiblio
68 GetStagedWebserviceBatches
69 GetImportBatchRangeDesc
70 GetNumberOfNonZ3950ImportBatches
73 GetItemNumbersFromImportBatch
77 GetImportBatchOverlayAction
78 SetImportBatchOverlayAction
79 GetImportBatchNoMatchAction
80 SetImportBatchNoMatchAction
81 GetImportBatchItemAction
82 SetImportBatchItemAction
85 GetImportRecordOverlayStatus
86 SetImportRecordOverlayStatus
89 SetMatchedBiblionumber
90 GetImportRecordMatches
91 SetImportRecordMatches
93 RecordsFromMARCXMLFile
94 RecordsFromISO2709File
101 C4::ImportBatch - manage batches of imported MARC records
109 =head2 GetZ3950BatchId
111 my $batchid = GetZ3950BatchId($z3950server);
113 Retrieves the ID of the import batch for the Z39.50
114 reservoir for the given target. If necessary,
115 creates the import batch.
119 sub GetZ3950BatchId {
120 my ($z3950server) = @_;
122 my $dbh = C4::Context->dbh;
123 my $sth = $dbh->prepare("SELECT import_batch_id FROM import_batches
124 WHERE batch_type = 'z3950'
126 $sth->execute($z3950server);
127 my $rowref = $sth->fetchrow_arrayref();
129 if (defined $rowref) {
132 my $batch_id = AddImportBatch( {
133 overlay_action => 'create_new',
134 import_status => 'staged',
135 batch_type => 'z3950',
136 file_name => $z3950server,
143 =head2 GetWebserviceBatchId
145 my $batchid = GetWebserviceBatchId();
147 Retrieves the ID of the import batch for webservice.
148 If necessary, creates the import batch.
152 my $WEBSERVICE_BASE_QRY = <<EOQ;
153 SELECT import_batch_id FROM import_batches
154 WHERE batch_type = 'webservice'
155 AND import_status = 'staged'
157 sub GetWebserviceBatchId {
160 my $dbh = C4::Context->dbh;
161 my $sql = $WEBSERVICE_BASE_QRY;
163 foreach my $field (qw(matcher_id overlay_action nomatch_action item_action)) {
164 if (my $val = $params->{$field}) {
165 $sql .= " AND $field = ?";
169 my $id = $dbh->selectrow_array($sql, undef, @args);
172 $params->{batch_type} = 'webservice';
173 $params->{import_status} = 'staged';
174 return AddImportBatch($params);
177 =head2 GetImportRecordMarc
179 my ($marcblob, $encoding) = GetImportRecordMarc($import_record_id);
183 sub GetImportRecordMarc {
184 my ($import_record_id) = @_;
186 my $dbh = C4::Context->dbh;
187 my ( $marc, $encoding ) = $dbh->selectrow_array(q|
188 SELECT marc, encoding
190 WHERE import_record_id = ?
191 |, undef, $import_record_id );
193 return $marc, $encoding;
196 sub GetRecordFromImportBiblio {
197 my ( $import_record_id, $embed_items ) = @_;
199 my ($marc) = GetImportRecordMarc($import_record_id);
200 my $record = MARC::Record->new_from_usmarc($marc);
202 EmbedItemsInImportBiblio( $record, $import_record_id ) if $embed_items;
207 sub EmbedItemsInImportBiblio {
208 my ( $record, $import_record_id ) = @_;
209 my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField( "items.itemnumber" );
210 my $dbh = C4::Context->dbh;
211 my $import_items = $dbh->selectall_arrayref(q|
212 SELECT import_items.marcxml
214 WHERE import_record_id = ?
215 |, { Slice => {} }, $import_record_id );
217 for my $import_item ( @$import_items ) {
218 my $item_marc = MARC::Record::new_from_xml($import_item->{marcxml}, 'UTF-8');
219 push @item_fields, $item_marc->field($itemtag);
221 $record->append_fields(@item_fields);
225 =head2 GetImportRecordMarcXML
227 my $marcxml = GetImportRecordMarcXML($import_record_id);
231 sub GetImportRecordMarcXML {
232 my ($import_record_id) = @_;
234 my $dbh = C4::Context->dbh;
235 my $sth = $dbh->prepare("SELECT marcxml FROM import_records WHERE import_record_id = ?");
236 $sth->execute($import_record_id);
237 my ($marcxml) = $sth->fetchrow();
243 =head2 AddImportBatch
245 my $batch_id = AddImportBatch($params_hash);
253 foreach (qw( matcher_id template_id branchcode
254 overlay_action nomatch_action item_action
255 import_status batch_type file_name comments record_type )) {
256 if (exists $params->{$_}) {
258 push @vals, $params->{$_};
261 my $dbh = C4::Context->dbh;
262 $dbh->do("INSERT INTO import_batches (".join( ',', @fields).")
263 VALUES (".join( ',', map '?', @fields).")",
266 return $dbh->{'mysql_insertid'};
269 =head2 GetImportBatch
271 my $row = GetImportBatch($batch_id);
273 Retrieve a hashref of an import_batches row.
280 my $dbh = C4::Context->dbh;
281 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 = ?");
282 $sth->bind_param(1, $batch_id);
284 my $result = $sth->fetchrow_hashref;
290 =head2 AddBiblioToBatch
292 my $import_record_id = AddBiblioToBatch($batch_id, $record_sequence,
293 $marc_record, $encoding, $update_counts);
297 sub AddBiblioToBatch {
298 my $batch_id = shift;
299 my $record_sequence = shift;
300 my $marc_record = shift;
301 my $encoding = shift;
302 my $update_counts = @_ ? shift : 1;
304 my $import_record_id = _create_import_record($batch_id, $record_sequence, $marc_record, 'biblio', $encoding, C4::Context->preference('marcflavour'));
305 _add_biblio_fields($import_record_id, $marc_record);
306 _update_batch_record_counts($batch_id) if $update_counts;
307 return $import_record_id;
310 =head2 AddAuthToBatch
312 my $import_record_id = AddAuthToBatch($batch_id, $record_sequence,
313 $marc_record, $encoding, $update_counts, [$marc_type]);
318 my $batch_id = shift;
319 my $record_sequence = shift;
320 my $marc_record = shift;
321 my $encoding = shift;
322 my $update_counts = @_ ? shift : 1;
323 my $marc_type = shift || C4::Context->preference('marcflavour');
325 $marc_type = 'UNIMARCAUTH' if $marc_type eq 'UNIMARC';
327 my $import_record_id = _create_import_record($batch_id, $record_sequence, $marc_record, 'auth', $encoding, $marc_type);
328 _add_auth_fields($import_record_id, $marc_record);
329 _update_batch_record_counts($batch_id) if $update_counts;
330 return $import_record_id;
333 =head2 BatchStageMarcRecords
335 ( $batch_id, $num_records, $num_items, @invalid_records ) =
336 BatchStageMarcRecords(
337 $record_type, $encoding,
338 $marc_records, $file_name,
339 $marc_modification_template, $comments,
340 $branch_code, $parse_items,
341 $leave_as_staging, $progress_interval,
347 sub BatchStageMarcRecords {
348 my $record_type = shift;
349 my $encoding = shift;
350 my $marc_records = shift;
351 my $file_name = shift;
352 my $marc_modification_template = shift;
353 my $comments = shift;
354 my $branch_code = shift;
355 my $parse_items = shift;
356 my $leave_as_staging = shift;
358 # optional callback to monitor status
360 my $progress_interval = 0;
361 my $progress_callback = undef;
363 $progress_interval = shift;
364 $progress_callback = shift;
365 $progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
366 $progress_interval = 0 unless 'CODE' eq ref $progress_callback;
369 my $batch_id = AddImportBatch( {
370 overlay_action => 'create_new',
371 import_status => 'staging',
372 batch_type => 'batch',
373 file_name => $file_name,
374 comments => $comments,
375 record_type => $record_type,
378 SetImportBatchItemAction($batch_id, 'always_add');
380 SetImportBatchItemAction($batch_id, 'ignore');
384 my $marc_type = C4::Context->preference('marcflavour');
385 $marc_type .= 'AUTH' if ($marc_type eq 'UNIMARC' && $record_type eq 'auth');
386 my @invalid_records = ();
389 # FIXME - for now, we're dealing only with bibs
391 foreach my $marc_record (@$marc_records) {
393 if ($progress_interval and (0 == ($rec_num % $progress_interval))) {
394 &$progress_callback($rec_num);
397 ModifyRecordWithTemplate( $marc_modification_template, $marc_record ) if ( $marc_modification_template );
399 my $import_record_id;
400 if (scalar($marc_record->fields()) == 0) {
401 push @invalid_records, $marc_record;
404 # Normalize the record so it doesn't have separated diacritics
405 SetUTF8Flag($marc_record);
408 if ($record_type eq 'biblio') {
409 $import_record_id = AddBiblioToBatch($batch_id, $rec_num, $marc_record, $encoding, int(rand(99999)), 0);
411 my @import_items_ids = AddItemsToImportBiblio($batch_id, $import_record_id, $marc_record, 0);
412 $num_items += scalar(@import_items_ids);
414 } elsif ($record_type eq 'auth') {
415 $import_record_id = AddAuthToBatch($batch_id, $rec_num, $marc_record, $encoding, int(rand(99999)), 0, $marc_type);
419 unless ($leave_as_staging) {
420 SetImportBatchStatus($batch_id, 'staged');
422 # FIXME branch_code, number of bibs, number of items
423 _update_batch_record_counts($batch_id);
424 return ($batch_id, $num_valid, $num_items, @invalid_records);
427 =head2 AddItemsToImportBiblio
429 my @import_items_ids = AddItemsToImportBiblio($batch_id,
430 $import_record_id, $marc_record, $update_counts);
434 sub AddItemsToImportBiblio {
435 my $batch_id = shift;
436 my $import_record_id = shift;
437 my $marc_record = shift;
438 my $update_counts = @_ ? shift : 0;
440 my @import_items_ids = ();
442 my $dbh = C4::Context->dbh;
443 my ($item_tag,$item_subfield) = &GetMarcFromKohaField( "items.itemnumber" );
444 foreach my $item_field ($marc_record->field($item_tag)) {
445 my $item_marc = MARC::Record->new();
446 $item_marc->leader("00000 a "); # must set Leader/09 to 'a'
447 $item_marc->append_fields($item_field);
448 $marc_record->delete_field($item_field);
449 my $sth = $dbh->prepare_cached("INSERT INTO import_items (import_record_id, status, marcxml)
451 $sth->bind_param(1, $import_record_id);
452 $sth->bind_param(2, 'staged');
453 $sth->bind_param(3, $item_marc->as_xml("USMARC"));
455 push @import_items_ids, $dbh->{'mysql_insertid'};
459 if ($#import_items_ids > -1) {
460 _update_batch_record_counts($batch_id) if $update_counts;
461 _update_import_record_marc($import_record_id, $marc_record, C4::Context->preference('marcflavour'));
463 return @import_items_ids;
466 =head2 BatchFindDuplicates
468 my $num_with_matches = BatchFindDuplicates($batch_id, $matcher,
469 $max_matches, $progress_interval, $progress_callback);
471 Goes through the records loaded in the batch and attempts to
472 find duplicates for each one. Sets the matching status
473 of each record to "no_match" or "auto_match" as appropriate.
475 The $max_matches parameter is optional; if it is not supplied,
478 The $progress_interval and $progress_callback parameters are
479 optional; if both are supplied, the sub referred to by
480 $progress_callback will be invoked every $progress_interval
481 records using the number of records processed as the
486 sub BatchFindDuplicates {
487 my $batch_id = shift;
489 my $max_matches = @_ ? shift : 10;
491 # optional callback to monitor status
493 my $progress_interval = 0;
494 my $progress_callback = undef;
496 $progress_interval = shift;
497 $progress_callback = shift;
498 $progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
499 $progress_interval = 0 unless 'CODE' eq ref $progress_callback;
502 my $dbh = C4::Context->dbh;
504 my $sth = $dbh->prepare("SELECT import_record_id, record_type, marc
506 WHERE import_batch_id = ?");
507 $sth->execute($batch_id);
508 my $num_with_matches = 0;
510 while (my $rowref = $sth->fetchrow_hashref) {
512 if ($progress_interval and (0 == ($rec_num % $progress_interval))) {
513 &$progress_callback($rec_num);
515 my $marc_record = MARC::Record->new_from_usmarc($rowref->{'marc'});
517 if (defined $matcher) {
518 @matches = $matcher->get_matches($marc_record, $max_matches);
520 if (scalar(@matches) > 0) {
522 SetImportRecordMatches($rowref->{'import_record_id'}, @matches);
523 SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'auto_match');
525 SetImportRecordMatches($rowref->{'import_record_id'}, ());
526 SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'no_match');
530 return $num_with_matches;
533 =head2 BatchCommitRecords
535 my ($num_added, $num_updated, $num_items_added, $num_items_replaced, $num_items_errored, $num_ignored) =
536 BatchCommitRecords($batch_id, $framework,
537 $progress_interval, $progress_callback);
541 sub BatchCommitRecords {
542 my $batch_id = shift;
543 my $framework = shift;
545 my $schema = Koha::Database->schema;
547 # optional callback to monitor status
549 my $progress_interval = 0;
550 my $progress_callback = undef;
552 $progress_interval = shift;
553 $progress_callback = shift;
554 $progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
555 $progress_interval = 0 unless 'CODE' eq ref $progress_callback;
561 my $num_items_added = 0;
562 my $num_items_replaced = 0;
563 my $num_items_errored = 0;
565 # commit (i.e., save, all records in the batch)
566 SetImportBatchStatus($batch_id, 'importing');
567 my $overlay_action = GetImportBatchOverlayAction($batch_id);
568 my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
569 my $item_action = GetImportBatchItemAction($batch_id);
572 my $dbh = C4::Context->dbh;
573 my $sth = $dbh->prepare("SELECT import_records.import_record_id, record_type, status, overlay_status, marc, encoding
575 LEFT JOIN import_auths ON (import_records.import_record_id=import_auths.import_record_id)
576 LEFT JOIN import_biblios ON (import_records.import_record_id=import_biblios.import_record_id)
577 WHERE import_batch_id = ?");
578 $sth->execute($batch_id);
579 my $marcflavour = C4::Context->preference('marcflavour');
581 my $userenv = C4::Context->userenv;
582 my $logged_in_patron = Koha::Patrons->find( $userenv->{number} );
586 $schema->txn_begin; # We commit in a transaction
587 while (my $rowref = $sth->fetchrow_hashref) {
588 $record_type = $rowref->{'record_type'};
592 if ($progress_interval and (0 == ($rec_num % $progress_interval))) {
593 # report progress and commit
595 &$progress_callback( $rec_num );
598 if ($rowref->{'status'} eq 'error' or $rowref->{'status'} eq 'imported') {
604 if ($marcflavour eq 'UNIMARC' && $record_type eq 'auth') {
605 $marc_type = 'UNIMARCAUTH';
606 } elsif ($marcflavour eq 'UNIMARC') {
607 $marc_type = 'UNIMARC';
609 $marc_type = 'USMARC';
611 my $marc_record = MARC::Record->new_from_usmarc($rowref->{'marc'});
613 if ($record_type eq 'biblio') {
614 # remove any item tags - rely on _batchCommitItems
615 ($item_tag,$item_subfield) = &GetMarcFromKohaField( "items.itemnumber" );
616 foreach my $item_field ($marc_record->field($item_tag)) {
617 $marc_record->delete_field($item_field);
621 my ($record_result, $item_result, $record_match) =
622 _get_commit_action($overlay_action, $nomatch_action, $item_action,
623 $rowref->{'overlay_status'}, $rowref->{'import_record_id'}, $record_type);
627 if ($record_result eq 'create_new') {
629 if ($record_type eq 'biblio') {
630 my $biblioitemnumber;
631 ($recordid, $biblioitemnumber) = AddBiblio($marc_record, $framework, { skip_record_index => 1 });
632 push @biblio_ids, $recordid;
633 $query = "UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?"; # FIXME call SetMatchedBiblionumber instead
634 if ($item_result eq 'create_new' || $item_result eq 'replace') {
635 my ($bib_items_added, $bib_items_replaced, $bib_items_errored) = _batchCommitItems($rowref->{'import_record_id'}, $recordid, $item_result, $biblioitemnumber);
636 $num_items_added += $bib_items_added;
637 $num_items_replaced += $bib_items_replaced;
638 $num_items_errored += $bib_items_errored;
641 $recordid = AddAuthority($marc_record, undef, GuessAuthTypeCode($marc_record));
642 $query = "UPDATE import_auths SET matched_authid = ? WHERE import_record_id = ?";
644 my $sth = $dbh->prepare_cached($query);
645 $sth->execute($recordid, $rowref->{'import_record_id'});
647 SetImportRecordStatus($rowref->{'import_record_id'}, 'imported');
648 } elsif ($record_result eq 'replace') {
650 $recordid = $record_match;
652 if ($record_type eq 'biblio') {
653 my $oldbiblio = Koha::Biblios->find( $recordid );
654 $oldxml = GetXmlBiblio($recordid);
656 # remove item fields so that they don't get
657 # added again if record is reverted
658 # 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.
659 my $old_marc = MARC::Record->new_from_xml(StripNonXmlChars($oldxml), 'UTF-8', $rowref->{'encoding'}, $marc_type);
660 foreach my $item_field ($old_marc->field($item_tag)) {
661 $old_marc->delete_field($item_field);
663 $oldxml = $old_marc->as_xml($marc_type);
665 my $context = { source => 'batchimport' };
666 if ($logged_in_patron) {
667 $context->{categorycode} = $logged_in_patron->categorycode;
668 $context->{userid} = $logged_in_patron->userid;
674 $oldbiblio->frameworkcode,
676 overlay_context => $context,
677 skip_record_index => 1
680 push @biblio_ids, $recordid;
681 $query = "UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?"; # FIXME call SetMatchedBiblionumber instead
683 if ($item_result eq 'create_new' || $item_result eq 'replace') {
684 my ($bib_items_added, $bib_items_replaced, $bib_items_errored) = _batchCommitItems($rowref->{'import_record_id'}, $recordid, $item_result);
685 $num_items_added += $bib_items_added;
686 $num_items_replaced += $bib_items_replaced;
687 $num_items_errored += $bib_items_errored;
690 $oldxml = GetAuthorityXML($recordid);
692 ModAuthority($recordid, $marc_record, GuessAuthTypeCode($marc_record));
693 $query = "UPDATE import_auths SET matched_authid = ? WHERE import_record_id = ?";
695 my $sth = $dbh->prepare_cached("UPDATE import_records SET marcxml_old = ? WHERE import_record_id = ?");
696 $sth->execute($oldxml, $rowref->{'import_record_id'});
698 my $sth2 = $dbh->prepare_cached($query);
699 $sth2->execute($recordid, $rowref->{'import_record_id'});
701 SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'match_applied');
702 SetImportRecordStatus($rowref->{'import_record_id'}, 'imported');
703 } elsif ($record_result eq 'ignore') {
704 $recordid = $record_match;
706 if ($record_type eq 'biblio' and defined $recordid and ( $item_result eq 'create_new' || $item_result eq 'replace' ) ) {
707 my ($bib_items_added, $bib_items_replaced, $bib_items_errored) = _batchCommitItems($rowref->{'import_record_id'}, $recordid, $item_result);
708 push @biblio_ids, $recordid if $bib_items_added || $bib_items_replaced;
709 $num_items_added += $bib_items_added;
710 $num_items_replaced += $bib_items_replaced;
711 $num_items_errored += $bib_items_errored;
712 # still need to record the matched biblionumber so that the
713 # items can be reverted
714 my $sth2 = $dbh->prepare_cached("UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?"); # FIXME call SetMatchedBiblionumber instead
715 $sth2->execute($recordid, $rowref->{'import_record_id'});
716 SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'match_applied');
718 SetImportRecordStatus($rowref->{'import_record_id'}, 'ignored');
721 $schema->txn_commit; # Commit final records that may not have hit callback threshold
725 my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
726 $indexer->index_records( \@biblio_ids, "specialUpdate", "biblioserver" );
729 SetImportBatchStatus($batch_id, 'imported');
730 return ($num_added, $num_updated, $num_items_added, $num_items_replaced, $num_items_errored, $num_ignored);
733 =head2 _batchCommitItems
735 ($num_items_added, $num_items_errored) =
736 _batchCommitItems($import_record_id, $biblionumber, [$action, $biblioitemnumber]);
738 Private function for batch committing item changes. We do not trigger a re-index here, that is left to the caller.
742 sub _batchCommitItems {
743 my ( $import_record_id, $biblionumber, $action, $biblioitemnumber ) = @_;
745 my $dbh = C4::Context->dbh;
747 my $num_items_added = 0;
748 my $num_items_errored = 0;
749 my $num_items_replaced = 0;
751 my $sth = $dbh->prepare( "
752 SELECT import_items_id, import_items.marcxml, encoding
754 JOIN import_records USING (import_record_id)
755 WHERE import_record_id = ?
756 ORDER BY import_items_id
758 $sth->bind_param( 1, $import_record_id );
761 while ( my $row = $sth->fetchrow_hashref() ) {
762 my $item_marc = MARC::Record->new_from_xml( StripNonXmlChars( $row->{'marcxml'} ), 'UTF-8', $row->{'encoding'} );
764 # Delete date_due subfield as to not accidentally delete item checkout due dates
765 my ( $MARCfield, $MARCsubfield ) = GetMarcFromKohaField( 'items.onloan' );
766 $item_marc->field($MARCfield)->delete_subfield( code => $MARCsubfield );
768 my $item = TransformMarcToKoha({ record => $item_marc, kohafields => ['items.barcode','items.itemnumber'] });
770 my $duplicate_barcode = exists( $item->{'barcode'} ) && Koha::Items->find({ barcode => $item->{'barcode'} });
771 my $duplicate_itemnumber = exists( $item->{'itemnumber'} );
773 my $updsth = $dbh->prepare("UPDATE import_items SET status = ?, itemnumber = ?, import_error = ? WHERE import_items_id = ?");
774 if ( $action eq "replace" && $duplicate_itemnumber ) {
775 # Duplicate itemnumbers have precedence, that way we can update barcodes by overlaying
776 ModItemFromMarc( $item_marc, $biblionumber, $item->{itemnumber}, { skip_record_index => 1 } );
777 $updsth->bind_param( 1, 'imported' );
778 $updsth->bind_param( 2, $item->{itemnumber} );
779 $updsth->bind_param( 3, undef );
780 $updsth->bind_param( 4, $row->{'import_items_id'} );
783 $num_items_replaced++;
784 } elsif ( $action eq "replace" && $duplicate_barcode ) {
785 my $itemnumber = $duplicate_barcode->itemnumber;
786 ModItemFromMarc( $item_marc, $biblionumber, $itemnumber, { skip_record_index => 1 } );
787 $updsth->bind_param( 1, 'imported' );
788 $updsth->bind_param( 2, $item->{itemnumber} );
789 $updsth->bind_param( 3, undef );
790 $updsth->bind_param( 4, $row->{'import_items_id'} );
793 $num_items_replaced++;
794 } elsif ($duplicate_barcode) {
795 $updsth->bind_param( 1, 'error' );
796 $updsth->bind_param( 2, undef );
797 $updsth->bind_param( 3, 'duplicate item barcode' );
798 $updsth->bind_param( 4, $row->{'import_items_id'} );
800 $num_items_errored++;
802 # Remove the itemnumber if it exists, we want to create a new item
803 my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField( "items.itemnumber" );
804 $item_marc->field($itemtag)->delete_subfield( code => $itemsubfield );
806 my ( $item_biblionumber, $biblioitemnumber, $itemnumber ) = AddItemFromMarc( $item_marc, $biblionumber, { biblioitemnumber => $biblioitemnumber, skip_record_index => 1 } );
808 $updsth->bind_param( 1, 'imported' );
809 $updsth->bind_param( 2, $itemnumber );
810 $updsth->bind_param( 3, undef );
811 $updsth->bind_param( 4, $row->{'import_items_id'} );
819 return ( $num_items_added, $num_items_replaced, $num_items_errored );
822 =head2 BatchRevertRecords
824 my ($num_deleted, $num_errors, $num_reverted, $num_items_deleted,
825 $num_ignored) = BatchRevertRecords($batch_id);
829 sub BatchRevertRecords {
830 my $batch_id = shift;
832 my $logger = Koha::Logger->get( { category => 'C4.ImportBatch' } );
834 $logger->trace("C4::ImportBatch::BatchRevertRecords( $batch_id )");
839 my $num_reverted = 0;
841 my $num_items_deleted = 0;
842 # commit (i.e., save, all records in the batch)
843 SetImportBatchStatus($batch_id, 'reverting');
844 my $overlay_action = GetImportBatchOverlayAction($batch_id);
845 my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
846 my $dbh = C4::Context->dbh;
847 my $sth = $dbh->prepare("SELECT import_records.import_record_id, record_type, status, overlay_status, marcxml_old, encoding, matched_biblionumber, matched_authid
849 LEFT JOIN import_auths ON (import_records.import_record_id=import_auths.import_record_id)
850 LEFT JOIN import_biblios ON (import_records.import_record_id=import_biblios.import_record_id)
851 WHERE import_batch_id = ?");
852 $sth->execute($batch_id);
854 my $marcflavour = C4::Context->preference('marcflavour');
855 while (my $rowref = $sth->fetchrow_hashref) {
856 $record_type = $rowref->{'record_type'};
857 if ($rowref->{'status'} eq 'error' or $rowref->{'status'} eq 'reverted') {
861 if ($marcflavour eq 'UNIMARC' && $record_type eq 'auth') {
862 $marc_type = 'UNIMARCAUTH';
863 } elsif ($marcflavour eq 'UNIMARC') {
864 $marc_type = 'UNIMARC';
866 $marc_type = 'USMARC';
869 my $record_result = _get_revert_action($overlay_action, $rowref->{'overlay_status'}, $rowref->{'status'});
871 if ($record_result eq 'delete') {
873 if ($record_type eq 'biblio') {
874 $num_items_deleted += BatchRevertItems($rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'});
875 $error = DelBiblio($rowref->{'matched_biblionumber'});
877 DelAuthority({ authid => $rowref->{'matched_authid'} });
879 if (defined $error) {
883 SetImportRecordStatus($rowref->{'import_record_id'}, 'reverted');
885 } elsif ($record_result eq 'restore') {
887 my $old_record = MARC::Record->new_from_xml(StripNonXmlChars($rowref->{'marcxml_old'}), 'UTF-8', $rowref->{'encoding'}, $marc_type);
888 if ($record_type eq 'biblio') {
889 my $biblionumber = $rowref->{'matched_biblionumber'};
890 my $oldbiblio = Koha::Biblios->find( $biblionumber );
892 $logger->info("C4::ImportBatch::BatchRevertRecords: Biblio record $biblionumber does not exist, restoration of this record was skipped") unless $oldbiblio;
893 next unless $oldbiblio; # Record has since been deleted. Deleted records should stay deleted.
895 $num_items_deleted += BatchRevertItems($rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'});
896 ModBiblio($old_record, $biblionumber, $oldbiblio->frameworkcode);
898 my $authid = $rowref->{'matched_authid'};
899 ModAuthority($authid, $old_record, GuessAuthTypeCode($old_record));
901 SetImportRecordStatus($rowref->{'import_record_id'}, 'reverted');
902 } elsif ($record_result eq 'ignore') {
903 if ($record_type eq 'biblio') {
904 $num_items_deleted += BatchRevertItems($rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'});
906 SetImportRecordStatus($rowref->{'import_record_id'}, 'reverted');
909 if ($record_type eq 'biblio') {
910 # remove matched_biblionumber only if there is no 'imported' item left
911 $query = "UPDATE import_biblios SET matched_biblionumber = NULL WHERE import_record_id = ?"; # FIXME Remove me
912 $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')";
914 $query = "UPDATE import_auths SET matched_authid = NULL WHERE import_record_id = ?";
916 my $sth2 = $dbh->prepare_cached($query);
917 $sth2->execute($rowref->{'import_record_id'});
921 SetImportBatchStatus($batch_id, 'reverted');
922 return ($num_deleted, $num_errors, $num_reverted, $num_items_deleted, $num_ignored);
925 =head2 BatchRevertItems
927 my $num_items_deleted = BatchRevertItems($import_record_id, $biblionumber);
931 sub BatchRevertItems {
932 my ($import_record_id, $biblionumber) = @_;
934 my $dbh = C4::Context->dbh;
935 my $num_items_deleted = 0;
937 my $sth = $dbh->prepare_cached("SELECT import_items_id, itemnumber
939 JOIN items USING (itemnumber)
940 WHERE import_record_id = ?");
941 $sth->bind_param(1, $import_record_id);
943 while (my $row = $sth->fetchrow_hashref()) {
944 my $item = Koha::Items->find($row->{itemnumber});
945 if ($item->safe_delete){
946 my $updsth = $dbh->prepare("UPDATE import_items SET status = ? WHERE import_items_id = ?");
947 $updsth->bind_param(1, 'reverted');
948 $updsth->bind_param(2, $row->{'import_items_id'});
951 $num_items_deleted++;
958 return $num_items_deleted;
963 CleanBatch($batch_id)
965 Deletes all staged records from the import batch
966 and sets the status of the batch to 'cleaned'. Note
967 that deleting a stage record does *not* affect
968 any record that has been committed to the database.
973 my $batch_id = shift;
974 return unless defined $batch_id;
976 C4::Context->dbh->do('DELETE FROM import_records WHERE import_batch_id = ?', {}, $batch_id);
977 SetImportBatchStatus($batch_id, 'cleaned');
982 DeleteBatch($batch_id)
984 Deletes the record from the database. This can only be done
985 once the batch has been cleaned.
990 my $batch_id = shift;
991 return unless defined $batch_id;
993 my $dbh = C4::Context->dbh;
994 my $sth = $dbh->prepare('DELETE FROM import_batches WHERE import_batch_id = ?');
995 $sth->execute( $batch_id );
998 =head2 GetAllImportBatches
1000 my $results = GetAllImportBatches();
1002 Returns a references to an array of hash references corresponding
1003 to all import_batches rows (of batch_type 'batch'), sorted in
1004 ascending order by import_batch_id.
1008 sub GetAllImportBatches {
1009 my $dbh = C4::Context->dbh;
1010 my $sth = $dbh->prepare_cached("SELECT * FROM import_batches
1011 WHERE batch_type IN ('batch', 'webservice')
1012 ORDER BY import_batch_id ASC");
1016 while (my $row = $sth->fetchrow_hashref) {
1017 push @$results, $row;
1023 =head2 GetStagedWebserviceBatches
1025 my $batch_ids = GetStagedWebserviceBatches();
1027 Returns a references to an array of batch id's
1028 of batch_type 'webservice' that are not imported
1032 my $PENDING_WEBSERVICE_BATCHES_QRY = <<EOQ;
1033 SELECT import_batch_id FROM import_batches
1034 WHERE batch_type = 'webservice'
1035 AND import_status = 'staged'
1037 sub GetStagedWebserviceBatches {
1038 my $dbh = C4::Context->dbh;
1039 return $dbh->selectcol_arrayref($PENDING_WEBSERVICE_BATCHES_QRY);
1042 =head2 GetImportBatchRangeDesc
1044 my $results = GetImportBatchRangeDesc($offset, $results_per_group);
1046 Returns a reference to an array of hash references corresponding to
1047 import_batches rows (sorted in descending order by import_batch_id)
1048 start at the given offset.
1052 sub GetImportBatchRangeDesc {
1053 my ($offset, $results_per_group) = @_;
1055 my $dbh = C4::Context->dbh;
1056 my $query = "SELECT b.*, p.name as profile FROM import_batches b
1057 LEFT JOIN import_batch_profiles p
1058 ON b.profile_id = p.id
1059 WHERE b.batch_type IN ('batch', 'webservice')
1060 ORDER BY b.import_batch_id DESC";
1062 if ($results_per_group){
1063 $query .= " LIMIT ?";
1064 push(@params, $results_per_group);
1067 $query .= " OFFSET ?";
1068 push(@params, $offset);
1070 my $sth = $dbh->prepare_cached($query);
1071 $sth->execute(@params);
1072 my $results = $sth->fetchall_arrayref({});
1077 =head2 GetItemNumbersFromImportBatch
1079 my @itemsnos = GetItemNumbersFromImportBatch($batch_id);
1083 sub GetItemNumbersFromImportBatch {
1084 my ($batch_id) = @_;
1085 my $dbh = C4::Context->dbh;
1087 SELECT itemnumber FROM import_items
1088 INNER JOIN items USING (itemnumber)
1089 INNER JOIN import_records USING (import_record_id)
1090 WHERE import_batch_id = ?|;
1091 my $sth = $dbh->prepare( $sql );
1092 $sth->execute($batch_id);
1094 while ( my ($itm) = $sth->fetchrow_array ) {
1100 =head2 GetNumberOfImportBatches
1102 my $count = GetNumberOfImportBatches();
1106 sub GetNumberOfNonZ3950ImportBatches {
1107 my $dbh = C4::Context->dbh;
1108 my $sth = $dbh->prepare("SELECT COUNT(*) FROM import_batches WHERE batch_type != 'z3950'");
1110 my ($count) = $sth->fetchrow_array();
1115 =head2 GetImportBiblios
1117 my $results = GetImportBiblios($importid);
1121 sub GetImportBiblios {
1122 my ($import_record_id) = @_;
1124 my $dbh = C4::Context->dbh;
1125 my $query = "SELECT * FROM import_biblios WHERE import_record_id = ?";
1126 return $dbh->selectall_arrayref(
1134 =head2 GetImportRecordsRange
1136 my $results = GetImportRecordsRange($batch_id, $offset, $results_per_group);
1138 Returns a reference to an array of hash references corresponding to
1139 import_biblios/import_auths/import_records rows for a given batch
1140 starting at the given offset.
1144 sub GetImportRecordsRange {
1145 my ( $batch_id, $offset, $results_per_group, $status, $parameters ) = @_;
1147 my $dbh = C4::Context->dbh;
1149 my $order_by = $parameters->{order_by} || 'import_record_id';
1150 ( $order_by ) = grep( { $_ eq $order_by } qw( import_record_id title status overlay_status ) ) ? $order_by : 'import_record_id';
1152 my $order_by_direction =
1153 uc( $parameters->{order_by_direction} // 'ASC' ) eq 'DESC' ? 'DESC' : 'ASC';
1155 $order_by .= " $order_by_direction, authorized_heading" if $order_by eq 'title';
1157 my $query = "SELECT title, author, isbn, issn, authorized_heading, import_records.import_record_id,
1158 record_sequence, status, overlay_status,
1159 matched_biblionumber, matched_authid, record_type
1161 LEFT JOIN import_auths ON (import_records.import_record_id=import_auths.import_record_id)
1162 LEFT JOIN import_biblios ON (import_records.import_record_id=import_biblios.import_record_id)
1163 WHERE import_batch_id = ?";
1165 push(@params, $batch_id);
1167 $query .= " AND status=?";
1168 push(@params,$status);
1171 $query.=" ORDER BY $order_by $order_by_direction";
1173 if($results_per_group){
1174 $query .= " LIMIT ?";
1175 push(@params, $results_per_group);
1178 $query .= " OFFSET ?";
1179 push(@params, $offset);
1181 my $sth = $dbh->prepare_cached($query);
1182 $sth->execute(@params);
1183 my $results = $sth->fetchall_arrayref({});
1189 =head2 GetBestRecordMatch
1191 my $record_id = GetBestRecordMatch($import_record_id);
1195 sub GetBestRecordMatch {
1196 my ($import_record_id) = @_;
1198 my $dbh = C4::Context->dbh;
1199 my $sth = $dbh->prepare("SELECT candidate_match_id
1200 FROM import_record_matches
1201 JOIN import_records ON ( import_record_matches.import_record_id = import_records.import_record_id )
1202 LEFT JOIN biblio ON ( candidate_match_id = biblio.biblionumber )
1203 LEFT JOIN auth_header ON ( candidate_match_id = auth_header.authid )
1204 WHERE import_record_matches.import_record_id = ? AND
1205 ( (import_records.record_type = 'biblio' AND biblio.biblionumber IS NOT NULL) OR
1206 (import_records.record_type = 'auth' AND auth_header.authid IS NOT NULL) )
1208 ORDER BY score DESC, candidate_match_id DESC");
1209 $sth->execute($import_record_id);
1210 my ($record_id) = $sth->fetchrow_array();
1215 =head2 GetImportBatchStatus
1217 my $status = GetImportBatchStatus($batch_id);
1221 sub GetImportBatchStatus {
1222 my ($batch_id) = @_;
1224 my $dbh = C4::Context->dbh;
1225 my $sth = $dbh->prepare("SELECT import_status FROM import_batches WHERE import_batch_id = ?");
1226 $sth->execute($batch_id);
1227 my ($status) = $sth->fetchrow_array();
1233 =head2 SetImportBatchStatus
1235 SetImportBatchStatus($batch_id, $new_status);
1239 sub SetImportBatchStatus {
1240 my ($batch_id, $new_status) = @_;
1242 my $dbh = C4::Context->dbh;
1243 my $sth = $dbh->prepare("UPDATE import_batches SET import_status = ? WHERE import_batch_id = ?");
1244 $sth->execute($new_status, $batch_id);
1249 =head2 SetMatchedBiblionumber
1251 SetMatchedBiblionumber($import_record_id, $biblionumber);
1255 sub SetMatchedBiblionumber {
1256 my ($import_record_id, $biblionumber) = @_;
1258 my $dbh = C4::Context->dbh;
1260 q|UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?|,
1261 undef, $biblionumber, $import_record_id
1265 =head2 GetImportBatchOverlayAction
1267 my $overlay_action = GetImportBatchOverlayAction($batch_id);
1271 sub GetImportBatchOverlayAction {
1272 my ($batch_id) = @_;
1274 my $dbh = C4::Context->dbh;
1275 my $sth = $dbh->prepare("SELECT overlay_action FROM import_batches WHERE import_batch_id = ?");
1276 $sth->execute($batch_id);
1277 my ($overlay_action) = $sth->fetchrow_array();
1279 return $overlay_action;
1284 =head2 SetImportBatchOverlayAction
1286 SetImportBatchOverlayAction($batch_id, $new_overlay_action);
1290 sub SetImportBatchOverlayAction {
1291 my ($batch_id, $new_overlay_action) = @_;
1293 my $dbh = C4::Context->dbh;
1294 my $sth = $dbh->prepare("UPDATE import_batches SET overlay_action = ? WHERE import_batch_id = ?");
1295 $sth->execute($new_overlay_action, $batch_id);
1300 =head2 GetImportBatchNoMatchAction
1302 my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
1306 sub GetImportBatchNoMatchAction {
1307 my ($batch_id) = @_;
1309 my $dbh = C4::Context->dbh;
1310 my $sth = $dbh->prepare("SELECT nomatch_action FROM import_batches WHERE import_batch_id = ?");
1311 $sth->execute($batch_id);
1312 my ($nomatch_action) = $sth->fetchrow_array();
1314 return $nomatch_action;
1319 =head2 SetImportBatchNoMatchAction
1321 SetImportBatchNoMatchAction($batch_id, $new_nomatch_action);
1325 sub SetImportBatchNoMatchAction {
1326 my ($batch_id, $new_nomatch_action) = @_;
1328 my $dbh = C4::Context->dbh;
1329 my $sth = $dbh->prepare("UPDATE import_batches SET nomatch_action = ? WHERE import_batch_id = ?");
1330 $sth->execute($new_nomatch_action, $batch_id);
1335 =head2 GetImportBatchItemAction
1337 my $item_action = GetImportBatchItemAction($batch_id);
1341 sub GetImportBatchItemAction {
1342 my ($batch_id) = @_;
1344 my $dbh = C4::Context->dbh;
1345 my $sth = $dbh->prepare("SELECT item_action FROM import_batches WHERE import_batch_id = ?");
1346 $sth->execute($batch_id);
1347 my ($item_action) = $sth->fetchrow_array();
1349 return $item_action;
1354 =head2 SetImportBatchItemAction
1356 SetImportBatchItemAction($batch_id, $new_item_action);
1360 sub SetImportBatchItemAction {
1361 my ($batch_id, $new_item_action) = @_;
1363 my $dbh = C4::Context->dbh;
1364 my $sth = $dbh->prepare("UPDATE import_batches SET item_action = ? WHERE import_batch_id = ?");
1365 $sth->execute($new_item_action, $batch_id);
1370 =head2 GetImportBatchMatcher
1372 my $matcher_id = GetImportBatchMatcher($batch_id);
1376 sub GetImportBatchMatcher {
1377 my ($batch_id) = @_;
1379 my $dbh = C4::Context->dbh;
1380 my $sth = $dbh->prepare("SELECT matcher_id FROM import_batches WHERE import_batch_id = ?");
1381 $sth->execute($batch_id);
1382 my ($matcher_id) = $sth->fetchrow_array();
1389 =head2 SetImportBatchMatcher
1391 SetImportBatchMatcher($batch_id, $new_matcher_id);
1395 sub SetImportBatchMatcher {
1396 my ($batch_id, $new_matcher_id) = @_;
1398 my $dbh = C4::Context->dbh;
1399 my $sth = $dbh->prepare("UPDATE import_batches SET matcher_id = ? WHERE import_batch_id = ?");
1400 $sth->execute($new_matcher_id, $batch_id);
1405 =head2 GetImportRecordOverlayStatus
1407 my $overlay_status = GetImportRecordOverlayStatus($import_record_id);
1411 sub GetImportRecordOverlayStatus {
1412 my ($import_record_id) = @_;
1414 my $dbh = C4::Context->dbh;
1415 my $sth = $dbh->prepare("SELECT overlay_status FROM import_records WHERE import_record_id = ?");
1416 $sth->execute($import_record_id);
1417 my ($overlay_status) = $sth->fetchrow_array();
1419 return $overlay_status;
1424 =head2 SetImportRecordOverlayStatus
1426 SetImportRecordOverlayStatus($import_record_id, $new_overlay_status);
1430 sub SetImportRecordOverlayStatus {
1431 my ($import_record_id, $new_overlay_status) = @_;
1433 my $dbh = C4::Context->dbh;
1434 my $sth = $dbh->prepare("UPDATE import_records SET overlay_status = ? WHERE import_record_id = ?");
1435 $sth->execute($new_overlay_status, $import_record_id);
1440 =head2 GetImportRecordStatus
1442 my $status = GetImportRecordStatus($import_record_id);
1446 sub GetImportRecordStatus {
1447 my ($import_record_id) = @_;
1449 my $dbh = C4::Context->dbh;
1450 my $sth = $dbh->prepare("SELECT status FROM import_records WHERE import_record_id = ?");
1451 $sth->execute($import_record_id);
1452 my ($status) = $sth->fetchrow_array();
1459 =head2 SetImportRecordStatus
1461 SetImportRecordStatus($import_record_id, $new_status);
1465 sub SetImportRecordStatus {
1466 my ($import_record_id, $new_status) = @_;
1468 my $dbh = C4::Context->dbh;
1469 my $sth = $dbh->prepare("UPDATE import_records SET status = ? WHERE import_record_id = ?");
1470 $sth->execute($new_status, $import_record_id);
1475 =head2 GetImportRecordMatches
1477 my $results = GetImportRecordMatches($import_record_id, $best_only);
1481 sub GetImportRecordMatches {
1482 my $import_record_id = shift;
1483 my $best_only = @_ ? shift : 0;
1485 my $dbh = C4::Context->dbh;
1486 # FIXME currently biblio only
1487 my $sth = $dbh->prepare_cached("SELECT title, author, biblionumber,
1488 candidate_match_id, score, record_type,
1491 JOIN import_record_matches USING (import_record_id)
1492 LEFT JOIN biblio ON (biblionumber = candidate_match_id)
1493 WHERE import_record_id = ?
1494 ORDER BY score DESC, biblionumber DESC");
1495 $sth->bind_param(1, $import_record_id);
1498 while (my $row = $sth->fetchrow_hashref) {
1499 if ($row->{'record_type'} eq 'auth') {
1500 $row->{'authorized_heading'} = C4::AuthoritiesMarc::GetAuthorizedHeading( { authid => $row->{'candidate_match_id'} } );
1502 next if ($row->{'record_type'} eq 'biblio' && not $row->{'biblionumber'});
1503 push @$results, $row;
1512 =head2 SetImportRecordMatches
1514 SetImportRecordMatches($import_record_id, @matches);
1518 sub SetImportRecordMatches {
1519 my $import_record_id = shift;
1522 my $dbh = C4::Context->dbh;
1523 my $delsth = $dbh->prepare("DELETE FROM import_record_matches WHERE import_record_id = ?");
1524 $delsth->execute($import_record_id);
1527 my $sth = $dbh->prepare("INSERT INTO import_record_matches (import_record_id, candidate_match_id, score, chosen)
1528 VALUES (?, ?, ?, ?)");
1529 my $chosen = 1; #The first match is defaulted to be chosen
1530 foreach my $match (@matches) {
1531 $sth->execute($import_record_id, $match->{'record_id'}, $match->{'score'}, $chosen);
1532 $chosen = 0; #After the first we do not default to other matches
1536 =head2 RecordsFromISO2709File
1538 my ($errors, $records) = C4::ImportBatch::RecordsFromISO2709File($input_file, $record_type, $encoding);
1540 Reads ISO2709 binary porridge from the given file and creates MARC::Record-objects out of it.
1542 @PARAM1, String, absolute path to the ISO2709 file.
1543 @PARAM2, String, see stage_file.pl
1544 @PARAM3, String, should be utf8
1546 Returns two array refs.
1550 sub RecordsFromISO2709File {
1551 my ($input_file, $record_type, $encoding) = @_;
1554 my $marc_type = C4::Context->preference('marcflavour');
1555 $marc_type .= 'AUTH' if ($marc_type eq 'UNIMARC' && $record_type eq 'auth');
1557 open my $fh, '<', $input_file or die "$0: cannot open input file $input_file: $!\n";
1563 next unless $_; # skip if record has only whitespace, as might occur
1564 # if file includes newlines between each MARC record
1565 my ($marc_record, $charset_guessed, $char_errors) = MarcToUTF8Record($_, $marc_type, $encoding);
1566 push @marc_records, $marc_record;
1567 if ($charset_guessed ne $encoding) {
1569 "Unexpected charset $charset_guessed, expecting $encoding";
1573 return ( \@errors, \@marc_records );
1576 =head2 RecordsFromMARCXMLFile
1578 my ($errors, $records) = C4::ImportBatch::RecordsFromMARCXMLFile($input_file, $encoding);
1580 Creates MARC::Record-objects out of the given MARCXML-file.
1582 @PARAM1, String, absolute path to the ISO2709 file.
1583 @PARAM2, String, should be utf8
1585 Returns two array refs.
1589 sub RecordsFromMARCXMLFile {
1590 my ( $filename, $encoding ) = @_;
1591 my $batch = MARC::File::XML->in( $filename );
1592 my ( @marcRecords, @errors, $record );
1594 eval { $record = $batch->next( $encoding ); };
1598 push @marcRecords, $record if $record;
1600 return (\@errors, \@marcRecords);
1603 =head2 RecordsFromMarcPlugin
1605 Converts text of input_file into array of MARC records with to_marc plugin
1609 sub RecordsFromMarcPlugin {
1610 my ($input_file, $plugin_class, $encoding) = @_;
1611 my ( $text, @return );
1612 return \@return if !$input_file || !$plugin_class;
1615 open my $fh, '<', $input_file or die "$0: cannot open input file $input_file: $!\n";
1625 # Convert to large MARC blob with plugin
1626 $text = Koha::Plugins::Handler->run({
1627 class => $plugin_class,
1628 method => 'to_marc',
1629 params => { data => $text },
1632 # Convert to array of MARC records
1634 my $marc_type = C4::Context->preference('marcflavour');
1635 foreach my $blob ( split(/\x1D/, $text) ) {
1636 next if $blob =~ /^\s*$/;
1637 my ($marcrecord) = MarcToUTF8Record($blob, $marc_type, $encoding);
1638 push @return, $marcrecord;
1644 # internal functions
1646 sub _create_import_record {
1647 my ($batch_id, $record_sequence, $marc_record, $record_type, $encoding, $marc_type) = @_;
1649 my $dbh = C4::Context->dbh;
1650 my $sth = $dbh->prepare("INSERT INTO import_records (import_batch_id, record_sequence, marc, marcxml, marcxml_old,
1651 record_type, encoding)
1652 VALUES (?, ?, ?, ?, ?, ?, ?)");
1653 $sth->execute($batch_id, $record_sequence, $marc_record->as_usmarc(), $marc_record->as_xml($marc_type), '',
1654 $record_type, $encoding);
1655 my $import_record_id = $dbh->{'mysql_insertid'};
1657 return $import_record_id;
1660 sub _update_import_record_marc {
1661 my ($import_record_id, $marc_record, $marc_type) = @_;
1663 my $dbh = C4::Context->dbh;
1664 my $sth = $dbh->prepare("UPDATE import_records SET marc = ?, marcxml = ?
1665 WHERE import_record_id = ?");
1666 $sth->execute($marc_record->as_usmarc(), $marc_record->as_xml($marc_type), $import_record_id);
1670 sub _add_auth_fields {
1671 my ($import_record_id, $marc_record) = @_;
1674 if ($marc_record->field('001')) {
1675 $controlnumber = $marc_record->field('001')->data();
1677 my $authorized_heading = C4::AuthoritiesMarc::GetAuthorizedHeading({ record => $marc_record });
1678 my $dbh = C4::Context->dbh;
1679 my $sth = $dbh->prepare("INSERT INTO import_auths (import_record_id, control_number, authorized_heading) VALUES (?, ?, ?)");
1680 $sth->execute($import_record_id, $controlnumber, $authorized_heading);
1684 sub _add_biblio_fields {
1685 my ($import_record_id, $marc_record) = @_;
1687 my ($title, $author, $isbn, $issn) = _parse_biblio_fields($marc_record);
1688 my $dbh = C4::Context->dbh;
1689 # FIXME no controlnumber, originalsource
1690 $isbn = C4::Koha::GetNormalizedISBN($isbn);
1691 my $sth = $dbh->prepare("INSERT INTO import_biblios (import_record_id, title, author, isbn, issn) VALUES (?, ?, ?, ?, ?)");
1692 $sth->execute($import_record_id, $title, $author, $isbn, $issn) or die $sth->errstr;
1697 sub _update_biblio_fields {
1698 my ($import_record_id, $marc_record) = @_;
1700 my ($title, $author, $isbn, $issn) = _parse_biblio_fields($marc_record);
1701 my $dbh = C4::Context->dbh;
1702 # FIXME no controlnumber, originalsource
1703 # FIXME 2 - should regularize normalization of ISBN wherever it is done
1707 my $sth = $dbh->prepare("UPDATE import_biblios SET title = ?, author = ?, isbn = ?, issn = ?
1708 WHERE import_record_id = ?");
1709 $sth->execute($title, $author, $isbn, $issn, $import_record_id);
1713 sub _parse_biblio_fields {
1714 my ($marc_record) = @_;
1716 my $dbh = C4::Context->dbh;
1717 my $bibliofields = TransformMarcToKoha({ record => $marc_record, kohafields => ['biblio.title','biblio.author','biblioitems.isbn','biblioitems.issn'] });
1718 return ($bibliofields->{'title'}, $bibliofields->{'author'}, $bibliofields->{'isbn'}, $bibliofields->{'issn'});
1722 sub _update_batch_record_counts {
1723 my ($batch_id) = @_;
1725 my $dbh = C4::Context->dbh;
1726 my $sth = $dbh->prepare_cached("UPDATE import_batches SET
1730 WHERE import_batch_id = import_batches.import_batch_id),
1734 JOIN import_items USING (import_record_id)
1735 WHERE import_batch_id = import_batches.import_batch_id
1736 AND record_type = 'biblio')
1737 WHERE import_batch_id = ?");
1738 $sth->bind_param(1, $batch_id);
1743 sub _get_commit_action {
1744 my ($overlay_action, $nomatch_action, $item_action, $overlay_status, $import_record_id, $record_type) = @_;
1746 if ($record_type eq 'biblio') {
1747 my ($bib_result, $bib_match, $item_result);
1749 $bib_match = GetBestRecordMatch($import_record_id);
1750 if ($overlay_status ne 'no_match' && defined($bib_match)) {
1752 $bib_result = $overlay_action;
1754 if($item_action eq 'always_add' or $item_action eq 'add_only_for_matches'){
1755 $item_result = 'create_new';
1756 } elsif($item_action eq 'replace'){
1757 $item_result = 'replace';
1759 $item_result = 'ignore';
1763 $bib_result = $nomatch_action;
1764 $item_result = ($item_action eq 'always_add' or $item_action eq 'add_only_for_new') ? 'create_new' : 'ignore';
1766 return ($bib_result, $item_result, $bib_match);
1767 } else { # must be auths
1768 my ($auth_result, $auth_match);
1770 $auth_match = GetBestRecordMatch($import_record_id);
1771 if ($overlay_status ne 'no_match' && defined($auth_match)) {
1772 $auth_result = $overlay_action;
1774 $auth_result = $nomatch_action;
1777 return ($auth_result, undef, $auth_match);
1782 sub _get_revert_action {
1783 my ($overlay_action, $overlay_status, $status) = @_;
1787 if ($status eq 'ignored') {
1788 $bib_result = 'ignore';
1790 if ($overlay_action eq 'create_new') {
1791 $bib_result = 'delete';
1793 $bib_result = ($overlay_status eq 'match_applied') ? 'restore' : 'delete';
1804 Koha Development Team <http://koha-community.org/>
1806 Galen Charlton <galen.charlton@liblime.com>