| Lines 408-413
          sub marc_records_to_documents {
      
      
        Link Here | 
        
          | 408 |     my $control_fields_rules = $rules->{control_fields}; | 408 |     my $control_fields_rules = $rules->{control_fields}; | 
        
          | 409 |     my $data_fields_rules = $rules->{data_fields}; | 409 |     my $data_fields_rules = $rules->{data_fields}; | 
        
          | 410 |     my $marcflavour = lc C4::Context->preference('marcflavour'); | 410 |     my $marcflavour = lc C4::Context->preference('marcflavour'); | 
            
              |  |  | 411 |     my $use_array = C4::Context->preference('ElasticsearchMARCFormat') eq 'ARRAY'; | 
        
          | 411 |  | 412 |  | 
        
          | 412 |     my @record_documents; | 413 |     my @record_documents; | 
        
          | 413 |  | 414 |  | 
  
    | Lines 527-552
          sub marc_records_to_documents {
      
      
        Link Here | 
        
          | 527 |  | 528 |  | 
        
          | 528 |         # TODO: Perhaps should check if $records_document non empty, but really should never be the case | 529 |         # TODO: Perhaps should check if $records_document non empty, but really should never be the case | 
        
          | 529 |         $record->encoding('UTF-8'); | 530 |         $record->encoding('UTF-8'); | 
          
            
              | 530 |         my @warnings; | 531 |         if ($use_array) { | 
            
              | 531 |         { | 532 |             $record_document->{'marc_data_array'} = $self->_marc_to_array($record); | 
            
              | 532 |             # Temporarily intercept all warn signals (MARC::Record carps when record length > 99999) | 533 |             $record_document->{'marc_format'} = 'ARRAY'; | 
            
              | 533 |             local $SIG{__WARN__} = sub { | 534 |         } else { | 
            
              | 534 |                 push @warnings, $_[0]; | 535 |             my @warnings; | 
            
              | 535 |             }; | 536 |             { | 
            
              | 536 |             $record_document->{'marc_data'} = encode_base64(encode('UTF-8', $record->as_usmarc())); | 537 |                 # Temporarily intercept all warn signals (MARC::Record carps when record length > 99999) | 
            
              | 537 |         } | 538 |                 local $SIG{__WARN__} = sub { | 
            
              | 538 |         if (@warnings) { | 539 |                     push @warnings, $_[0]; | 
            
              | 539 |             # Suppress warnings if record length exceeded | 540 |                 }; | 
            
              | 540 |             unless (substr($record->leader(), 0, 5) eq '99999') { | 541 |                 $record_document->{'marc_data'} = encode_base64(encode('UTF-8', $record->as_usmarc())); | 
            
              | 541 |                 foreach my $warning (@warnings) { | 542 |             } | 
            
              | 542 |                     carp $warning; | 543 |             if (@warnings) { | 
            
              |  |  | 544 |                 # Suppress warnings if record length exceeded | 
            
              | 545 |                 unless (substr($record->leader(), 0, 5) eq '99999') { | 
            
              | 546 |                     foreach my $warning (@warnings) { | 
            
              | 547 |                         carp $warning; | 
            
              | 548 |                     } | 
        
          | 543 |                 } | 549 |                 } | 
            
              |  |  | 550 |                 $record_document->{'marc_data'} = $record->as_xml_record($marcflavour); | 
            
              | 551 |                 $record_document->{'marc_format'} = 'MARCXML'; | 
            
              | 552 |             } | 
            
              | 553 |             else { | 
            
              | 554 |                 $record_document->{'marc_format'} = 'base64ISO2709'; | 
        
          | 544 |             } | 555 |             } | 
            
              | 545 |             $record_document->{'marc_data'} = $record->as_xml_record($marcflavour); |  |  | 
            
              | 546 |             $record_document->{'marc_format'} = 'MARCXML'; | 
            
              | 547 |         } | 
            
              | 548 |         else { | 
            
              | 549 |             $record_document->{'marc_format'} = 'base64ISO2709'; | 
        
          | 550 |         } | 556 |         } | 
        
          | 551 |         my $id = $record->subfield('999', 'c'); | 557 |         my $id = $record->subfield('999', 'c'); | 
        
          | 552 |         push @record_documents, [$id, $record_document]; | 558 |         push @record_documents, [$id, $record_document]; | 
  
    | Lines 554-559
          sub marc_records_to_documents {
      
      
        Link Here | 
        
          | 554 |     return \@record_documents; | 560 |     return \@record_documents; | 
        
          | 555 | } | 561 | } | 
        
          | 556 |  | 562 |  | 
            
              |  |  | 563 | =head2 _marc_to_array($record) | 
            
              | 564 |  | 
            
              | 565 |     my @fields = _marc_to_array($record) | 
            
              | 566 |  | 
            
              | 567 | Convert a MARC::Record to an array modeled after MARC-in-JSON | 
            
              | 568 | (see https://github.com/marc4j/marc4j/wiki/MARC-in-JSON-Description) | 
            
              | 569 |  | 
            
              | 570 | =over 4 | 
            
              | 571 |  | 
            
              | 572 | =item C<$record> | 
            
              | 573 |  | 
            
              | 574 | A MARC::Record object | 
            
              | 575 |  | 
            
              | 576 | =back | 
            
              | 577 |  | 
            
              | 578 | =cut | 
            
              | 579 |  | 
            
              | 580 | sub _marc_to_array { | 
            
              | 581 |     my ($self, $record) = @_; | 
            
              | 582 |  | 
            
              | 583 |     my $data = { | 
            
              | 584 |         leader => $record->leader(), | 
            
              | 585 |         fields => [] | 
            
              | 586 |     }; | 
            
              | 587 |     for my $field ($record->fields()) { | 
            
              | 588 |         my $tag = $field->tag(); | 
            
              | 589 |         if ($field->is_control_field()) { | 
            
              | 590 |             push @{$data->{fields}}, {$tag => $field->data()}; | 
            
              | 591 |         } else { | 
            
              | 592 |             my $subfields = (); | 
            
              | 593 |             foreach my $subfield ($field->subfields()) { | 
            
              | 594 |                 my ($code, $contents) = @{$subfield}; | 
            
              | 595 |                 push @{$subfields}, {$code => $contents}; | 
            
              | 596 |             } | 
            
              | 597 |             push @{$data->{fields}}, { | 
            
              | 598 |                 $tag => { | 
            
              | 599 |                     ind1 => $field->indicator(1), | 
            
              | 600 |                     ind2 => $field->indicator(2), | 
            
              | 601 |                     subfields => $subfields | 
            
              | 602 |                 } | 
            
              | 603 |             }; | 
            
              | 604 |         } | 
            
              | 605 |     } | 
            
              | 606 |     return $data; | 
            
              | 607 | } | 
            
              | 608 |  | 
            
              | 609 | =head2 _array_to_marc($data) | 
            
              | 610 |  | 
            
              | 611 |     my $record = _array_to_marc($data) | 
            
              | 612 |  | 
            
              | 613 | Convert an array modeled after MARC-in-JSON to a MARC::Record | 
            
              | 614 |  | 
            
              | 615 | =over 4 | 
            
              | 616 |  | 
            
              | 617 | =item C<$data> | 
            
              | 618 |  | 
            
              | 619 | An array modeled after MARC-in-JSON | 
            
              | 620 | (see https://github.com/marc4j/marc4j/wiki/MARC-in-JSON-Description) | 
            
              | 621 |  | 
            
              | 622 | =back | 
            
              | 623 |  | 
            
              | 624 | =cut | 
            
              | 625 |  | 
            
              | 626 | sub _array_to_marc { | 
            
              | 627 |     my ($self, $data) = @_; | 
            
              | 628 |  | 
            
              | 629 |     my $record = MARC::Record->new(); | 
            
              | 630 |  | 
            
              | 631 |     $record->leader($data->{leader}); | 
            
              | 632 |     for my $field (@{$data->{fields}}) { | 
            
              | 633 |         my $tag = (keys %{$field})[0]; | 
            
              | 634 |         $field = $field->{$tag}; | 
            
              | 635 |         my $marc_field; | 
            
              | 636 |         if (ref($field) eq 'HASH') { | 
            
              | 637 |             my @subfields; | 
            
              | 638 |             foreach my $subfield (@{$field->{subfields}}) { | 
            
              | 639 |                 my $code = (keys %{$subfield})[0]; | 
            
              | 640 |                 push @subfields, $code; | 
            
              | 641 |                 push @subfields, $subfield->{$code}; | 
            
              | 642 |             } | 
            
              | 643 |             $marc_field = MARC::Field->new($tag, $field->{ind1}, $field->{ind2}, @subfields); | 
            
              | 644 |         } else { | 
            
              | 645 |             $marc_field = MARC::Field->new($tag, $field) | 
            
              | 646 |         } | 
            
              | 647 |         $record->append_fields($marc_field); | 
            
              | 648 |     } | 
            
              | 649 | ; | 
            
              | 650 |     return $record; | 
            
              | 651 | } | 
            
              | 652 |  | 
        
          | 557 | =head2 _field_mappings($facet, $suggestible, $sort, $target_name, $target_type, $range) | 653 | =head2 _field_mappings($facet, $suggestible, $sort, $target_name, $target_type, $range) | 
        
          | 558 |  | 654 |  | 
        
          | 559 |     my @mappings = _field_mappings($facet, $suggestible, $sort, $target_name, $target_type, $range) | 655 |     my @mappings = _field_mappings($facet, $suggestible, $sort, $target_name, $target_type, $range) |