fix for #3620: basket management
[wip/koha-chris_n.git] / C4 / ImportBatch.pm
1 package C4::ImportBatch;
2
3 # Copyright (C) 2007 LibLime
4 #
5 # This file is part of Koha.
6 #
7 # Koha is free software; you can redistribute it and/or modify it under the
8 # terms of the GNU General Public License as published by the Free Software
9 # Foundation; either version 2 of the License, or (at your option) any later
10 # version.
11 #
12 # Koha is distributed in the hope that it will be useful, but WITHOUT ANY
13 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14 # A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
15 #
16 # You should have received a copy of the GNU General Public License along with
17 # Koha; if not, write to the Free Software Foundation, Inc., 59 Temple Place,
18 # Suite 330, Boston, MA  02111-1307 USA
19
20 use strict;
21 use warnings;
22
23 use C4::Context;
24 use C4::Koha;
25 use C4::Biblio;
26 use C4::Items;
27 use C4::Charset;
28
29 use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
30
31 BEGIN {
32         # set the version for version checking
33         $VERSION = 3.01;
34         require Exporter;
35         @ISA    = qw(Exporter);
36         @EXPORT = qw(
37     GetZ3950BatchId
38     GetImportRecordMarc
39     AddImportBatch
40     GetImportBatch
41     AddBiblioToBatch
42     ModBiblioInBatch
43
44     BatchStageMarcRecords
45     BatchFindBibDuplicates
46     BatchCommitBibRecords
47     BatchRevertBibRecords
48     CleanBatch
49
50     GetAllImportBatches
51     GetImportBatchRangeDesc
52     GetNumberOfNonZ3950ImportBatches
53     GetImportBibliosRange
54         GetItemNumbersFromImportBatch
55     
56     GetImportBatchStatus
57     SetImportBatchStatus
58     GetImportBatchOverlayAction
59     SetImportBatchOverlayAction
60     GetImportBatchNoMatchAction
61     SetImportBatchNoMatchAction
62     GetImportBatchItemAction
63     SetImportBatchItemAction
64     GetImportBatchMatcher
65     SetImportBatchMatcher
66     GetImportRecordOverlayStatus
67     SetImportRecordOverlayStatus
68     GetImportRecordStatus
69     SetImportRecordStatus
70     GetImportRecordMatches
71     SetImportRecordMatches
72         );
73 }
74
75 =head1 NAME
76
77 C4::ImportBatch - manage batches of imported MARC records
78
79 =head1 SYNOPSIS
80
81 =over 4
82
83 use C4::ImportBatch;
84
85 =back
86
87 =head1 FUNCTIONS
88
89 =head2 GetZ3950BatchId
90
91 =over 4
92
93 my $batchid = GetZ3950BatchId($z3950server);
94
95 =back
96
97 Retrieves the ID of the import batch for the Z39.50
98 reservoir for the given target.  If necessary,
99 creates the import batch.
100
101 =cut
102
103 sub GetZ3950BatchId {
104     my ($z3950server) = @_;
105
106     my $dbh = C4::Context->dbh;
107     my $sth = $dbh->prepare("SELECT import_batch_id FROM import_batches
108                              WHERE  batch_type = 'z3950'
109                              AND    file_name = ?");
110     $sth->execute($z3950server);
111     my $rowref = $sth->fetchrow_arrayref();
112     $sth->finish();
113     if (defined $rowref) {
114         return $rowref->[0];
115     } else {
116         my $batch_id = AddImportBatch('create_new', 'staged', 'z3950', $z3950server, '');
117         return $batch_id;
118     }
119     
120 }
121
122 =head2 GetImportRecordMarc
123
124 =over 4
125
126 my ($marcblob, $encoding) = GetImportRecordMarc($import_record_id);
127
128 =back
129
130 =cut
131
132 sub GetImportRecordMarc {
133     my ($import_record_id) = @_;
134
135     my $dbh = C4::Context->dbh;
136     my $sth = $dbh->prepare("SELECT marc, encoding FROM import_records WHERE import_record_id = ?");
137     $sth->execute($import_record_id);
138     my ($marc, $encoding) = $sth->fetchrow();
139     $sth->finish();
140     return $marc, $encoding;
141
142 }
143
144 =head2 AddImportBatch
145
146 =over 4
147
148 my $batch_id = AddImportBatch($overlay_action, $import_status, $type, $file_name, $comments);
149
150 =back
151
152 =cut
153
154 sub AddImportBatch {
155     my ($overlay_action, $import_status, $type, $file_name, $comments) = @_;
156
157     my $dbh = C4::Context->dbh;
158     my $sth = $dbh->prepare("INSERT INTO import_batches (overlay_action, import_status, batch_type,
159                                                          file_name, comments)
160                                     VALUES (?, ?, ?, ?, ?)");
161     $sth->execute($overlay_action, $import_status, $type, $file_name, $comments);
162     my $batch_id = $dbh->{'mysql_insertid'};
163     $sth->finish();
164
165     return $batch_id;
166
167 }
168
169 =head2 GetImportBatch 
170
171 =over 4
172
173 my $row = GetImportBatch($batch_id);
174
175 =back
176
177 Retrieve a hashref of an import_batches row.
178
179 =cut
180
181 sub GetImportBatch {
182     my ($batch_id) = @_;
183
184     my $dbh = C4::Context->dbh;
185     my $sth = $dbh->prepare_cached("SELECT * FROM import_batches WHERE import_batch_id = ?");
186     $sth->bind_param(1, $batch_id);
187     $sth->execute();
188     my $result = $sth->fetchrow_hashref;
189     $sth->finish();
190     return $result;
191
192 }
193
194 =head2 AddBiblioToBatch 
195
196 =over 4
197
198 my $import_record_id = AddBiblioToBatch($batch_id, $record_sequence, $marc_record, $encoding, $z3950random, $update_counts);
199
200 =back
201
202 =cut
203
204 sub AddBiblioToBatch {
205     my $batch_id = shift;
206     my $record_sequence = shift;
207     my $marc_record = shift;
208     my $encoding = shift;
209     my $z3950random = shift;
210     my $update_counts = @_ ? shift : 1;
211
212     my $import_record_id = _create_import_record($batch_id, $record_sequence, $marc_record, 'biblio', $encoding, $z3950random);
213     _add_biblio_fields($import_record_id, $marc_record);
214     _update_batch_record_counts($batch_id) if $update_counts;
215     return $import_record_id;
216 }
217
218 =head2 ModBiblioInBatch
219
220 =over 4
221
222 ModBiblioInBatch($import_record_id, $marc_record);
223
224 =back
225
226 =cut
227
228 sub ModBiblioInBatch {
229     my ($import_record_id, $marc_record) = @_;
230
231     _update_import_record_marc($import_record_id, $marc_record);
232     _update_biblio_fields($import_record_id, $marc_record);
233
234 }
235
236 =head2 BatchStageMarcRecords
237
238 =over 4
239
240 ($batch_id, $num_records, $num_items, @invalid_records) = 
241     BatchStageMarcRecords($marc_flavor, $marc_records, $file_name, 
242                           $comments, $branch_code, $parse_items,
243                           $leave_as_staging, 
244                           $progress_interval, $progress_callback);
245
246 =back
247
248 =cut
249
250 sub  BatchStageMarcRecords {
251     my $marc_flavor = shift;
252     my $marc_records = shift;
253     my $file_name = shift;
254     my $comments = shift;
255     my $branch_code = shift;
256     my $parse_items = shift;
257     my $leave_as_staging = shift;
258    
259     # optional callback to monitor status 
260     # of job
261     my $progress_interval = 0;
262     my $progress_callback = undef;
263     if ($#_ == 1) {
264         $progress_interval = shift;
265         $progress_callback = shift;
266         $progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
267         $progress_interval = 0 unless 'CODE' eq ref $progress_callback;
268     } 
269     
270     my $batch_id = AddImportBatch('create_new', 'staging', 'batch', $file_name, $comments);
271     if ($parse_items) {
272         SetImportBatchItemAction($batch_id, 'always_add');
273     } else {
274         SetImportBatchItemAction($batch_id, 'ignore');
275     }
276
277     my @invalid_records = ();
278     my $num_valid = 0;
279     my $num_items = 0;
280     # FIXME - for now, we're dealing only with bibs
281     my $rec_num = 0;
282     foreach my $marc_blob (split(/\x1D/, $marc_records)) {
283         $marc_blob =~ s/^\s+//g;
284         $marc_blob =~ s/\s+$//g;
285         next unless $marc_blob;
286         $rec_num++;
287         if ($progress_interval and (0 == ($rec_num % $progress_interval))) {
288             &$progress_callback($rec_num);
289         }
290         my ($marc_record, $charset_guessed, $char_errors) =
291             MarcToUTF8Record($marc_blob, C4::Context->preference("marcflavour"));
292         my $import_record_id;
293         if (scalar($marc_record->fields()) == 0) {
294             push @invalid_records, $marc_blob;
295         } else {
296             $num_valid++;
297             $import_record_id = AddBiblioToBatch($batch_id, $rec_num, $marc_record, $marc_flavor, int(rand(99999)), 0);
298             if ($parse_items) {
299                 my @import_items_ids = AddItemsToImportBiblio($batch_id, $import_record_id, $marc_record, 0);
300                 $num_items += scalar(@import_items_ids);
301             }
302         }
303     }
304     unless ($leave_as_staging) {
305         SetImportBatchStatus($batch_id, 'staged');
306     }
307     # FIXME branch_code, number of bibs, number of items
308     _update_batch_record_counts($batch_id);
309     return ($batch_id, $num_valid, $num_items, @invalid_records);
310 }
311
312 =head2 AddItemsToImportBiblio
313
314 =over 4
315
316 my @import_items_ids = AddItemsToImportBiblio($batch_id, $import_record_id, $marc_record, $update_counts);
317
318 =back
319
320 =cut
321
322 sub AddItemsToImportBiblio {
323     my $batch_id = shift;
324     my $import_record_id = shift;
325     my $marc_record = shift;
326     my $update_counts = @_ ? shift : 0;
327
328     my @import_items_ids = ();
329    
330     my $dbh = C4::Context->dbh; 
331     my ($item_tag,$item_subfield) = &GetMarcFromKohaField("items.itemnumber",'');
332     foreach my $item_field ($marc_record->field($item_tag)) {
333         my $item_marc = MARC::Record->new();
334         $item_marc->leader("00000    a              "); # must set Leader/09 to 'a'
335         $item_marc->append_fields($item_field);
336         $marc_record->delete_field($item_field);
337         my $sth = $dbh->prepare_cached("INSERT INTO import_items (import_record_id, status, marcxml)
338                                         VALUES (?, ?, ?)");
339         $sth->bind_param(1, $import_record_id);
340         $sth->bind_param(2, 'staged');
341         $sth->bind_param(3, $item_marc->as_xml());
342         $sth->execute();
343         push @import_items_ids, $dbh->{'mysql_insertid'};
344         $sth->finish();
345     }
346
347     if ($#import_items_ids > -1) {
348         _update_batch_record_counts($batch_id) if $update_counts;
349         _update_import_record_marc($import_record_id, $marc_record);
350     }
351     return @import_items_ids;
352 }
353
354 =head2 BatchFindBibDuplicates
355
356 =over 4
357
358 my $num_with_matches = BatchFindBibDuplicates($batch_id, $matcher, $max_matches, $progress_interval, $progress_callback);
359
360 =back
361
362 Goes through the records loaded in the batch and attempts to 
363 find duplicates for each one.  Sets the matching status 
364 of each record to "no_match" or "auto_match" as appropriate.
365
366 The $max_matches parameter is optional; if it is not supplied,
367 it defaults to 10.
368
369 The $progress_interval and $progress_callback parameters are 
370 optional; if both are supplied, the sub referred to by
371 $progress_callback will be invoked every $progress_interval
372 records using the number of records processed as the 
373 singular argument.
374
375 =cut
376
377 sub BatchFindBibDuplicates {
378     my $batch_id = shift;
379     my $matcher = shift;
380     my $max_matches = @_ ? shift : 10;
381
382     # optional callback to monitor status 
383     # of job
384     my $progress_interval = 0;
385     my $progress_callback = undef;
386     if ($#_ == 1) {
387         $progress_interval = shift;
388         $progress_callback = shift;
389         $progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
390         $progress_interval = 0 unless 'CODE' eq ref $progress_callback;
391     }
392
393     my $dbh = C4::Context->dbh;
394
395     my $sth = $dbh->prepare("SELECT import_record_id, marc
396                              FROM import_records
397                              JOIN import_biblios USING (import_record_id)
398                              WHERE import_batch_id = ?");
399     $sth->execute($batch_id);
400     my $num_with_matches = 0;
401     my $rec_num = 0;
402     while (my $rowref = $sth->fetchrow_hashref) {
403         $rec_num++;
404         if ($progress_interval and (0 == ($rec_num % $progress_interval))) {
405             &$progress_callback($rec_num);
406         }
407         my $marc_record = MARC::Record->new_from_usmarc($rowref->{'marc'});
408         my @matches = ();
409         if (defined $matcher) {
410             @matches = $matcher->get_matches($marc_record, $max_matches);
411         }
412         if (scalar(@matches) > 0) {
413             $num_with_matches++;
414             SetImportRecordMatches($rowref->{'import_record_id'}, @matches);
415             SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'auto_match');
416         } else {
417             SetImportRecordMatches($rowref->{'import_record_id'}, ());
418             SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'no_match');
419         }
420     }
421     $sth->finish();
422     return $num_with_matches;
423 }
424
425 =head2 BatchCommitBibRecords
426
427 =over 4
428
429 my ($num_added, $num_updated, $num_items_added, $num_items_errored, $num_ignored) = 
430     BatchCommitBibRecords($batch_id, $progress_interval, $progress_callback);
431
432 =back
433
434 =cut
435
436 sub BatchCommitBibRecords {
437     my $batch_id = shift;
438
439     # optional callback to monitor status 
440     # of job
441     my $progress_interval = 0;
442     my $progress_callback = undef;
443     if ($#_ == 1) {
444         $progress_interval = shift;
445         $progress_callback = shift;
446         $progress_interval = 0 unless $progress_interval =~ /^\d+$/ and $progress_interval > 0;
447         $progress_interval = 0 unless 'CODE' eq ref $progress_callback;
448     }
449
450     my $num_added = 0;
451     my $num_updated = 0;
452     my $num_items_added = 0;
453     my $num_items_errored = 0;
454     my $num_ignored = 0;
455     # commit (i.e., save, all records in the batch)
456     # FIXME biblio only at the moment
457     SetImportBatchStatus('importing');
458     my $overlay_action = GetImportBatchOverlayAction($batch_id);
459     my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
460     my $item_action = GetImportBatchItemAction($batch_id);
461     my $dbh = C4::Context->dbh;
462     my $sth = $dbh->prepare("SELECT import_record_id, status, overlay_status, marc, encoding
463                              FROM import_records
464                              JOIN import_biblios USING (import_record_id)
465                              WHERE import_batch_id = ?");
466     $sth->execute($batch_id);
467     my $rec_num = 0;
468     while (my $rowref = $sth->fetchrow_hashref) {
469         $rec_num++;
470         if ($progress_interval and (0 == ($rec_num % $progress_interval))) {
471             &$progress_callback($rec_num);
472         }
473         if ($rowref->{'status'} eq 'error' or $rowref->{'status'} eq 'imported') {
474             $num_ignored++;
475             next;
476         }
477
478         my $marc_record = MARC::Record->new_from_usmarc($rowref->{'marc'});
479
480         # remove any item tags - rely on BatchCommitItems
481         my ($item_tag,$item_subfield) = &GetMarcFromKohaField("items.itemnumber",'');
482         foreach my $item_field ($marc_record->field($item_tag)) {
483             $marc_record->delete_field($item_field);
484         }
485
486         # decide what what to do with the bib and item records
487         my ($bib_result, $item_result, $bib_match) = 
488             _get_commit_action($overlay_action, $nomatch_action, $item_action, 
489                                $rowref->{'overlay_status'}, $rowref->{'import_record_id'});
490
491         if ($bib_result eq 'create_new') {
492             $num_added++;
493             my ($biblionumber, $biblioitemnumber) = AddBiblio($marc_record, '');
494             my $sth = $dbh->prepare_cached("UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?");
495             $sth->execute($biblionumber, $rowref->{'import_record_id'});
496             $sth->finish();
497             if ($item_result eq 'create_new') {
498                 my ($bib_items_added, $bib_items_errored) = BatchCommitItems($rowref->{'import_record_id'}, $biblionumber);
499                 $num_items_added += $bib_items_added;
500                 $num_items_errored += $bib_items_errored;
501             }
502             SetImportRecordStatus($rowref->{'import_record_id'}, 'imported');
503         } elsif ($bib_result eq 'replace') {
504             $num_updated++;
505             my $biblionumber = $bib_match;
506             my ($count, $oldbiblio) = GetBiblio($biblionumber);
507             my $oldxml = GetXmlBiblio($biblionumber);
508
509             # remove item fields so that they don't get
510             # added again if record is reverted
511             my $old_marc = MARC::Record->new_from_xml(StripNonXmlChars($oldxml), 'UTF-8', $rowref->{'encoding'});
512             foreach my $item_field ($old_marc->field($item_tag)) {
513                 $old_marc->delete_field($item_field);
514             }
515
516             ModBiblio($marc_record, $biblionumber, $oldbiblio->{'frameworkcode'});
517             my $sth = $dbh->prepare_cached("UPDATE import_records SET marcxml_old = ? WHERE import_record_id = ?");
518             $sth->execute($old_marc->as_xml(), $rowref->{'import_record_id'});
519             $sth->finish();
520             my $sth2 = $dbh->prepare_cached("UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?");
521             $sth2->execute($biblionumber, $rowref->{'import_record_id'});
522             $sth2->finish();
523             if ($item_result eq 'create_new') {
524                 my ($bib_items_added, $bib_items_errored) = BatchCommitItems($rowref->{'import_record_id'}, $biblionumber);
525                 $num_items_added += $bib_items_added;
526                 $num_items_errored += $bib_items_errored;
527             }
528             SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'match_applied');
529             SetImportRecordStatus($rowref->{'import_record_id'}, 'imported');
530         } elsif ($bib_result eq 'ignore') {
531             $num_ignored++;
532             my $biblionumber = $bib_match;
533             if (defined $biblionumber and $item_result eq 'create_new') {
534                 my ($bib_items_added, $bib_items_errored) = BatchCommitItems($rowref->{'import_record_id'}, $biblionumber);
535                 $num_items_added += $bib_items_added;
536                 $num_items_errored += $bib_items_errored;
537                 # still need to record the matched biblionumber so that the
538                 # items can be reverted
539                 my $sth2 = $dbh->prepare_cached("UPDATE import_biblios SET matched_biblionumber = ? WHERE import_record_id = ?");
540                 $sth2->execute($biblionumber, $rowref->{'import_record_id'});
541                 SetImportRecordOverlayStatus($rowref->{'import_record_id'}, 'match_applied');
542             }
543             SetImportRecordStatus($rowref->{'import_record_id'}, 'ignored');
544         }
545     }
546     $sth->finish();
547     SetImportBatchStatus($batch_id, 'imported');
548     return ($num_added, $num_updated, $num_items_added, $num_items_errored, $num_ignored);
549 }
550
551 =head2 BatchCommitItems
552
553 =over 4
554
555 ($num_items_added, $num_items_errored) = BatchCommitItems($import_record_id, $biblionumber);
556
557 =back
558
559 =cut
560
561 sub BatchCommitItems {
562     my ($import_record_id, $biblionumber) = @_;
563
564     my $dbh = C4::Context->dbh;
565
566     my $num_items_added = 0;
567     my $num_items_errored = 0;
568     my $sth = $dbh->prepare("SELECT import_items_id, import_items.marcxml, encoding
569                              FROM import_items
570                              JOIN import_records USING (import_record_id)
571                              WHERE import_record_id = ?
572                              ORDER BY import_items_id");
573     $sth->bind_param(1, $import_record_id);
574     $sth->execute();
575     while (my $row = $sth->fetchrow_hashref()) {
576         my $item_marc = MARC::Record->new_from_xml(StripNonXmlChars($row->{'marcxml'}), 'UTF-8', $row->{'encoding'});
577         # FIXME - duplicate barcode check needs to become part of AddItemFromMarc()
578         my $item = TransformMarcToKoha($dbh, $item_marc);
579         my $duplicate_barcode = exists($item->{'barcode'}) && GetItemnumberFromBarcode($item->{'barcode'});
580         if ($duplicate_barcode) {
581             my $updsth = $dbh->prepare("UPDATE import_items SET status = ?, import_error = ? WHERE import_items_id = ?");
582             $updsth->bind_param(1, 'error');
583             $updsth->bind_param(2, 'duplicate item barcode');
584             $updsth->bind_param(3, $row->{'import_items_id'});
585             $updsth->execute();
586             $num_items_errored++;
587         } else {
588             my ($item_biblionumber, $biblioitemnumber, $itemnumber) = AddItemFromMarc($item_marc, $biblionumber);
589             my $updsth = $dbh->prepare("UPDATE import_items SET status = ?, itemnumber = ? WHERE import_items_id = ?");
590             $updsth->bind_param(1, 'imported');
591             $updsth->bind_param(2, $itemnumber);
592             $updsth->bind_param(3, $row->{'import_items_id'});
593             $updsth->execute();
594             $updsth->finish();
595             $num_items_added++;
596         }
597     }
598     $sth->finish();
599     return ($num_items_added, $num_items_errored);
600 }
601
602 =head2 BatchRevertBibRecords
603
604 =over 4
605
606 my ($num_deleted, $num_errors, $num_reverted, $num_items_deleted, $num_ignored) = BatchRevertBibRecords($batch_id);
607
608 =back
609
610 =cut
611
612 sub BatchRevertBibRecords {
613     my $batch_id = shift;
614
615     my $num_deleted = 0;
616     my $num_errors = 0;
617     my $num_reverted = 0;
618     my $num_items_deleted = 0;
619     my $num_ignored = 0;
620     # commit (i.e., save, all records in the batch)
621     # FIXME biblio only at the moment
622     SetImportBatchStatus('reverting');
623     my $overlay_action = GetImportBatchOverlayAction($batch_id);
624     my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
625     my $dbh = C4::Context->dbh;
626     my $sth = $dbh->prepare("SELECT import_record_id, status, overlay_status, marcxml_old, encoding, matched_biblionumber
627                              FROM import_records
628                              JOIN import_biblios USING (import_record_id)
629                              WHERE import_batch_id = ?");
630     $sth->execute($batch_id);
631     while (my $rowref = $sth->fetchrow_hashref) {
632         if ($rowref->{'status'} eq 'error' or $rowref->{'status'} eq 'reverted') {
633             $num_ignored++;
634             next;
635         }
636
637         my $bib_result = _get_revert_action($overlay_action, $rowref->{'overlay_status'}, $rowref->{'status'});
638
639         if ($bib_result eq 'delete') {
640             $num_items_deleted += BatchRevertItems($rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'});
641             my $error = DelBiblio($rowref->{'matched_biblionumber'});
642             if (defined $error) {
643                 $num_errors++;
644             } else {
645                 $num_deleted++;
646                 SetImportRecordStatus($rowref->{'import_record_id'}, 'reverted');
647             }
648         } elsif ($bib_result eq 'restore') {
649             $num_reverted++;
650             my $old_record = MARC::Record->new_from_xml(StripNonXmlChars($rowref->{'marcxml_old'}), 'UTF-8', $rowref->{'encoding'});
651             my $biblionumber = $rowref->{'matched_biblionumber'};
652             my ($count, $oldbiblio) = GetBiblio($biblionumber);
653             $num_items_deleted += BatchRevertItems($rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'});
654             ModBiblio($old_record, $biblionumber, $oldbiblio->{'frameworkcode'});
655             SetImportRecordStatus($rowref->{'import_record_id'}, 'reverted');
656         } elsif ($bib_result eq 'ignore') {
657             $num_items_deleted += BatchRevertItems($rowref->{'import_record_id'}, $rowref->{'matched_biblionumber'});
658             SetImportRecordStatus($rowref->{'import_record_id'}, 'reverted');
659         }
660         my $sth2 = $dbh->prepare_cached("UPDATE import_biblios SET matched_biblionumber = NULL WHERE import_record_id = ?");
661         $sth2->execute($rowref->{'import_record_id'});
662     }
663
664     $sth->finish();
665     SetImportBatchStatus($batch_id, 'reverted');
666     return ($num_deleted, $num_errors, $num_reverted, $num_items_deleted, $num_ignored);
667 }
668
669 =head2 BatchRevertItems
670
671 =over 4
672
673 my $num_items_deleted = BatchRevertItems($import_record_id, $biblionumber);
674
675 =back
676
677 =cut
678
679 sub BatchRevertItems {
680     my ($import_record_id, $biblionumber) = @_;
681
682     my $dbh = C4::Context->dbh;
683     my $num_items_deleted = 0;
684
685     my $sth = $dbh->prepare_cached("SELECT import_items_id, itemnumber
686                                    FROM import_items
687                                    JOIN items USING (itemnumber)
688                                    WHERE import_record_id = ?");
689     $sth->bind_param(1, $import_record_id);
690     $sth->execute();
691     while (my $row = $sth->fetchrow_hashref()) {
692         DelItem($dbh, $biblionumber, $row->{'itemnumber'});
693         my $updsth = $dbh->prepare("UPDATE import_items SET status = ? WHERE import_items_id = ?");
694         $updsth->bind_param(1, 'reverted');
695         $updsth->bind_param(2, $row->{'import_items_id'});
696         $updsth->execute();
697         $updsth->finish();
698         $num_items_deleted++;
699     }
700     $sth->finish();
701     return $num_items_deleted;
702 }
703
704 =head2 CleanBatch
705
706 =over 4
707
708 CleanBatch($batch_id)
709
710 =back
711
712 Deletes all staged records from the import batch
713 and sets the status of the batch to 'cleaned'.  Note
714 that deleting a stage record does *not* affect
715 any record that has been committed to the database.
716
717 =cut
718
719 sub CleanBatch {
720     my $batch_id = shift;
721     return unless defined $batch_id;
722
723     C4::Context->dbh->do('DELETE FROM import_records WHERE import_batch_id = ?', {}, $batch_id);
724     SetImportBatchStatus($batch_id, 'cleaned');
725 }
726
727 =head2 GetAllImportBatches
728
729 =over 4
730
731 my $results = GetAllImportBatches();
732
733 =back
734
735 Returns a references to an array of hash references corresponding
736 to all import_batches rows (of batch_type 'batch'), sorted in 
737 ascending order by import_batch_id.
738
739 =cut
740
741 sub  GetAllImportBatches {
742     my $dbh = C4::Context->dbh;
743     my $sth = $dbh->prepare_cached("SELECT * FROM import_batches
744                                     WHERE batch_type = 'batch'
745                                     ORDER BY import_batch_id ASC");
746
747     my $results = [];
748     $sth->execute();
749     while (my $row = $sth->fetchrow_hashref) {
750         push @$results, $row;
751     }
752     $sth->finish();
753     return $results;
754 }
755
756 =head2 GetImportBatchRangeDesc
757
758 =over 4
759
760 my $results = GetImportBatchRangeDesc($offset, $results_per_group);
761
762 =back
763
764 Returns a reference to an array of hash references corresponding to
765 import_batches rows (sorted in descending order by import_batch_id)
766 start at the given offset.
767
768 =cut
769
770 sub GetImportBatchRangeDesc {
771     my ($offset, $results_per_group) = @_;
772
773     my $dbh = C4::Context->dbh;
774     my $query = "SELECT * FROM import_batches
775                                     WHERE batch_type = 'batch'
776                                     ORDER BY import_batch_id DESC";
777     my @params;
778     if ($offset){
779         if ($results_per_group){
780             $query .= " LIMIT ?";
781             push(@params, $results_per_group);
782         }
783         $query .= " OFFSET ?";
784         push(@params, $offset);
785     }
786     my $sth = $dbh->prepare_cached($query);
787     $sth->execute(@params);
788     my $results = $sth->fetchall_arrayref({});
789     $sth->finish();
790     return $results;
791 }
792
793 =head2 GetItemNumbersFromImportBatch
794
795 =cut
796
797 sub GetItemNumbersFromImportBatch {
798         my ($batch_id) = @_;
799         my $dbh = C4::Context->dbh;
800         my $sth = $dbh->prepare("SELECT itemnumber FROM import_batches,import_records,import_items WHERE import_batches.import_batch_id=import_records.import_batch_id AND import_records.import_record_id=import_items.import_record_id AND import_batches.import_batch_id=?");
801         $sth->execute($batch_id);
802         my @items ;
803         while ( my ($itm) = $sth->fetchrow_array ) {
804                 push @items, $itm;
805         }
806         return @items;
807 }
808
809 =head2 GetNumberOfImportBatches 
810
811 =over 4
812
813 my $count = GetNumberOfImportBatches();
814
815 =back
816
817 =cut
818
819 sub GetNumberOfNonZ3950ImportBatches {
820     my $dbh = C4::Context->dbh;
821     my $sth = $dbh->prepare("SELECT COUNT(*) FROM import_batches WHERE batch_type='batch'");
822     $sth->execute();
823     my ($count) = $sth->fetchrow_array();
824     $sth->finish();
825     return $count;
826 }
827
828 =head2 GetImportBibliosRange
829
830 =over 4
831
832 my $results = GetImportBibliosRange($batch_id, $offset, $results_per_group);
833
834 =back
835
836 Returns a reference to an array of hash references corresponding to
837 import_biblios/import_records rows for a given batch
838 starting at the given offset.
839
840 =cut
841
842 sub GetImportBibliosRange {
843     my ($batch_id, $offset, $results_per_group, $status) = @_;
844
845     my $dbh = C4::Context->dbh;
846     my $query = "SELECT title, author, isbn, issn, import_record_id, record_sequence,
847                                            status, overlay_status
848                                     FROM   import_records
849                                     JOIN   import_biblios USING (import_record_id)
850                                     WHERE  import_batch_id = ?";
851     my @params;
852     push(@params, $batch_id);
853     if ($status) {
854         $query .= " AND status=?";
855         push(@params,$status);
856     }
857     $query.=" ORDER BY import_record_id";
858
859     if($offset){
860         if($results_per_group){
861             $query .= " LIMIT ?";
862             push(@params, $results_per_group);
863         }
864         $query .= " OFFSET ?";
865         push(@params, $offset);
866     }
867     my $sth = $dbh->prepare_cached($query);
868     $sth->execute(@params);
869     my $results = $sth->fetchall_arrayref({});
870     $sth->finish();
871     return $results;
872
873 }
874
875 =head2 GetBestRecordMatch
876
877 =over 4
878
879 my $record_id = GetBestRecordMatch($import_record_id);
880
881 =back
882
883 =cut
884
885 sub GetBestRecordMatch {
886     my ($import_record_id) = @_;
887
888     my $dbh = C4::Context->dbh;
889     my $sth = $dbh->prepare("SELECT candidate_match_id
890                              FROM   import_record_matches
891                              WHERE  import_record_id = ?
892                              ORDER BY score DESC, candidate_match_id DESC");
893     $sth->execute($import_record_id);
894     my ($record_id) = $sth->fetchrow_array();
895     $sth->finish();
896     return $record_id;
897 }
898
899 =head2 GetImportBatchStatus
900
901 =over 4
902
903 my $status = GetImportBatchStatus($batch_id);
904
905 =back
906
907 =cut
908
909 sub GetImportBatchStatus {
910     my ($batch_id) = @_;
911
912     my $dbh = C4::Context->dbh;
913     my $sth = $dbh->prepare("SELECT import_status FROM import_batches WHERE import_batch_id = ?");
914     $sth->execute($batch_id);
915     my ($status) = $sth->fetchrow_array();
916     $sth->finish();
917     return $status;
918
919 }
920
921 =head2 SetImportBatchStatus
922
923 =over 4
924
925 SetImportBatchStatus($batch_id, $new_status);
926
927 =back
928
929 =cut
930
931 sub SetImportBatchStatus {
932     my ($batch_id, $new_status) = @_;
933
934     my $dbh = C4::Context->dbh;
935     my $sth = $dbh->prepare("UPDATE import_batches SET import_status = ? WHERE import_batch_id = ?");
936     $sth->execute($new_status, $batch_id);
937     $sth->finish();
938
939 }
940
941 =head2 GetImportBatchOverlayAction
942
943 =over 4
944
945 my $overlay_action = GetImportBatchOverlayAction($batch_id);
946
947 =back
948
949 =cut
950
951 sub GetImportBatchOverlayAction {
952     my ($batch_id) = @_;
953
954     my $dbh = C4::Context->dbh;
955     my $sth = $dbh->prepare("SELECT overlay_action FROM import_batches WHERE import_batch_id = ?");
956     $sth->execute($batch_id);
957     my ($overlay_action) = $sth->fetchrow_array();
958     $sth->finish();
959     return $overlay_action;
960
961 }
962
963
964 =head2 SetImportBatchOverlayAction
965
966 =over 4
967
968 SetImportBatchOverlayAction($batch_id, $new_overlay_action);
969
970 =back
971
972 =cut
973
974 sub SetImportBatchOverlayAction {
975     my ($batch_id, $new_overlay_action) = @_;
976
977     my $dbh = C4::Context->dbh;
978     my $sth = $dbh->prepare("UPDATE import_batches SET overlay_action = ? WHERE import_batch_id = ?");
979     $sth->execute($new_overlay_action, $batch_id);
980     $sth->finish();
981
982 }
983
984 =head2 GetImportBatchNoMatchAction
985
986 =over 4
987
988 my $nomatch_action = GetImportBatchNoMatchAction($batch_id);
989
990 =back
991
992 =cut
993
994 sub GetImportBatchNoMatchAction {
995     my ($batch_id) = @_;
996
997     my $dbh = C4::Context->dbh;
998     my $sth = $dbh->prepare("SELECT nomatch_action FROM import_batches WHERE import_batch_id = ?");
999     $sth->execute($batch_id);
1000     my ($nomatch_action) = $sth->fetchrow_array();
1001     $sth->finish();
1002     return $nomatch_action;
1003
1004 }
1005
1006
1007 =head2 SetImportBatchNoMatchAction
1008
1009 =over 4
1010
1011 SetImportBatchNoMatchAction($batch_id, $new_nomatch_action);
1012
1013 =back
1014
1015 =cut
1016
1017 sub SetImportBatchNoMatchAction {
1018     my ($batch_id, $new_nomatch_action) = @_;
1019
1020     my $dbh = C4::Context->dbh;
1021     my $sth = $dbh->prepare("UPDATE import_batches SET nomatch_action = ? WHERE import_batch_id = ?");
1022     $sth->execute($new_nomatch_action, $batch_id);
1023     $sth->finish();
1024
1025 }
1026
1027 =head2 GetImportBatchItemAction
1028
1029 =over 4
1030
1031 my $item_action = GetImportBatchItemAction($batch_id);
1032
1033 =back
1034
1035 =cut
1036
1037 sub GetImportBatchItemAction {
1038     my ($batch_id) = @_;
1039
1040     my $dbh = C4::Context->dbh;
1041     my $sth = $dbh->prepare("SELECT item_action FROM import_batches WHERE import_batch_id = ?");
1042     $sth->execute($batch_id);
1043     my ($item_action) = $sth->fetchrow_array();
1044     $sth->finish();
1045     return $item_action;
1046
1047 }
1048
1049
1050 =head2 SetImportBatchItemAction
1051
1052 =over 4
1053
1054 SetImportBatchItemAction($batch_id, $new_item_action);
1055
1056 =back
1057
1058 =cut
1059
1060 sub SetImportBatchItemAction {
1061     my ($batch_id, $new_item_action) = @_;
1062
1063     my $dbh = C4::Context->dbh;
1064     my $sth = $dbh->prepare("UPDATE import_batches SET item_action = ? WHERE import_batch_id = ?");
1065     $sth->execute($new_item_action, $batch_id);
1066     $sth->finish();
1067
1068 }
1069
1070 =head2 GetImportBatchMatcher
1071
1072 =over 4
1073
1074 my $matcher_id = GetImportBatchMatcher($batch_id);
1075
1076 =back
1077
1078 =cut
1079
1080 sub GetImportBatchMatcher {
1081     my ($batch_id) = @_;
1082
1083     my $dbh = C4::Context->dbh;
1084     my $sth = $dbh->prepare("SELECT matcher_id FROM import_batches WHERE import_batch_id = ?");
1085     $sth->execute($batch_id);
1086     my ($matcher_id) = $sth->fetchrow_array();
1087     $sth->finish();
1088     return $matcher_id;
1089
1090 }
1091
1092
1093 =head2 SetImportBatchMatcher
1094
1095 =over 4
1096
1097 SetImportBatchMatcher($batch_id, $new_matcher_id);
1098
1099 =back
1100
1101 =cut
1102
1103 sub SetImportBatchMatcher {
1104     my ($batch_id, $new_matcher_id) = @_;
1105
1106     my $dbh = C4::Context->dbh;
1107     my $sth = $dbh->prepare("UPDATE import_batches SET matcher_id = ? WHERE import_batch_id = ?");
1108     $sth->execute($new_matcher_id, $batch_id);
1109     $sth->finish();
1110
1111 }
1112
1113 =head2 GetImportRecordOverlayStatus
1114
1115 =over 4
1116
1117 my $overlay_status = GetImportRecordOverlayStatus($import_record_id);
1118
1119 =back
1120
1121 =cut
1122
1123 sub GetImportRecordOverlayStatus {
1124     my ($import_record_id) = @_;
1125
1126     my $dbh = C4::Context->dbh;
1127     my $sth = $dbh->prepare("SELECT overlay_status FROM import_records WHERE import_record_id = ?");
1128     $sth->execute($import_record_id);
1129     my ($overlay_status) = $sth->fetchrow_array();
1130     $sth->finish();
1131     return $overlay_status;
1132
1133 }
1134
1135
1136 =head2 SetImportRecordOverlayStatus
1137
1138 =over 4
1139
1140 SetImportRecordOverlayStatus($import_record_id, $new_overlay_status);
1141
1142 =back
1143
1144 =cut
1145
1146 sub SetImportRecordOverlayStatus {
1147     my ($import_record_id, $new_overlay_status) = @_;
1148
1149     my $dbh = C4::Context->dbh;
1150     my $sth = $dbh->prepare("UPDATE import_records SET overlay_status = ? WHERE import_record_id = ?");
1151     $sth->execute($new_overlay_status, $import_record_id);
1152     $sth->finish();
1153
1154 }
1155
1156 =head2 GetImportRecordStatus
1157
1158 =over 4
1159
1160 my $overlay_status = GetImportRecordStatus($import_record_id);
1161
1162 =back
1163
1164 =cut
1165
1166 sub GetImportRecordStatus {
1167     my ($import_record_id) = @_;
1168
1169     my $dbh = C4::Context->dbh;
1170     my $sth = $dbh->prepare("SELECT status FROM import_records WHERE import_record_id = ?");
1171     $sth->execute($import_record_id);
1172     my ($overlay_status) = $sth->fetchrow_array();
1173     $sth->finish();
1174     return $overlay_status;
1175
1176 }
1177
1178
1179 =head2 SetImportRecordStatus
1180
1181 =over 4
1182
1183 SetImportRecordStatus($import_record_id, $new_overlay_status);
1184
1185 =back
1186
1187 =cut
1188
1189 sub SetImportRecordStatus {
1190     my ($import_record_id, $new_overlay_status) = @_;
1191
1192     my $dbh = C4::Context->dbh;
1193     my $sth = $dbh->prepare("UPDATE import_records SET status = ? WHERE import_record_id = ?");
1194     $sth->execute($new_overlay_status, $import_record_id);
1195     $sth->finish();
1196
1197 }
1198
1199 =head2 GetImportRecordMatches
1200
1201 =over 4
1202
1203 my $results = GetImportRecordMatches($import_record_id, $best_only);
1204
1205 =back
1206
1207 =cut
1208
1209 sub GetImportRecordMatches {
1210     my $import_record_id = shift;
1211     my $best_only = @_ ? shift : 0;
1212
1213     my $dbh = C4::Context->dbh;
1214     # FIXME currently biblio only
1215     my $sth = $dbh->prepare_cached("SELECT title, author, biblionumber, score
1216                                     FROM import_records
1217                                     JOIN import_record_matches USING (import_record_id)
1218                                     JOIN biblio ON (biblionumber = candidate_match_id)
1219                                     WHERE import_record_id = ?
1220                                     ORDER BY score DESC, biblionumber DESC");
1221     $sth->bind_param(1, $import_record_id);
1222     my $results = [];
1223     $sth->execute();
1224     while (my $row = $sth->fetchrow_hashref) {
1225         push @$results, $row;
1226         last if $best_only;
1227     }
1228     $sth->finish();
1229
1230     return $results;
1231     
1232 }
1233
1234
1235 =head2 SetImportRecordMatches
1236
1237 =over 4
1238
1239 SetImportRecordMatches($import_record_id, @matches);
1240
1241 =back
1242
1243 =cut
1244
1245 sub SetImportRecordMatches {
1246     my $import_record_id = shift;
1247     my @matches = @_;
1248
1249     my $dbh = C4::Context->dbh;
1250     my $delsth = $dbh->prepare("DELETE FROM import_record_matches WHERE import_record_id = ?");
1251     $delsth->execute($import_record_id);
1252     $delsth->finish();
1253
1254     my $sth = $dbh->prepare("INSERT INTO import_record_matches (import_record_id, candidate_match_id, score)
1255                                     VALUES (?, ?, ?)");
1256     foreach my $match (@matches) {
1257         $sth->execute($import_record_id, $match->{'record_id'}, $match->{'score'});
1258     }
1259 }
1260
1261
1262 # internal functions
1263
1264 sub _create_import_record {
1265     my ($batch_id, $record_sequence, $marc_record, $record_type, $encoding, $z3950random) = @_;
1266
1267     my $dbh = C4::Context->dbh;
1268     my $sth = $dbh->prepare("INSERT INTO import_records (import_batch_id, record_sequence, marc, marcxml, 
1269                                                          record_type, encoding, z3950random)
1270                                     VALUES (?, ?, ?, ?, ?, ?, ?)");
1271     $sth->execute($batch_id, $record_sequence, $marc_record->as_usmarc(), $marc_record->as_xml(),
1272                   $record_type, $encoding, $z3950random);
1273     my $import_record_id = $dbh->{'mysql_insertid'};
1274     $sth->finish();
1275     return $import_record_id;
1276 }
1277
1278 sub _update_import_record_marc {
1279     my ($import_record_id, $marc_record) = @_;
1280
1281     my $dbh = C4::Context->dbh;
1282     my $sth = $dbh->prepare("UPDATE import_records SET marc = ?, marcxml = ?
1283                              WHERE  import_record_id = ?");
1284     $sth->execute($marc_record->as_usmarc(), $marc_record->as_xml(), $import_record_id);
1285     $sth->finish();
1286 }
1287
1288 sub _add_biblio_fields {
1289     my ($import_record_id, $marc_record) = @_;
1290
1291     my ($title, $author, $isbn, $issn) = _parse_biblio_fields($marc_record);
1292     my $dbh = C4::Context->dbh;
1293     # FIXME no controlnumber, originalsource
1294     $isbn = C4::Koha::_isbn_cleanup($isbn); # FIXME C4::Koha::_isbn_cleanup should be made public
1295     my $sth = $dbh->prepare("INSERT INTO import_biblios (import_record_id, title, author, isbn, issn) VALUES (?, ?, ?, ?, ?)");
1296     $sth->execute($import_record_id, $title, $author, $isbn, $issn);
1297     $sth->finish();
1298                 
1299 }
1300
1301 sub _update_biblio_fields {
1302     my ($import_record_id, $marc_record) = @_;
1303
1304     my ($title, $author, $isbn, $issn) = _parse_biblio_fields($marc_record);
1305     my $dbh = C4::Context->dbh;
1306     # FIXME no controlnumber, originalsource
1307     # FIXME 2 - should regularize normalization of ISBN wherever it is done
1308     $isbn =~ s/\(.*$//;
1309     $isbn =~ tr/ -_//;
1310     $isbn = uc $isbn;
1311     my $sth = $dbh->prepare("UPDATE import_biblios SET title = ?, author = ?, isbn = ?, issn = ?
1312                              WHERE  import_record_id = ?");
1313     $sth->execute($title, $author, $isbn, $issn, $import_record_id);
1314     $sth->finish();
1315 }
1316
1317 sub _parse_biblio_fields {
1318     my ($marc_record) = @_;
1319
1320     my $dbh = C4::Context->dbh;
1321     my $bibliofields = TransformMarcToKoha($dbh, $marc_record, '');
1322     return ($bibliofields->{'title'}, $bibliofields->{'author'}, $bibliofields->{'isbn'}, $bibliofields->{'issn'});
1323
1324 }
1325
1326 sub _update_batch_record_counts {
1327     my ($batch_id) = @_;
1328
1329     my $dbh = C4::Context->dbh;
1330     my $sth = $dbh->prepare_cached("UPDATE import_batches SET num_biblios = (
1331                                     SELECT COUNT(*)
1332                                     FROM import_records
1333                                     WHERE import_batch_id = import_batches.import_batch_id
1334                                     AND record_type = 'biblio')
1335                                     WHERE import_batch_id = ?");
1336     $sth->bind_param(1, $batch_id);
1337     $sth->execute();
1338     $sth->finish();
1339     $sth = $dbh->prepare_cached("UPDATE import_batches SET num_items = (
1340                                     SELECT COUNT(*)
1341                                     FROM import_records
1342                                     JOIN import_items USING (import_record_id)
1343                                     WHERE import_batch_id = import_batches.import_batch_id
1344                                     AND record_type = 'biblio')
1345                                     WHERE import_batch_id = ?");
1346     $sth->bind_param(1, $batch_id);
1347     $sth->execute();
1348     $sth->finish();
1349
1350 }
1351
1352 sub _get_commit_action {
1353     my ($overlay_action, $nomatch_action, $item_action, $overlay_status, $import_record_id) = @_;
1354     
1355     my ($bib_result, $bib_match, $item_result);
1356
1357     if ($overlay_status ne 'no_match') {
1358         $bib_match = GetBestRecordMatch($import_record_id);
1359         if ($overlay_action eq 'replace') {
1360             $bib_result  = defined($bib_match) ? 'replace' : 'create_new';
1361         } elsif ($overlay_action eq 'create_new') {
1362             $bib_result  = 'create_new';
1363         } elsif ($overlay_action eq 'ignore') {
1364             $bib_result  = 'ignore';
1365         } 
1366         $item_result = ($item_action eq 'always_add' or $item_action eq 'add_only_for_matches') ? 'create_new' : 'ignore';
1367     } else {
1368         $bib_result = $nomatch_action;
1369         $item_result = ($item_action eq 'always_add' or $item_action eq 'add_only_for_new')     ? 'create_new' : 'ignore';
1370     }
1371
1372     return ($bib_result, $item_result, $bib_match);
1373 }
1374
1375 sub _get_revert_action {
1376     my ($overlay_action, $overlay_status, $status) = @_;
1377
1378     my $bib_result;
1379
1380     if ($status eq 'ignored') {
1381         $bib_result = 'ignore';
1382     } else {
1383         if ($overlay_action eq 'create_new') {
1384             $bib_result = 'delete';
1385         } else {
1386             $bib_result = ($overlay_status eq 'match_applied') ? 'restore' : 'delete';
1387         }
1388     }
1389     return $bib_result;
1390 }
1391
1392 1;
1393 __END__
1394
1395 =head1 AUTHOR
1396
1397 Koha Development Team <info@koha.org>
1398
1399 Galen Charlton <galen.charlton@liblime.com>
1400
1401 =cut