Attachment #35050 for bug #12404

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




use C4::Koha; #marc2csv
use C4::XSLT ();
use YAML; #marcrecords2csv
use Template;
use Text::CSV::Encoded; #marc2csv

use vars qw($VERSION @ISA @EXPORT);


=cut


sub marcrecord2csv {
    my ($biblio, $id, $header, $csv, $fieldprocessing, $itemnumbers) = @_;
    my $output;

    # Getting the record
    my $record = GetMarcBiblio($biblio);
    return unless $record;
    C4::Biblio::EmbedItemsInMarcBiblio( $record, $biblio, $itemnumbers );
    # Getting the framework
    my $frameworkcode = GetFrameworkCode($biblio);

    my @marcfieldsarray = split('\|', $marcfieldslist);

   # Separating the marcfields from the user-supplied headers
    my @csv_structures;
    foreach (@marcfieldsarray) {
        my @result = split('=', $_);
        my $content = ( @result == 2 )
            ? $result[1]
            : $result[0];
        my @fields;
        while ( $content =~ m|(\d{3})\$?(.)?|g ) {
            my $fieldtag = $1;
            my $subfieldtag = $2 || undef;
            push @fields, { fieldtag => $fieldtag, subfieldtag => $subfieldtag };
        }
        if ( @result == 2) {
           push @csv_structures, { header => $result[0], content => $content, fields => \@fields };
        } else {
           push @csv_structures, { content => $content, fields => \@fields }
        }
    }

    my ( @marcfieldsheaders, @csv_rows );
    my $dbh = C4::Context->dbh;
	my @marcfieldsheaders;
	my $dbh   = C4::Context->dbh;

	# For each field or subfield
	foreach (@marcfields) {

	    my $field = $_->{field};
        # Remove any blank char that might have unintentionally insered into the tag name
        $field =~ s/\s+//g; 

	    # If we have a user-supplied header, we use it
	    if (exists $_->{header}) {
		    push @marcfieldsheaders, $_->{header};
	    } else {
		# If not, we get the matching tag name from koha
		if (index($field, '$') > 0) {
		    my ($fieldtag, $subfieldtag) = split('\$', $field);
		    my $query = "SELECT liblibrarian FROM marc_subfield_structure WHERE tagfield=? AND tagsubfield=?";
		    my $sth = $dbh->prepare($query);
		    $sth->execute($fieldtag, $subfieldtag);
		    my @results = $sth->fetchrow_array();
		    push @marcfieldsheaders, $results[0];
		} else {
		    my $query = "SELECT liblibrarian FROM marc_tag_structure WHERE tagfield=?";
		    my $sth = $dbh->prepare($query);
		    $sth->execute($field);
		    my @results = $sth->fetchrow_array();
		    push @marcfieldsheaders, $results[0];
		}
	    }
	}
	$csv->combine(@marcfieldsheaders);
	$output = $csv->string() . "\n";	
    }

    my $field_list;
    for my $field ( $record->fields ) {
        my $fieldtag = $field->tag;
        my $values;
        if ( $field->is_control_field ) {
            $values = $field->data();
        } else {
            $values->{indicator}{1} = $field->indicator(1);
            $values->{indicator}{2} = $field->indicator(2);
            for my $subfield ( $field->subfields ) {
                my $subfieldtag = $subfield->[0];
                my $value = $subfield->[1];
                push @{ $values->{$subfieldtag} }, $value;
            }
        }
        # We force the key as an integer (trick for 00X and OXX fields)
        push @{ $field_list->{fields}{0+$fieldtag} }, $values;
    }
		    my $authvalues = GetKohaAuthorisedValuesFromField($fieldtag, $subfieldtag, $frameworkcode, undef);
		    push @tmpfields, (defined $authvalues->{$subfield}) ? $authvalues->{$subfield} : $subfield;
		}
	    }
	    push (@fieldstab, join($subfieldseparator, @tmpfields));  		
	# Or a field
	} else {
	    my @fields = ($record->field($marcfield));
	    my $authvalues = GetKohaAuthorisedValuesFromField($marcfield, undef, $frameworkcode, undef);

    # For each field or subfield
    foreach my $csv_structure (@csv_structures) {
        my @field_values;
        my $tags = $csv_structure->{fields};
        my $content = $csv_structure->{content};

        if ( $header ) {
            # If we have a user-supplied header, we use it
            if ( exists $csv_structure->{header} ) {
                push @marcfieldsheaders, $csv_structure->{header};
            } else {
                # If not, we get the matching tag name from koha
                my $tag = $tags->[0];
                if ( $tag->{subfieldtag} ) {
                    my $query = "SELECT liblibrarian FROM marc_subfield_structure WHERE tagfield=? AND tagsubfield=?";
                    my @results = $dbh->selectrow_array( $query, {}, $tag->{subfieldtag} );
                    push @marcfieldsheaders, $results[0];
                } else {
                    my $query = "SELECT liblibrarian FROM marc_tag_structure WHERE tagfield=?";
                    my @results = $dbh->selectrow_array( $query, {}, $tag->{fieldtag} );
                    push @marcfieldsheaders, $results[0];
                }
                $value = join ($subfieldseparator, @subvaluesarray);
            }
        }

        # TT tags exist
        if ( $content =~ m|\[\%.*\%\]| ) {
            my $tt = Template->new();
            my $template = $content;
            my $vars;
            # Replace 00X and 0XX with X or XX
            $content =~ s|fields.00(\d)|fields.$1|g;
            $content =~ s|fields.0(\d{2})|fields.$1|g;
            my $tt_output;
            $tt->process( \$content, $field_list, \$tt_output );
            push @csv_rows, $tt_output;
        } else {
            for my $tag ( @$tags ) {
                my @fields = $record->field( $tag->{fieldtag} );
                # If it is a subfield
                my @loop_values;
                if ( $tag->{subfieldtag} ) {
                    # For each field
                    foreach my $field (@fields) {
                        my @subfields = $field->subfield( $tag->{subfieldtag} );
                        foreach my $subfield (@subfields) {
                            my $authvalues = GetKohaAuthorisedValuesFromField( $tag->{fieldtag}, $tag->{subfieldtag}, $frameworkcode, undef);
                            push @loop_values, (defined $authvalues->{$subfield}) ? $authvalues->{$subfield} : $subfield;
                        }
                    }

                # Or a field
                } else {
                    my $authvalues = GetKohaAuthorisedValuesFromField( $tag->{fieldtag}, undef, $frameworkcode, undef);

                    foreach my $field ( @fields ) {
                        my $value;

                        # If it is a control field
                        if ($field->is_control_field) {
                            $value = defined $authvalues->{$field->as_string} ? $authvalues->{$field->as_string} : $field->as_string;
                        } else {
                            # If it is a field, we gather all subfields, joined by the subfield separator
                            my @subvaluesarray;
                            my @subfields = $field->subfields;
                            foreach my $subfield (@subfields) {
                                push (@subvaluesarray, defined $authvalues->{$subfield->[1]} ? $authvalues->{$subfield->[1]} : $subfield->[1]);
                            }
                            $value = join ($subfieldseparator, @subvaluesarray);
                        }

                        # Field processing
                        my $marcfield = $tag->{fieldtag}; # This line fixes a retrocompatibility concern
                                                          # The "processing" could be based on the $marcfield variable.
                        eval $fieldprocessing if ($fieldprocessing);

                        push @loop_values, $value;
                    }

                }
                push @field_values, {
                    fieldtag => $tag->{fieldtag},
                    subfieldtag => $tag->{subfieldtag},
                    values => \@loop_values,
                };
            }
            for my $field_value ( @field_values ) {
                if ( $field_value->{subfieldtag} ) {
                    push @csv_rows, join( $subfieldseparator, @{ $field_value->{values} } );
                } else {
                    push @csv_rows, join( $fieldseparator, @{ $field_value->{values} } );
                }
            }
        }
    }
	 }
    };


    if ( $header ) {
        $csv->combine(@marcfieldsheaders);
        $output = $csv->string() . "\n";
    }
    $csv->combine(@csv_rows);
    $output .= $csv->string() . "\n";

    return $output;
- 

Return to bug 12404

Lines 33-38 use C4::Csv; #marc2csv Link Here

(-)a/C4/Record.pm (-89 / +129 lines)
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	-