View | Details | Raw Unified | Return to bug 12404
Collapse All | Expand All

(-)a/C4/Record.pm (-89 / +129 lines)
Lines 33-38 use C4::Csv; #marc2csv Link Here
33
use C4::Koha; #marc2csv
33
use C4::Koha; #marc2csv
34
use C4::XSLT ();
34
use C4::XSLT ();
35
use YAML; #marcrecords2csv
35
use YAML; #marcrecords2csv
36
use Template;
36
use Text::CSV::Encoded; #marc2csv
37
use Text::CSV::Encoded; #marc2csv
37
38
38
use vars qw($VERSION @ISA @EXPORT);
39
use vars qw($VERSION @ISA @EXPORT);
Lines 420-433 C<$itemnumbers> a list of itemnumbers to export Link Here
420
421
421
=cut
422
=cut
422
423
423
424
sub marcrecord2csv {
424
sub marcrecord2csv {
425
    my ($biblio, $id, $header, $csv, $fieldprocessing, $itemnumbers) = @_;
425
    my ($biblio, $id, $header, $csv, $fieldprocessing, $itemnumbers) = @_;
426
    my $output;
426
    my $output;
427
427
428
    # Getting the record
428
    # Getting the record
429
    my $record = GetMarcBiblio($biblio);
429
    my $record = GetMarcBiblio($biblio);
430
    next unless $record;
430
    return unless $record;
431
    C4::Biblio::EmbedItemsInMarcBiblio( $record, $biblio, $itemnumbers );
431
    C4::Biblio::EmbedItemsInMarcBiblio( $record, $biblio, $itemnumbers );
432
    # Getting the framework
432
    # Getting the framework
433
    my $frameworkcode = GetFrameworkCode($biblio);
433
    my $frameworkcode = GetFrameworkCode($biblio);
Lines 460-567 sub marcrecord2csv { Link Here
460
    my @marcfieldsarray = split('\|', $marcfieldslist);
460
    my @marcfieldsarray = split('\|', $marcfieldslist);
461
461
462
   # Separating the marcfields from the user-supplied headers
462
   # Separating the marcfields from the user-supplied headers
463
    my @marcfields;
463
    my @csv_structures;
464
    foreach (@marcfieldsarray) {
464
    foreach (@marcfieldsarray) {
465
        my @result = split('=', $_);
465
        my @result = split('=', $_);
466
        if (scalar(@result) == 2) {
466
        my $content = ( @result == 2 )
467
           push @marcfields, { header => $result[0], field => $result[1] }; 
467
            ? $result[1]
468
            : $result[0];
469
        my @fields;
470
        while ( $content =~ m|(\d{3})\$?(.)?|g ) {
471
            my $fieldtag = $1;
472
            my $subfieldtag = $2 || undef;
473
            push @fields, { fieldtag => $fieldtag, subfieldtag => $subfieldtag };
474
        }
475
        if ( @result == 2) {
476
           push @csv_structures, { header => $result[0], content => $content, fields => \@fields };
468
        } else {
477
        } else {
469
           push @marcfields, { field => $result[0] }
478
           push @csv_structures, { content => $content, fields => \@fields }
470
        }
479
        }
471
    }
480
    }
472
481
473
    # If we have to insert the headers
482
    my ( @marcfieldsheaders, @csv_rows );
474
    if ($header) {
483
    my $dbh = C4::Context->dbh;
475
	my @marcfieldsheaders;
476
	my $dbh   = C4::Context->dbh;
477
478
	# For each field or subfield
479
	foreach (@marcfields) {
480
481
	    my $field = $_->{field};
482
        # Remove any blank char that might have unintentionally insered into the tag name
483
        $field =~ s/\s+//g; 
484
485
	    # If we have a user-supplied header, we use it
486
	    if (exists $_->{header}) {
487
		    push @marcfieldsheaders, $_->{header};
488
	    } else {
489
		# If not, we get the matching tag name from koha
490
		if (index($field, '$') > 0) {
491
		    my ($fieldtag, $subfieldtag) = split('\$', $field);
492
		    my $query = "SELECT liblibrarian FROM marc_subfield_structure WHERE tagfield=? AND tagsubfield=?";
493
		    my $sth = $dbh->prepare($query);
494
		    $sth->execute($fieldtag, $subfieldtag);
495
		    my @results = $sth->fetchrow_array();
496
		    push @marcfieldsheaders, $results[0];
497
		} else {
498
		    my $query = "SELECT liblibrarian FROM marc_tag_structure WHERE tagfield=?";
499
		    my $sth = $dbh->prepare($query);
500
		    $sth->execute($field);
501
		    my @results = $sth->fetchrow_array();
502
		    push @marcfieldsheaders, $results[0];
503
		}
504
	    }
505
	}
506
	$csv->combine(@marcfieldsheaders);
507
	$output = $csv->string() . "\n";	
508
    }
509
484
510
    # For each marcfield to export
485
    my $field_list;
511
    my @fieldstab;
486
    for my $field ( $record->fields ) {
512
    foreach (@marcfields) {
487
        my $fieldtag = $field->tag;
513
	my $marcfield = $_->{field};
488
        my $values;
514
	# If it is a subfield
489
        if ( $field->is_control_field ) {
515
	if (index($marcfield, '$') > 0) {
490
            $values = $field->data();
516
	    my ($fieldtag, $subfieldtag) = split('\$', $marcfield);
491
        } else {
517
	    my @fields = $record->field($fieldtag);
492
            $values->{indicator}{1} = $field->indicator(1);
518
	    my @tmpfields;
493
            $values->{indicator}{2} = $field->indicator(2);
519
494
            for my $subfield ( $field->subfields ) {
520
	    # For each field
495
                my $subfieldtag = $subfield->[0];
521
	    foreach my $field (@fields) {
496
                my $value = $subfield->[1];
522
497
                push @{ $values->{$subfieldtag} }, $value;
523
		# We take every matching subfield
498
            }
524
		my @subfields = $field->subfield($subfieldtag);
499
        }
525
		foreach my $subfield (@subfields) {
500
        # We force the key as an integer (trick for 00X and OXX fields)
526
501
        push @{ $field_list->{fields}{0+$fieldtag} }, $values;
527
		    # Getting authorised value
502
    }
528
		    my $authvalues = GetKohaAuthorisedValuesFromField($fieldtag, $subfieldtag, $frameworkcode, undef);
529
		    push @tmpfields, (defined $authvalues->{$subfield}) ? $authvalues->{$subfield} : $subfield;
530
		}
531
	    }
532
	    push (@fieldstab, join($subfieldseparator, @tmpfields));  		
533
	# Or a field
534
	} else {
535
	    my @fields = ($record->field($marcfield));
536
	    my $authvalues = GetKohaAuthorisedValuesFromField($marcfield, undef, $frameworkcode, undef);
537
503
538
        my @valuesarray;
504
    # For each field or subfield
539
        foreach (@fields) {
505
    foreach my $csv_structure (@csv_structures) {
540
            my $value;
506
        my @field_values;
507
        my $tags = $csv_structure->{fields};
508
        my $content = $csv_structure->{content};
541
509
542
            # If it is a control field
510
        if ( $header ) {
543
            if ($_->is_control_field) {
511
            # If we have a user-supplied header, we use it
544
                $value = defined $authvalues->{$_->as_string} ? $authvalues->{$_->as_string} : $_->as_string;
512
            if ( exists $csv_structure->{header} ) {
513
                push @marcfieldsheaders, $csv_structure->{header};
545
            } else {
514
            } else {
546
                # If it is a field, we gather all subfields, joined by the subfield separator
515
                # If not, we get the matching tag name from koha
547
                my @subvaluesarray;
516
                my $tag = $tags->[0];
548
                my @subfields = $_->subfields;
517
                if ( $tag->{subfieldtag} ) {
549
                foreach my $subfield (@subfields) {
518
                    my $query = "SELECT liblibrarian FROM marc_subfield_structure WHERE tagfield=? AND tagsubfield=?";
550
                    push (@subvaluesarray, defined $authvalues->{$subfield->[1]} ? $authvalues->{$subfield->[1]} : $subfield->[1]);
519
                    my @results = $dbh->selectrow_array( $query, {}, $tag->{subfieldtag} );
520
                    push @marcfieldsheaders, $results[0];
521
                } else {
522
                    my $query = "SELECT liblibrarian FROM marc_tag_structure WHERE tagfield=?";
523
                    my @results = $dbh->selectrow_array( $query, {}, $tag->{fieldtag} );
524
                    push @marcfieldsheaders, $results[0];
551
                }
525
                }
552
                $value = join ($subfieldseparator, @subvaluesarray);
553
            }
526
            }
527
        }
554
528
555
            # Field processing
529
        # TT tags exist
556
            eval $fieldprocessing if ($fieldprocessing);
530
        if ( $content =~ m|\[\%.*\%\]| ) {
531
            my $tt = Template->new();
532
            my $template = $content;
533
            my $vars;
534
            # Replace 00X and 0XX with X or XX
535
            $content =~ s|fields.00(\d)|fields.$1|g;
536
            $content =~ s|fields.0(\d{2})|fields.$1|g;
537
            my $tt_output;
538
            $tt->process( \$content, $field_list, \$tt_output );
539
            push @csv_rows, $tt_output;
540
        } else {
541
            for my $tag ( @$tags ) {
542
                my @fields = $record->field( $tag->{fieldtag} );
543
                # If it is a subfield
544
                my @loop_values;
545
                if ( $tag->{subfieldtag} ) {
546
                    # For each field
547
                    foreach my $field (@fields) {
548
                        my @subfields = $field->subfield( $tag->{subfieldtag} );
549
                        foreach my $subfield (@subfields) {
550
                            my $authvalues = GetKohaAuthorisedValuesFromField( $tag->{fieldtag}, $tag->{subfieldtag}, $frameworkcode, undef);
551
                            push @loop_values, (defined $authvalues->{$subfield}) ? $authvalues->{$subfield} : $subfield;
552
                        }
553
                    }
554
555
                # Or a field
556
                } else {
557
                    my $authvalues = GetKohaAuthorisedValuesFromField( $tag->{fieldtag}, undef, $frameworkcode, undef);
558
559
                    foreach my $field ( @fields ) {
560
                        my $value;
561
562
                        # If it is a control field
563
                        if ($field->is_control_field) {
564
                            $value = defined $authvalues->{$field->as_string} ? $authvalues->{$field->as_string} : $field->as_string;
565
                        } else {
566
                            # If it is a field, we gather all subfields, joined by the subfield separator
567
                            my @subvaluesarray;
568
                            my @subfields = $field->subfields;
569
                            foreach my $subfield (@subfields) {
570
                                push (@subvaluesarray, defined $authvalues->{$subfield->[1]} ? $authvalues->{$subfield->[1]} : $subfield->[1]);
571
                            }
572
                            $value = join ($subfieldseparator, @subvaluesarray);
573
                        }
574
575
                        # Field processing
576
                        my $marcfield = $tag->{fieldtag}; # This line fixes a retrocompatibility concern
577
                                                          # The "processing" could be based on the $marcfield variable.
578
                        eval $fieldprocessing if ($fieldprocessing);
579
580
                        push @loop_values, $value;
581
                    }
557
582
558
            push @valuesarray, $value;
583
                }
584
                push @field_values, {
585
                    fieldtag => $tag->{fieldtag},
586
                    subfieldtag => $tag->{subfieldtag},
587
                    values => \@loop_values,
588
                };
589
            }
590
            for my $field_value ( @field_values ) {
591
                if ( $field_value->{subfieldtag} ) {
592
                    push @csv_rows, join( $subfieldseparator, @{ $field_value->{values} } );
593
                } else {
594
                    push @csv_rows, join( $fieldseparator, @{ $field_value->{values} } );
595
                }
596
            }
559
        }
597
        }
560
	    push (@fieldstab, join($fieldseparator, @valuesarray)); 
598
    }
561
	 }
562
    };
563
599
564
    $csv->combine(@fieldstab);
600
601
    if ( $header ) {
602
        $csv->combine(@marcfieldsheaders);
603
        $output = $csv->string() . "\n";
604
    }
605
    $csv->combine(@csv_rows);
565
    $output .= $csv->string() . "\n";
606
    $output .= $csv->string() . "\n";
566
607
567
    return $output;
608
    return $output;
568
- 

Return to bug 12404