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::Plugins::Handler;
41 our (@ISA, @EXPORT_OK);
49 GetImportRecordMarcXML
50 GetRecordFromImportBiblio
55 AddItemsToImportBiblio
67 GetStagedWebserviceBatches
68 GetImportBatchRangeDesc
69 GetNumberOfNonZ3950ImportBatches
72 GetItemNumbersFromImportBatch
76 GetImportBatchOverlayAction
77 SetImportBatchOverlayAction
78 GetImportBatchNoMatchAction
79 SetImportBatchNoMatchAction
80 GetImportBatchItemAction
81 SetImportBatchItemAction
84 GetImportRecordOverlayStatus
85 SetImportRecordOverlayStatus
88 SetMatchedBiblionumber
89 GetImportRecordMatches
90 SetImportRecordMatches
92 RecordsFromMARCXMLFile
93 RecordsFromISO2709File
100 C4::ImportBatch - manage batches of imported MARC records
108 =head2 GetZ3950BatchId
110 my $batchid = GetZ3950BatchId($z3950server);
112 Retrieves the ID of the import batch for the Z39.50
113 reservoir for the given target. If necessary,
114 creates the import batch.
118 sub GetZ3950BatchId {
119 my ($z3950server) = @_;
121 my $dbh = C4::Context->dbh;
122 my $sth = $dbh->prepare("SELECT import_batch_id FROM import_batches
123 WHERE batch_type = 'z3950'
125 $sth->execute($z3950server);
126 my $rowref = $sth->fetchrow_arrayref();
128 if (defined $rowref) {
131 my $batch_id = AddImportBatch( {
132 overlay_action => 'create_new',
133 import_status => 'staged',
134 batch_type => 'z3950',
135 file_name => $z3950server,
142 =head2 GetWebserviceBatchId
144 my $batchid = GetWebserviceBatchId();
146 Retrieves the ID of the import batch for webservice.
147 If necessary, creates the import batch.
151 my $WEBSERVICE_BASE_QRY = <<EOQ;
152 SELECT import_batch_id FROM import_batches
153 WHERE batch_type = 'webservice'
154 AND import_status = 'staged'
156 sub GetWebserviceBatchId {
159 my $dbh = C4::Context->dbh;
160 my $sql = $WEBSERVICE_BASE_QRY;
162 foreach my $field (qw(matcher_id overlay_action nomatch_action item_action)) {
163 if (my $val = $params->{$field}) {
164 $sql .= " AND $field = ?";
168 my $id = $dbh->selectrow_array($sql, undef, @args);
171 $params->{batch_type} = 'webservice';
172 $params->{import_status} = 'staged';
173 return AddImportBatch($params);
176 =head2 GetImportRecordMarc
178 my ($marcblob, $encoding) = GetImportRecordMarc($import_record_id);
182 sub GetImportRecordMarc {
183 my ($import_record_id) = @_;
185 my $dbh = C4::Context->dbh;
186 my ( $marc, $encoding ) = $dbh->selectrow_array(q|
187 SELECT marc, encoding
189 WHERE import_record_id = ?
190 |, undef, $import_record_id );
192 return $marc, $encoding;
195 sub GetRecordFromImportBiblio {
196 my ( $import_record_id, $embed_items ) = @_;
198 my ($marc) = GetImportRecordMarc($import_record_id);
199 my $record = MARC::Record->new_from_usmarc($marc);
201 EmbedItemsInImportBiblio( $record, $import_record_id ) if $embed_items;
206 sub EmbedItemsInImportBiblio {
207 my ( $record, $import_record_id ) = @_;
208 my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField( "items.itemnumber" );
209 my $dbh = C4::Context->dbh;
210 my $import_items = $dbh->selectall_arrayref(q|
211 SELECT import_items.marcxml
213 WHERE import_record_id = ?
214 |, { Slice => {} }, $import_record_id );
216 for my $import_item ( @$import_items ) {
217 my $item_marc = MARC::Record::new_from_xml($import_item->{marcxml}, 'UTF-8');
218 push @item_fields, $item_marc->field($itemtag);
220 $record->append_fields(@item_fields);
224 =head2 GetImportRecordMarcXML
226 my $marcxml = GetImportRecordMarcXML($import_record_id);
230 sub GetImportRecordMarcXML {
231 my ($import_record_id) = @_;
233 my $dbh = C4::Context->dbh;
234 my $sth = $dbh->prepare("SELECT marcxml FROM import_records WHERE import_record_id = ?");
235 $sth->execute($import_record_id);
236 my ($marcxml) = $sth->fetchrow();
242 =head2 AddImportBatch
244 my $batch_id = AddImportBatch($params_hash);
252 foreach (qw( matcher_id template_id branchcode
253 overlay_action nomatch_action item_action
254 import_status batch_type file_name comments record_type )) {
255 if (exists $params->{$_}) {
257 push @vals, $params->{$_};
260 my $dbh = C4::Context->dbh;
261 $dbh->do("INSERT INTO import_batches (".join( ',', @fields).")
262 VALUES (".join( ',', map '?', @fields).")",
265 return $dbh->{'mysql_insertid'};
268 =head2 GetImportBatch
270 my $row = GetImportBatch($batch_id);
272 Retrieve a hashref of an import_batches row.
279 my $dbh = C4::Context->dbh;
280 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 = ?");
281 $sth->bind_param(1, $batch_id);
283 my $result = $sth->fetchrow_hashref;
289 =head2 AddBiblioToBatch
291 my $import_record_id = AddBiblioToBatch($batch_id, $record_sequence,
292 $marc_record, $encoding, $update_counts);
296 sub AddBiblioToBatch {
297 my $batch_id = shift;
298 my $record_sequence = shift;
299 my $marc_record = shift;
300 my $encoding = shift;
301 my $update_counts = @_ ? shift : 1;
303 my $import_record_id = _create_import_record($batch_id, $record_sequence, $marc_record, 'biblio', $encoding, C4::Context->preference('marcflavour'));
304 _add_biblio_fields($import_record_id, $marc_record);
305 _update_batch_record_counts($batch_id) if $update_counts;
306 return $import_record_id;
309 =head2 ModBiblioInBatch
311 ModBiblioInBatch($import_record_id, $marc_record);
315 sub ModBiblioInBatch {
316 my ($import_record_id, $marc_record) = @_;
318 _update_import_record_marc($import_record_id, $marc_record, C4::Context->preference('marcflavour'));
319 _update_biblio_fields($import_record_id, $marc_record);
323 =head2 AddAuthToBatch
325 my $import_record_id = AddAuthToBatch($batch_id, $record_sequence,
326 $marc_record, $encoding, $update_counts, [$marc_type]);
331 my $batch_id = shift;
332 my $record_sequence = shift;
333 my $marc_record = shift;
334 my $encoding = shift;
335 my $update_counts = @_ ? shift : 1;
336 my $marc_type = shift || C4::Context->preference('marcflavour');
338 $marc_type = 'UNIMARCAUTH' if $marc_type eq 'UNIMARC';
340 my $import_record_id = _create_import_record($batch_id, $record_sequence, $marc_record, 'auth', $encoding, $marc_type);
341 _add_auth_fields($import_record_id, $marc_record);
342 _update_batch_record_counts($batch_id) if $update_counts;
343 return $import_record_id;
346 =head2 ModAuthInBatch
348 ModAuthInBatch($import_record_id, $marc_record);
353 my ($import_record_id, $marc_record) = @_;
355 my $marcflavour = C4::Context->preference('marcflavour');
356 _update_import_record_marc($import_record_id, $marc_record, $marcflavour eq 'UNIMARC' ? 'UNIMARCAUTH' : 'USMARC');
360 =head2 BatchStageMarcRecords
362 ( $batch_id, $num_records, $num_items, @invalid_records ) =
363 BatchStageMarcRecords(
364 $record_type, $encoding,
365 $marc_records, $file_name,
366 $marc_modification_template, $comments,
367 $branch_code, $parse_items,
368 $leave_as_staging, $progress_interval,
374 sub BatchStageMarcRecords {
375 my $record_type = shift;
376 my $encoding = shift;
377 my $marc_records = shift;
378 my $file_name = shift;
379 my $marc_modification_template = shift;
380 my $comments = shift;
381 my $branch_code = shift;
382 my $parse_items = shift;
383 my $leave_as_staging = shift;
385 # optional callback to monitor status
387 my $progress_interval = 0;
388 my $progress_callback = undef;
390 $progress_interval = shift;
391 $progress_callback = shift;
392 $progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
393 $progress_interval = 0 unless 'CODE' eq ref $progress_callback;
396 my $batch_id = AddImportBatch( {
397 overlay_action => 'create_new',
398 import_status => 'staging',
399 batch_type => 'batch',
400 file_name => $file_name,
401 comments => $comments,
402 record_type => $record_type,
405 SetImportBatchItemAction($batch_id, 'always_add');
407 SetImportBatchItemAction($batch_id, 'ignore');
411 my $marc_type = C4::Context->preference('marcflavour');
412 $marc_type .= 'AUTH' if ($marc_type eq 'UNIMARC' && $record_type eq 'auth');
413 my @invalid_records = ();
416 # FIXME - for now, we're dealing only with bibs
418 foreach my $marc_record (@$marc_records) {
420 if ($progress_interval and (0 == ($rec_num % $progress_interval))) {
421 &$progress_callback($rec_num);
424 ModifyRecordWithTemplate( $marc_modification_template, $marc_record ) if ( $marc_modification_template );
426 my $import_record_id;
427 if (scalar($marc_record->fields()) == 0) {
428 push @invalid_records, $marc_record;
431 # Normalize the record so it doesn't have separated diacritics
432 SetUTF8Flag($marc_record);
435 if ($record_type eq 'biblio') {
436 $import_record_id = AddBiblioToBatch($batch_id, $rec_num, $marc_record, $encoding, int(rand(99999)), 0);
438 my @import_items_ids = AddItemsToImportBiblio($batch_id, $import_record_id, $marc_record, 0);
439 $num_items += scalar(@import_items_ids);
441 } elsif ($record_type eq 'auth') {
442 $import_record_id = AddAuthToBatch($batch_id, $rec_num, $marc_record, $encoding, int(rand(99999)), 0, $marc_type);
446 unless ($leave_as_staging) {
447 SetImportBatchStatus($batch_id, 'staged');
449 # FIXME branch_code, number of bibs, number of items
450 _update_batch_record_counts($batch_id);
451 return ($batch_id, $num_valid, $num_items, @invalid_records);
454 =head2 AddItemsToImportBiblio
456 my @import_items_ids = AddItemsToImportBiblio($batch_id,
457 $import_record_id, $marc_record, $update_counts);
461 sub AddItemsToImportBiblio {
462 my $batch_id = shift;
463 my $import_record_id = shift;
464 my $marc_record = shift;
465 my $update_counts = @_ ? shift : 0;
467 my @import_items_ids = ();
469 my $dbh = C4::Context->dbh;
470 my ($item_tag,$item_subfield) = &GetMarcFromKohaField( "items.itemnumber" );
471 foreach my $item_field ($marc_record->field($item_tag)) {
472 my $item_marc = MARC::Record->new();
473 $item_marc->leader("00000 a "); # must set Leader/09 to 'a'
474 $item_marc->append_fields($item_field);
475 $marc_record->delete_field($item_field);
476 my $sth = $dbh->prepare_cached("INSERT INTO import_items (import_record_id, status, marcxml)
478 $sth->bind_param(1, $import_record_id);
479 $sth->bind_param(2, 'staged');
480 $sth->bind_param(3, $item_marc->as_xml("USMARC"));
482 push @import_items_ids, $dbh->{'mysql_insertid'};
486 if ($#import_items_ids > -1) {
487 _update_batch_record_counts($batch_id) if $update_counts;
488 _update_import_record_marc($import_record_id, $marc_record, C4::Context->preference('marcflavour'));
490 return @import_items_ids;
493 =head2 BatchFindDuplicates
495 my $num_with_matches = BatchFindDuplicates($batch_id, $matcher,
496 $max_matches, $progress_interval, $progress_callback);
498 Goes through the records loaded in the batch and attempts to
499 find duplicates for each one. Sets the matching status
500 of each record to "no_match" or "auto_match" as appropriate.
502 The $max_matches parameter is optional; if it is not supplied,
505 The $progress_interval and $progress_callback parameters are
506 optional; if both are supplied, the sub referred to by
507 $progress_callback will be invoked every $progress_interval
508 records using the number of records processed as the
513 sub BatchFindDuplicates {
514 my $batch_id = shift;
516 my $max_matches = @_ ? shift : 10;
518 # optional callback to monitor status
520 my $progress_interval = 0;
521 my $progress_callback = undef;
523 $progress_interval = shift;
524 $progress_callback = shift;
525 $progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
526 $progress_interval = 0 unless 'CODE' eq ref $progress_callback;
529 my $dbh = C4::Context->dbh;
531 my $sth = $dbh->prepare("SELECT import_record_id, record_type, marc
533 WHERE import_batch_id = ?");
534 $sth->execute($batch_id);
535 my $num_with_matches = 0;
537 while (my $rowref = $sth->fetchrow_hashref) {
539 if ($progress_interval and (0 == ($rec_num % $progress_interval))) {
540 &$progress_callback($rec_num);
542 my $marc_record = MARC::Record->new_from_usmarc($rowref->{'marc'});
544 if (defined $matcher) {
545 @matches = $matcher->get_matches($marc_record, $max_matches);
547 if (scalar(@matches) > 0) {
549 SetImportRecordMatches($rowref->{'import_record_id'}, @matches);
550 SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'auto_match');
552 SetImportRecordMatches($rowref->{'import_record_id'}, ());
553 SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'no_match');
557 return $num_with_matches;
560 =head2 BatchCommitRecords
562 my ($num_added, $num_updated, $num_items_added, $num_items_replaced, $num_items_errored, $num_ignored) =
563 BatchCommitRecords($batch_id, $framework,
564 $progress_interval, $progress_callback);
568 sub BatchCommitRecords {
569 my $batch_id = shift;
570 my $framework = shift;
572 # optional callback to monitor status
574 my $progress_interval = 0;
575 my $progress_callback = undef;
577 $progress_interval = shift;
578 $progress_callback = shift;
579 $progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
580 $progress_interval = 0 unless 'CODE' eq ref $progress_callback;
586 my $num_items_added = 0;
587 my $num_items_replaced = 0;
588 my $num_items_errored = 0;
590 # commit (i.e., save, all records in the batch)
591 SetImportBatchStatus($batch_id, 'importing');
592 my $overlay_action = GetImportBatchOverlayAction($batch_id);
593 my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
594 my $item_action = GetImportBatchItemAction($batch_id);
597 my $dbh = C4::Context->dbh;
598 my $sth = $dbh->prepare("SELECT import_records.import_record_id, record_type, status, overlay_status, marc, encoding
600 LEFT JOIN import_auths ON (import_records.import_record_id=import_auths.import_record_id)
601 LEFT JOIN import_biblios ON (import_records.import_record_id=import_biblios.import_record_id)
602 WHERE import_batch_id = ?");
603 $sth->execute($batch_id);
604 my $marcflavour = C4::Context->preference('marcflavour');
606 my $userenv = C4::Context->userenv;
607 my $logged_in_patron = Koha::Patrons->find( $userenv->{number} );
610 while (my $rowref = $sth->fetchrow_hashref) {
611 $record_type = $rowref->{'record_type'};
613 if ($progress_interval and (0 == ($rec_num % $progress_interval))) {
614 &$progress_callback($rec_num);
616 if ($rowref->{'status'} eq 'error' or $rowref->{'status'} eq 'imported') {
622 if ($marcflavour eq 'UNIMARC' && $record_type eq 'auth') {
623 $marc_type = 'UNIMARCAUTH';
624 } elsif ($marcflavour eq 'UNIMARC') {
625 $marc_type = 'UNIMARC';
627 $marc_type = 'USMARC';
629 my $marc_record = MARC::Record->new_from_usmarc($rowref->{'marc'});
631 if ($record_type eq 'biblio') {
632 # remove any item tags - rely on BatchCommitItems
633 ($item_tag,$item_subfield) = &GetMarcFromKohaField( "items.itemnumber" );
634 foreach my $item_field ($marc_record->field($item_tag)) {
635 $marc_record->delete_field($item_field);
639 my ($record_result, $item_result, $record_match) =
640 _get_commit_action($overlay_action, $nomatch_action, $item_action,
641 $rowref->{'overlay_status'}, $rowref->{'import_record_id'}, $record_type);
645 if ($record_result eq 'create_new') {
647 if ($record_type eq 'biblio') {
648 my $biblioitemnumber;
649 ($recordid, $biblioitemnumber) = AddBiblio($marc_record, $framework);
650 $query = "UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?"; # FIXME call SetMatchedBiblionumber instead
651 if ($item_result eq 'create_new' || $item_result eq 'replace') {
652 my ($bib_items_added, $bib_items_replaced, $bib_items_errored) = BatchCommitItems($rowref->{'import_record_id'}, $recordid, $item_result);
653 $num_items_added += $bib_items_added;
654 $num_items_replaced += $bib_items_replaced;
655 $num_items_errored += $bib_items_errored;
658 $recordid = AddAuthority($marc_record, undef, GuessAuthTypeCode($marc_record));
659 $query = "UPDATE import_auths SET matched_authid = ? WHERE import_record_id = ?";
661 my $sth = $dbh->prepare_cached($query);
662 $sth->execute($recordid, $rowref->{'import_record_id'});
664 SetImportRecordStatus($rowref->{'import_record_id'}, 'imported');
665 } elsif ($record_result eq 'replace') {
667 $recordid = $record_match;
669 if ($record_type eq 'biblio') {
670 my $oldbiblio = Koha::Biblios->find( $recordid );
671 $oldxml = GetXmlBiblio($recordid);
673 # remove item fields so that they don't get
674 # added again if record is reverted
675 # 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.
676 my $old_marc = MARC::Record->new_from_xml(StripNonXmlChars($oldxml), 'UTF-8', $rowref->{'encoding'}, $marc_type);
677 foreach my $item_field ($old_marc->field($item_tag)) {
678 $old_marc->delete_field($item_field);
680 $oldxml = $old_marc->as_xml($marc_type);
682 ModBiblio($marc_record, $recordid, $oldbiblio->frameworkcode, {
684 source => 'batchimport',
685 categorycode => $logged_in_patron->categorycode,
686 userid => $logged_in_patron->userid
689 $query = "UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?"; # FIXME call SetMatchedBiblionumber instead
691 if ($item_result eq 'create_new' || $item_result eq 'replace') {
692 my ($bib_items_added, $bib_items_replaced, $bib_items_errored) = BatchCommitItems($rowref->{'import_record_id'}, $recordid, $item_result);
693 $num_items_added += $bib_items_added;
694 $num_items_replaced += $bib_items_replaced;
695 $num_items_errored += $bib_items_errored;
698 $oldxml = GetAuthorityXML($recordid);
700 ModAuthority($recordid, $marc_record, GuessAuthTypeCode($marc_record));
701 $query = "UPDATE import_auths SET matched_authid = ? WHERE import_record_id = ?";
703 my $sth = $dbh->prepare_cached("UPDATE import_records SET marcxml_old = ? WHERE import_record_id = ?");
704 $sth->execute($oldxml, $rowref->{'import_record_id'});
706 my $sth2 = $dbh->prepare_cached($query);
707 $sth2->execute($recordid, $rowref->{'import_record_id'});
709 SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'match_applied');
710 SetImportRecordStatus($rowref->{'import_record_id'}, 'imported');
711 } elsif ($record_result eq 'ignore') {
712 $recordid = $record_match;
714 $recordid = $record_match;
715 if ($record_type eq 'biblio' and defined $recordid and ( $item_result eq 'create_new' || $item_result eq 'replace' ) ) {
716 my ($bib_items_added, $bib_items_replaced, $bib_items_errored) = BatchCommitItems($rowref->{'import_record_id'}, $recordid, $item_result);
717 $num_items_added += $bib_items_added;
718 $num_items_replaced += $bib_items_replaced;
719 $num_items_errored += $bib_items_errored;
720 # still need to record the matched biblionumber so that the
721 # items can be reverted
722 my $sth2 = $dbh->prepare_cached("UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?"); # FIXME call SetMatchedBiblionumber instead
723 $sth2->execute($recordid, $rowref->{'import_record_id'});
724 SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'match_applied');
726 SetImportRecordStatus($rowref->{'import_record_id'}, 'ignored');
730 SetImportBatchStatus($batch_id, 'imported');
731 return ($num_added, $num_updated, $num_items_added, $num_items_replaced, $num_items_errored, $num_ignored);
734 =head2 BatchCommitItems
736 ($num_items_added, $num_items_errored) =
737 BatchCommitItems($import_record_id, $biblionumber);
741 sub BatchCommitItems {
742 my ( $import_record_id, $biblionumber, $action ) = @_;
744 my $dbh = C4::Context->dbh;
746 my $num_items_added = 0;
747 my $num_items_errored = 0;
748 my $num_items_replaced = 0;
750 my $sth = $dbh->prepare( "
751 SELECT import_items_id, import_items.marcxml, encoding
753 JOIN import_records USING (import_record_id)
754 WHERE import_record_id = ?
755 ORDER BY import_items_id
757 $sth->bind_param( 1, $import_record_id );
760 while ( my $row = $sth->fetchrow_hashref() ) {
761 my $item_marc = MARC::Record->new_from_xml( StripNonXmlChars( $row->{'marcxml'} ), 'UTF-8', $row->{'encoding'} );
763 # Delete date_due subfield as to not accidentally delete item checkout due dates
764 my ( $MARCfield, $MARCsubfield ) = GetMarcFromKohaField( 'items.onloan' );
765 $item_marc->field($MARCfield)->delete_subfield( code => $MARCsubfield );
767 my $item = TransformMarcToKoha( $item_marc );
769 my $duplicate_barcode = exists( $item->{'barcode'} ) && Koha::Items->find({ barcode => $item->{'barcode'} });
770 my $duplicate_itemnumber = exists( $item->{'itemnumber'} );
772 my $updsth = $dbh->prepare("UPDATE import_items SET status = ?, itemnumber = ? WHERE import_items_id = ?");
773 if ( $action eq "replace" && $duplicate_itemnumber ) {
774 # Duplicate itemnumbers have precedence, that way we can update barcodes by overlaying
775 ModItemFromMarc( $item_marc, $biblionumber, $item->{itemnumber} );
776 $updsth->bind_param( 1, 'imported' );
777 $updsth->bind_param( 2, $item->{itemnumber} );
778 $updsth->bind_param( 3, $row->{'import_items_id'} );
781 $num_items_replaced++;
782 } elsif ( $action eq "replace" && $duplicate_barcode ) {
783 my $itemnumber = $duplicate_barcode->itemnumber;
784 ModItemFromMarc( $item_marc, $biblionumber, $itemnumber );
785 $updsth->bind_param( 1, 'imported' );
786 $updsth->bind_param( 2, $item->{itemnumber} );
787 $updsth->bind_param( 3, $row->{'import_items_id'} );
790 $num_items_replaced++;
791 } elsif ($duplicate_barcode) {
792 $updsth->bind_param( 1, 'error' );
793 $updsth->bind_param( 2, 'duplicate item barcode' );
794 $updsth->bind_param( 3, $row->{'import_items_id'} );
796 $num_items_errored++;
798 # Remove the itemnumber if it exists, we want to create a new item
799 my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField( "items.itemnumber" );
800 $item_marc->field($itemtag)->delete_subfield( code => $itemsubfield );
802 my ( $item_biblionumber, $biblioitemnumber, $itemnumber ) = AddItemFromMarc( $item_marc, $biblionumber );
804 $updsth->bind_param( 1, 'imported' );
805 $updsth->bind_param( 2, $itemnumber );
806 $updsth->bind_param( 3, $row->{'import_items_id'} );
814 return ( $num_items_added, $num_items_replaced, $num_items_errored );
817 =head2 BatchRevertRecords
819 my ($num_deleted, $num_errors, $num_reverted, $num_items_deleted,
820 $num_ignored) = BatchRevertRecords($batch_id);
824 sub BatchRevertRecords {
825 my $batch_id = shift;
827 my $logger = Koha::Logger->get( { category => 'C4.ImportBatch' } );
829 $logger->trace("C4::ImportBatch::BatchRevertRecords( $batch_id )");
834 my $num_reverted = 0;
836 my $num_items_deleted = 0;
837 # commit (i.e., save, all records in the batch)
838 SetImportBatchStatus($batch_id, 'reverting');
839 my $overlay_action = GetImportBatchOverlayAction($batch_id);
840 my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
841 my $dbh = C4::Context->dbh;
842 my $sth = $dbh->prepare("SELECT import_records.import_record_id, record_type, status, overlay_status, marcxml_old, encoding, matched_biblionumber, matched_authid
844 LEFT JOIN import_auths ON (import_records.import_record_id=import_auths.import_record_id)
845 LEFT JOIN import_biblios ON (import_records.import_record_id=import_biblios.import_record_id)
846 WHERE import_batch_id = ?");
847 $sth->execute($batch_id);
849 my $marcflavour = C4::Context->preference('marcflavour');
850 while (my $rowref = $sth->fetchrow_hashref) {
851 $record_type = $rowref->{'record_type'};
852 if ($rowref->{'status'} eq 'error' or $rowref->{'status'} eq 'reverted') {
856 if ($marcflavour eq 'UNIMARC' && $record_type eq 'auth') {
857 $marc_type = 'UNIMARCAUTH';
858 } elsif ($marcflavour eq 'UNIMARC') {
859 $marc_type = 'UNIMARC';
861 $marc_type = 'USMARC';
864 my $record_result = _get_revert_action($overlay_action, $rowref->{'overlay_status'}, $rowref->{'status'});
866 if ($record_result eq 'delete') {
868 if ($record_type eq 'biblio') {
869 $num_items_deleted += BatchRevertItems($rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'});
870 $error = DelBiblio($rowref->{'matched_biblionumber'});
872 DelAuthority({ authid => $rowref->{'matched_authid'} });
874 if (defined $error) {
878 SetImportRecordStatus($rowref->{'import_record_id'}, 'reverted');
880 } elsif ($record_result eq 'restore') {
882 my $old_record = MARC::Record->new_from_xml(StripNonXmlChars($rowref->{'marcxml_old'}), 'UTF-8', $rowref->{'encoding'}, $marc_type);
883 if ($record_type eq 'biblio') {
884 my $biblionumber = $rowref->{'matched_biblionumber'};
885 my $oldbiblio = Koha::Biblios->find( $biblionumber );
887 $logger->info("C4::ImportBatch::BatchRevertRecords: Biblio record $biblionumber does not exist, restoration of this record was skipped") unless $oldbiblio;
888 next unless $oldbiblio; # Record has since been deleted. Deleted records should stay deleted.
890 $num_items_deleted += BatchRevertItems($rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'});
891 ModBiblio($old_record, $biblionumber, $oldbiblio->frameworkcode);
893 my $authid = $rowref->{'matched_authid'};
894 ModAuthority($authid, $old_record, GuessAuthTypeCode($old_record));
896 SetImportRecordStatus($rowref->{'import_record_id'}, 'reverted');
897 } elsif ($record_result eq 'ignore') {
898 if ($record_type eq 'biblio') {
899 $num_items_deleted += BatchRevertItems($rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'});
901 SetImportRecordStatus($rowref->{'import_record_id'}, 'reverted');
904 if ($record_type eq 'biblio') {
905 # remove matched_biblionumber only if there is no 'imported' item left
906 $query = "UPDATE import_biblios SET matched_biblionumber = NULL WHERE import_record_id = ?"; # FIXME Remove me
907 $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')";
909 $query = "UPDATE import_auths SET matched_authid = NULL WHERE import_record_id = ?";
911 my $sth2 = $dbh->prepare_cached($query);
912 $sth2->execute($rowref->{'import_record_id'});
916 SetImportBatchStatus($batch_id, 'reverted');
917 return ($num_deleted, $num_errors, $num_reverted, $num_items_deleted, $num_ignored);
920 =head2 BatchRevertItems
922 my $num_items_deleted = BatchRevertItems($import_record_id, $biblionumber);
926 sub BatchRevertItems {
927 my ($import_record_id, $biblionumber) = @_;
929 my $dbh = C4::Context->dbh;
930 my $num_items_deleted = 0;
932 my $sth = $dbh->prepare_cached("SELECT import_items_id, itemnumber
934 JOIN items USING (itemnumber)
935 WHERE import_record_id = ?");
936 $sth->bind_param(1, $import_record_id);
938 while (my $row = $sth->fetchrow_hashref()) {
939 my $item = Koha::Items->find($row->{itemnumber});
940 if ($item->safe_delete){
941 my $updsth = $dbh->prepare("UPDATE import_items SET status = ? WHERE import_items_id = ?");
942 $updsth->bind_param(1, 'reverted');
943 $updsth->bind_param(2, $row->{'import_items_id'});
946 $num_items_deleted++;
953 return $num_items_deleted;
958 CleanBatch($batch_id)
960 Deletes all staged records from the import batch
961 and sets the status of the batch to 'cleaned'. Note
962 that deleting a stage record does *not* affect
963 any record that has been committed to the database.
968 my $batch_id = shift;
969 return unless defined $batch_id;
971 C4::Context->dbh->do('DELETE FROM import_records WHERE import_batch_id = ?', {}, $batch_id);
972 SetImportBatchStatus($batch_id, 'cleaned');
977 DeleteBatch($batch_id)
979 Deletes the record from the database. This can only be done
980 once the batch has been cleaned.
985 my $batch_id = shift;
986 return unless defined $batch_id;
988 my $dbh = C4::Context->dbh;
989 my $sth = $dbh->prepare('DELETE FROM import_batches WHERE import_batch_id = ?');
990 $sth->execute( $batch_id );
993 =head2 GetAllImportBatches
995 my $results = GetAllImportBatches();
997 Returns a references to an array of hash references corresponding
998 to all import_batches rows (of batch_type 'batch'), sorted in
999 ascending order by import_batch_id.
1003 sub GetAllImportBatches {
1004 my $dbh = C4::Context->dbh;
1005 my $sth = $dbh->prepare_cached("SELECT * FROM import_batches
1006 WHERE batch_type IN ('batch', 'webservice')
1007 ORDER BY import_batch_id ASC");
1011 while (my $row = $sth->fetchrow_hashref) {
1012 push @$results, $row;
1018 =head2 GetStagedWebserviceBatches
1020 my $batch_ids = GetStagedWebserviceBatches();
1022 Returns a references to an array of batch id's
1023 of batch_type 'webservice' that are not imported
1027 my $PENDING_WEBSERVICE_BATCHES_QRY = <<EOQ;
1028 SELECT import_batch_id FROM import_batches
1029 WHERE batch_type = 'webservice'
1030 AND import_status = 'staged'
1032 sub GetStagedWebserviceBatches {
1033 my $dbh = C4::Context->dbh;
1034 return $dbh->selectcol_arrayref($PENDING_WEBSERVICE_BATCHES_QRY);
1037 =head2 GetImportBatchRangeDesc
1039 my $results = GetImportBatchRangeDesc($offset, $results_per_group);
1041 Returns a reference to an array of hash references corresponding to
1042 import_batches rows (sorted in descending order by import_batch_id)
1043 start at the given offset.
1047 sub GetImportBatchRangeDesc {
1048 my ($offset, $results_per_group) = @_;
1050 my $dbh = C4::Context->dbh;
1051 my $query = "SELECT b.*, p.name as profile FROM import_batches b
1052 LEFT JOIN import_batch_profiles p
1053 ON b.profile_id = p.id
1054 WHERE b.batch_type IN ('batch', 'webservice')
1055 ORDER BY b.import_batch_id DESC";
1057 if ($results_per_group){
1058 $query .= " LIMIT ?";
1059 push(@params, $results_per_group);
1062 $query .= " OFFSET ?";
1063 push(@params, $offset);
1065 my $sth = $dbh->prepare_cached($query);
1066 $sth->execute(@params);
1067 my $results = $sth->fetchall_arrayref({});
1072 =head2 GetItemNumbersFromImportBatch
1074 my @itemsnos = GetItemNumbersFromImportBatch($batch_id);
1078 sub GetItemNumbersFromImportBatch {
1079 my ($batch_id) = @_;
1080 my $dbh = C4::Context->dbh;
1082 SELECT itemnumber FROM import_items
1083 INNER JOIN items USING (itemnumber)
1084 INNER JOIN import_records USING (import_record_id)
1085 WHERE import_batch_id = ?|;
1086 my $sth = $dbh->prepare( $sql );
1087 $sth->execute($batch_id);
1089 while ( my ($itm) = $sth->fetchrow_array ) {
1095 =head2 GetNumberOfImportBatches
1097 my $count = GetNumberOfImportBatches();
1101 sub GetNumberOfNonZ3950ImportBatches {
1102 my $dbh = C4::Context->dbh;
1103 my $sth = $dbh->prepare("SELECT COUNT(*) FROM import_batches WHERE batch_type != 'z3950'");
1105 my ($count) = $sth->fetchrow_array();
1110 =head2 GetImportBiblios
1112 my $results = GetImportBiblios($importid);
1116 sub GetImportBiblios {
1117 my ($import_record_id) = @_;
1119 my $dbh = C4::Context->dbh;
1120 my $query = "SELECT * FROM import_biblios WHERE import_record_id = ?";
1121 return $dbh->selectall_arrayref(
1129 =head2 GetImportRecordsRange
1131 my $results = GetImportRecordsRange($batch_id, $offset, $results_per_group);
1133 Returns a reference to an array of hash references corresponding to
1134 import_biblios/import_auths/import_records rows for a given batch
1135 starting at the given offset.
1139 sub GetImportRecordsRange {
1140 my ( $batch_id, $offset, $results_per_group, $status, $parameters ) = @_;
1142 my $dbh = C4::Context->dbh;
1144 my $order_by = $parameters->{order_by} || 'import_record_id';
1145 ( $order_by ) = grep( { $_ eq $order_by } qw( import_record_id title status overlay_status ) ) ? $order_by : 'import_record_id';
1147 my $order_by_direction =
1148 uc( $parameters->{order_by_direction} // 'ASC' ) eq 'DESC' ? 'DESC' : 'ASC';
1150 $order_by .= " $order_by_direction, authorized_heading" if $order_by eq 'title';
1152 my $query = "SELECT title, author, isbn, issn, authorized_heading, import_records.import_record_id,
1153 record_sequence, status, overlay_status,
1154 matched_biblionumber, matched_authid, record_type
1156 LEFT JOIN import_auths ON (import_records.import_record_id=import_auths.import_record_id)
1157 LEFT JOIN import_biblios ON (import_records.import_record_id=import_biblios.import_record_id)
1158 WHERE import_batch_id = ?";
1160 push(@params, $batch_id);
1162 $query .= " AND status=?";
1163 push(@params,$status);
1166 $query.=" ORDER BY $order_by $order_by_direction";
1168 if($results_per_group){
1169 $query .= " LIMIT ?";
1170 push(@params, $results_per_group);
1173 $query .= " OFFSET ?";
1174 push(@params, $offset);
1176 my $sth = $dbh->prepare_cached($query);
1177 $sth->execute(@params);
1178 my $results = $sth->fetchall_arrayref({});
1184 =head2 GetBestRecordMatch
1186 my $record_id = GetBestRecordMatch($import_record_id);
1190 sub GetBestRecordMatch {
1191 my ($import_record_id) = @_;
1193 my $dbh = C4::Context->dbh;
1194 my $sth = $dbh->prepare("SELECT candidate_match_id
1195 FROM import_record_matches
1196 JOIN import_records ON ( import_record_matches.import_record_id = import_records.import_record_id )
1197 LEFT JOIN biblio ON ( candidate_match_id = biblio.biblionumber )
1198 LEFT JOIN auth_header ON ( candidate_match_id = auth_header.authid )
1199 WHERE import_record_matches.import_record_id = ? AND
1200 ( (import_records.record_type = 'biblio' AND biblio.biblionumber IS NOT NULL) OR
1201 (import_records.record_type = 'auth' AND auth_header.authid IS NOT NULL) )
1202 ORDER BY score DESC, candidate_match_id DESC");
1203 $sth->execute($import_record_id);
1204 my ($record_id) = $sth->fetchrow_array();
1209 =head2 GetImportBatchStatus
1211 my $status = GetImportBatchStatus($batch_id);
1215 sub GetImportBatchStatus {
1216 my ($batch_id) = @_;
1218 my $dbh = C4::Context->dbh;
1219 my $sth = $dbh->prepare("SELECT import_status FROM import_batches WHERE import_batch_id = ?");
1220 $sth->execute($batch_id);
1221 my ($status) = $sth->fetchrow_array();
1227 =head2 SetImportBatchStatus
1229 SetImportBatchStatus($batch_id, $new_status);
1233 sub SetImportBatchStatus {
1234 my ($batch_id, $new_status) = @_;
1236 my $dbh = C4::Context->dbh;
1237 my $sth = $dbh->prepare("UPDATE import_batches SET import_status = ? WHERE import_batch_id = ?");
1238 $sth->execute($new_status, $batch_id);
1243 =head2 SetMatchedBiblionumber
1245 SetMatchedBiblionumber($import_record_id, $biblionumber);
1249 sub SetMatchedBiblionumber {
1250 my ($import_record_id, $biblionumber) = @_;
1252 my $dbh = C4::Context->dbh;
1254 q|UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?|,
1255 undef, $biblionumber, $import_record_id
1259 =head2 GetImportBatchOverlayAction
1261 my $overlay_action = GetImportBatchOverlayAction($batch_id);
1265 sub GetImportBatchOverlayAction {
1266 my ($batch_id) = @_;
1268 my $dbh = C4::Context->dbh;
1269 my $sth = $dbh->prepare("SELECT overlay_action FROM import_batches WHERE import_batch_id = ?");
1270 $sth->execute($batch_id);
1271 my ($overlay_action) = $sth->fetchrow_array();
1273 return $overlay_action;
1278 =head2 SetImportBatchOverlayAction
1280 SetImportBatchOverlayAction($batch_id, $new_overlay_action);
1284 sub SetImportBatchOverlayAction {
1285 my ($batch_id, $new_overlay_action) = @_;
1287 my $dbh = C4::Context->dbh;
1288 my $sth = $dbh->prepare("UPDATE import_batches SET overlay_action = ? WHERE import_batch_id = ?");
1289 $sth->execute($new_overlay_action, $batch_id);
1294 =head2 GetImportBatchNoMatchAction
1296 my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
1300 sub GetImportBatchNoMatchAction {
1301 my ($batch_id) = @_;
1303 my $dbh = C4::Context->dbh;
1304 my $sth = $dbh->prepare("SELECT nomatch_action FROM import_batches WHERE import_batch_id = ?");
1305 $sth->execute($batch_id);
1306 my ($nomatch_action) = $sth->fetchrow_array();
1308 return $nomatch_action;
1313 =head2 SetImportBatchNoMatchAction
1315 SetImportBatchNoMatchAction($batch_id, $new_nomatch_action);
1319 sub SetImportBatchNoMatchAction {
1320 my ($batch_id, $new_nomatch_action) = @_;
1322 my $dbh = C4::Context->dbh;
1323 my $sth = $dbh->prepare("UPDATE import_batches SET nomatch_action = ? WHERE import_batch_id = ?");
1324 $sth->execute($new_nomatch_action, $batch_id);
1329 =head2 GetImportBatchItemAction
1331 my $item_action = GetImportBatchItemAction($batch_id);
1335 sub GetImportBatchItemAction {
1336 my ($batch_id) = @_;
1338 my $dbh = C4::Context->dbh;
1339 my $sth = $dbh->prepare("SELECT item_action FROM import_batches WHERE import_batch_id = ?");
1340 $sth->execute($batch_id);
1341 my ($item_action) = $sth->fetchrow_array();
1343 return $item_action;
1348 =head2 SetImportBatchItemAction
1350 SetImportBatchItemAction($batch_id, $new_item_action);
1354 sub SetImportBatchItemAction {
1355 my ($batch_id, $new_item_action) = @_;
1357 my $dbh = C4::Context->dbh;
1358 my $sth = $dbh->prepare("UPDATE import_batches SET item_action = ? WHERE import_batch_id = ?");
1359 $sth->execute($new_item_action, $batch_id);
1364 =head2 GetImportBatchMatcher
1366 my $matcher_id = GetImportBatchMatcher($batch_id);
1370 sub GetImportBatchMatcher {
1371 my ($batch_id) = @_;
1373 my $dbh = C4::Context->dbh;
1374 my $sth = $dbh->prepare("SELECT matcher_id FROM import_batches WHERE import_batch_id = ?");
1375 $sth->execute($batch_id);
1376 my ($matcher_id) = $sth->fetchrow_array();
1383 =head2 SetImportBatchMatcher
1385 SetImportBatchMatcher($batch_id, $new_matcher_id);
1389 sub SetImportBatchMatcher {
1390 my ($batch_id, $new_matcher_id) = @_;
1392 my $dbh = C4::Context->dbh;
1393 my $sth = $dbh->prepare("UPDATE import_batches SET matcher_id = ? WHERE import_batch_id = ?");
1394 $sth->execute($new_matcher_id, $batch_id);
1399 =head2 GetImportRecordOverlayStatus
1401 my $overlay_status = GetImportRecordOverlayStatus($import_record_id);
1405 sub GetImportRecordOverlayStatus {
1406 my ($import_record_id) = @_;
1408 my $dbh = C4::Context->dbh;
1409 my $sth = $dbh->prepare("SELECT overlay_status FROM import_records WHERE import_record_id = ?");
1410 $sth->execute($import_record_id);
1411 my ($overlay_status) = $sth->fetchrow_array();
1413 return $overlay_status;
1418 =head2 SetImportRecordOverlayStatus
1420 SetImportRecordOverlayStatus($import_record_id, $new_overlay_status);
1424 sub SetImportRecordOverlayStatus {
1425 my ($import_record_id, $new_overlay_status) = @_;
1427 my $dbh = C4::Context->dbh;
1428 my $sth = $dbh->prepare("UPDATE import_records SET overlay_status = ? WHERE import_record_id = ?");
1429 $sth->execute($new_overlay_status, $import_record_id);
1434 =head2 GetImportRecordStatus
1436 my $status = GetImportRecordStatus($import_record_id);
1440 sub GetImportRecordStatus {
1441 my ($import_record_id) = @_;
1443 my $dbh = C4::Context->dbh;
1444 my $sth = $dbh->prepare("SELECT status FROM import_records WHERE import_record_id = ?");
1445 $sth->execute($import_record_id);
1446 my ($status) = $sth->fetchrow_array();
1453 =head2 SetImportRecordStatus
1455 SetImportRecordStatus($import_record_id, $new_status);
1459 sub SetImportRecordStatus {
1460 my ($import_record_id, $new_status) = @_;
1462 my $dbh = C4::Context->dbh;
1463 my $sth = $dbh->prepare("UPDATE import_records SET status = ? WHERE import_record_id = ?");
1464 $sth->execute($new_status, $import_record_id);
1469 =head2 GetImportRecordMatches
1471 my $results = GetImportRecordMatches($import_record_id, $best_only);
1475 sub GetImportRecordMatches {
1476 my $import_record_id = shift;
1477 my $best_only = @_ ? shift : 0;
1479 my $dbh = C4::Context->dbh;
1480 # FIXME currently biblio only
1481 my $sth = $dbh->prepare_cached("SELECT title, author, biblionumber,
1482 candidate_match_id, score, record_type
1484 JOIN import_record_matches USING (import_record_id)
1485 LEFT JOIN biblio ON (biblionumber = candidate_match_id)
1486 WHERE import_record_id = ?
1487 ORDER BY score DESC, biblionumber DESC");
1488 $sth->bind_param(1, $import_record_id);
1491 while (my $row = $sth->fetchrow_hashref) {
1492 if ($row->{'record_type'} eq 'auth') {
1493 $row->{'authorized_heading'} = C4::AuthoritiesMarc::GetAuthorizedHeading( { authid => $row->{'candidate_match_id'} } );
1495 next if ($row->{'record_type'} eq 'biblio' && not $row->{'biblionumber'});
1496 push @$results, $row;
1505 =head2 SetImportRecordMatches
1507 SetImportRecordMatches($import_record_id, @matches);
1511 sub SetImportRecordMatches {
1512 my $import_record_id = shift;
1515 my $dbh = C4::Context->dbh;
1516 my $delsth = $dbh->prepare("DELETE FROM import_record_matches WHERE import_record_id = ?");
1517 $delsth->execute($import_record_id);
1520 my $sth = $dbh->prepare("INSERT INTO import_record_matches (import_record_id, candidate_match_id, score)
1522 foreach my $match (@matches) {
1523 $sth->execute($import_record_id, $match->{'record_id'}, $match->{'score'});
1527 =head2 RecordsFromISO2709File
1529 my ($errors, $records) = C4::ImportBatch::RecordsFromISO2709File($input_file, $record_type, $encoding);
1531 Reads ISO2709 binary porridge from the given file and creates MARC::Record-objects out of it.
1533 @PARAM1, String, absolute path to the ISO2709 file.
1534 @PARAM2, String, see stage_file.pl
1535 @PARAM3, String, should be utf8
1537 Returns two array refs.
1541 sub RecordsFromISO2709File {
1542 my ($input_file, $record_type, $encoding) = @_;
1545 my $marc_type = C4::Context->preference('marcflavour');
1546 $marc_type .= 'AUTH' if ($marc_type eq 'UNIMARC' && $record_type eq 'auth');
1548 open my $fh, '<', $input_file or die "$0: cannot open input file $input_file: $!\n";
1554 next unless $_; # skip if record has only whitespace, as might occur
1555 # if file includes newlines between each MARC record
1556 my ($marc_record, $charset_guessed, $char_errors) = MarcToUTF8Record($_, $marc_type, $encoding);
1557 push @marc_records, $marc_record;
1558 if ($charset_guessed ne $encoding) {
1560 "Unexpected charset $charset_guessed, expecting $encoding";
1564 return ( \@errors, \@marc_records );
1567 =head2 RecordsFromMARCXMLFile
1569 my ($errors, $records) = C4::ImportBatch::RecordsFromMARCXMLFile($input_file, $encoding);
1571 Creates MARC::Record-objects out of the given MARCXML-file.
1573 @PARAM1, String, absolute path to the ISO2709 file.
1574 @PARAM2, String, should be utf8
1576 Returns two array refs.
1580 sub RecordsFromMARCXMLFile {
1581 my ( $filename, $encoding ) = @_;
1582 my $batch = MARC::File::XML->in( $filename );
1583 my ( @marcRecords, @errors, $record );
1585 eval { $record = $batch->next( $encoding ); };
1589 push @marcRecords, $record if $record;
1591 return (\@errors, \@marcRecords);
1594 =head2 RecordsFromMarcPlugin
1596 Converts text of input_file into array of MARC records with to_marc plugin
1600 sub RecordsFromMarcPlugin {
1601 my ($input_file, $plugin_class, $encoding) = @_;
1602 my ( $text, @return );
1603 return \@return if !$input_file || !$plugin_class;
1606 open my $fh, '<', $input_file or die "$0: cannot open input file $input_file: $!\n";
1616 # Convert to large MARC blob with plugin
1617 $text = Koha::Plugins::Handler->run({
1618 class => $plugin_class,
1619 method => 'to_marc',
1620 params => { data => $text },
1623 # Convert to array of MARC records
1625 my $marc_type = C4::Context->preference('marcflavour');
1626 foreach my $blob ( split(/\x1D/, $text) ) {
1627 next if $blob =~ /^\s*$/;
1628 my ($marcrecord) = MarcToUTF8Record($blob, $marc_type, $encoding);
1629 push @return, $marcrecord;
1635 # internal functions
1637 sub _create_import_record {
1638 my ($batch_id, $record_sequence, $marc_record, $record_type, $encoding, $marc_type) = @_;
1640 my $dbh = C4::Context->dbh;
1641 my $sth = $dbh->prepare("INSERT INTO import_records (import_batch_id, record_sequence, marc, marcxml, marcxml_old,
1642 record_type, encoding)
1643 VALUES (?, ?, ?, ?, ?, ?, ?)");
1644 $sth->execute($batch_id, $record_sequence, $marc_record->as_usmarc(), $marc_record->as_xml($marc_type), '',
1645 $record_type, $encoding);
1646 my $import_record_id = $dbh->{'mysql_insertid'};
1648 return $import_record_id;
1651 sub _update_import_record_marc {
1652 my ($import_record_id, $marc_record, $marc_type) = @_;
1654 my $dbh = C4::Context->dbh;
1655 my $sth = $dbh->prepare("UPDATE import_records SET marc = ?, marcxml = ?
1656 WHERE import_record_id = ?");
1657 $sth->execute($marc_record->as_usmarc(), $marc_record->as_xml($marc_type), $import_record_id);
1661 sub _add_auth_fields {
1662 my ($import_record_id, $marc_record) = @_;
1665 if ($marc_record->field('001')) {
1666 $controlnumber = $marc_record->field('001')->data();
1668 my $authorized_heading = C4::AuthoritiesMarc::GetAuthorizedHeading({ record => $marc_record });
1669 my $dbh = C4::Context->dbh;
1670 my $sth = $dbh->prepare("INSERT INTO import_auths (import_record_id, control_number, authorized_heading) VALUES (?, ?, ?)");
1671 $sth->execute($import_record_id, $controlnumber, $authorized_heading);
1675 sub _add_biblio_fields {
1676 my ($import_record_id, $marc_record) = @_;
1678 my ($title, $author, $isbn, $issn) = _parse_biblio_fields($marc_record);
1679 my $dbh = C4::Context->dbh;
1680 # FIXME no controlnumber, originalsource
1681 $isbn = C4::Koha::GetNormalizedISBN($isbn);
1682 my $sth = $dbh->prepare("INSERT INTO import_biblios (import_record_id, title, author, isbn, issn) VALUES (?, ?, ?, ?, ?)");
1683 $sth->execute($import_record_id, $title, $author, $isbn, $issn) or die $sth->errstr;
1688 sub _update_biblio_fields {
1689 my ($import_record_id, $marc_record) = @_;
1691 my ($title, $author, $isbn, $issn) = _parse_biblio_fields($marc_record);
1692 my $dbh = C4::Context->dbh;
1693 # FIXME no controlnumber, originalsource
1694 # FIXME 2 - should regularize normalization of ISBN wherever it is done
1698 my $sth = $dbh->prepare("UPDATE import_biblios SET title = ?, author = ?, isbn = ?, issn = ?
1699 WHERE import_record_id = ?");
1700 $sth->execute($title, $author, $isbn, $issn, $import_record_id);
1704 sub _parse_biblio_fields {
1705 my ($marc_record) = @_;
1707 my $dbh = C4::Context->dbh;
1708 my $bibliofields = TransformMarcToKoha($marc_record, '');
1709 return ($bibliofields->{'title'}, $bibliofields->{'author'}, $bibliofields->{'isbn'}, $bibliofields->{'issn'});
1713 sub _update_batch_record_counts {
1714 my ($batch_id) = @_;
1716 my $dbh = C4::Context->dbh;
1717 my $sth = $dbh->prepare_cached("UPDATE import_batches SET
1721 WHERE import_batch_id = import_batches.import_batch_id),
1725 JOIN import_items USING (import_record_id)
1726 WHERE import_batch_id = import_batches.import_batch_id
1727 AND record_type = 'biblio')
1728 WHERE import_batch_id = ?");
1729 $sth->bind_param(1, $batch_id);
1734 sub _get_commit_action {
1735 my ($overlay_action, $nomatch_action, $item_action, $overlay_status, $import_record_id, $record_type) = @_;
1737 if ($record_type eq 'biblio') {
1738 my ($bib_result, $bib_match, $item_result);
1740 if ($overlay_status ne 'no_match') {
1741 $bib_match = GetBestRecordMatch($import_record_id);
1742 if ($overlay_action eq 'replace') {
1743 $bib_result = defined($bib_match) ? 'replace' : 'create_new';
1744 } elsif ($overlay_action eq 'create_new') {
1745 $bib_result = 'create_new';
1746 } elsif ($overlay_action eq 'ignore') {
1747 $bib_result = 'ignore';
1749 if($item_action eq 'always_add' or $item_action eq 'add_only_for_matches'){
1750 $item_result = 'create_new';
1752 elsif($item_action eq 'replace'){
1753 $item_result = 'replace';
1756 $item_result = 'ignore';
1759 $bib_result = $nomatch_action;
1760 $item_result = ($item_action eq 'always_add' or $item_action eq 'add_only_for_new') ? 'create_new' : 'ignore';
1762 return ($bib_result, $item_result, $bib_match);
1763 } else { # must be auths
1764 my ($auth_result, $auth_match);
1766 if ($overlay_status ne 'no_match') {
1767 $auth_match = GetBestRecordMatch($import_record_id);
1768 if ($overlay_action eq 'replace') {
1769 $auth_result = defined($auth_match) ? 'replace' : 'create_new';
1770 } elsif ($overlay_action eq 'create_new') {
1771 $auth_result = 'create_new';
1772 } elsif ($overlay_action eq 'ignore') {
1773 $auth_result = 'ignore';
1776 $auth_result = $nomatch_action;
1779 return ($auth_result, undef, $auth_match);
1784 sub _get_revert_action {
1785 my ($overlay_action, $overlay_status, $status) = @_;
1789 if ($status eq 'ignored') {
1790 $bib_result = 'ignore';
1792 if ($overlay_action eq 'create_new') {
1793 $bib_result = 'delete';
1795 $bib_result = ($overlay_status eq 'match_applied') ? 'restore' : 'delete';
1806 Koha Development Team <http://koha-community.org/>
1808 Galen Charlton <galen.charlton@liblime.com>