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