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

(-)a/C4/Biblio.pm (-136 / +62 lines)
Lines 1085-1097 sub GetMarcSubfieldStructure { Link Here
1085
    return $cached if $cached;
1085
    return $cached if $cached;
1086
1086
1087
    my $dbh = C4::Context->dbh;
1087
    my $dbh = C4::Context->dbh;
1088
    my $subfield_structure = $dbh->selectall_hashref( q|
1088
    # We moved to selectall_arrayref since selectall_hashref does not
1089
    # keep duplicate mappings on kohafield (like place in 260 vs 264)
1090
    my $subfield_aref = $dbh->selectall_arrayref( q|
1089
        SELECT *
1091
        SELECT *
1090
        FROM marc_subfield_structure
1092
        FROM marc_subfield_structure
1091
        WHERE frameworkcode = ?
1093
        WHERE frameworkcode = ?
1092
        AND kohafield > ''
1094
        AND kohafield > ''
1093
    |, 'kohafield', {}, $frameworkcode );
1095
        ORDER BY frameworkcode,tagfield,tagsubfield
1094
1096
    |, { Slice => {} }, $frameworkcode );
1097
    # Now map the output to a hash structure
1098
    my $subfield_structure = {};
1099
    foreach my $row ( @$subfield_aref ) {
1100
        push @{ $subfield_structure->{ $row->{kohafield} }}, $row;
1101
    }
1095
    $cache->set_in_cache( $cache_key, $subfield_structure );
1102
    $cache->set_in_cache( $cache_key, $subfield_structure );
1096
    return $subfield_structure;
1103
    return $subfield_structure;
1097
}
1104
}
Lines 1109-1115 sub GetMarcFromKohaField { Link Here
1109
    my ( $kohafield, $frameworkcode ) = @_;
1116
    my ( $kohafield, $frameworkcode ) = @_;
1110
    return (0, undef) unless $kohafield;
1117
    return (0, undef) unless $kohafield;
1111
    my $mss = GetMarcSubfieldStructure( $frameworkcode );
1118
    my $mss = GetMarcSubfieldStructure( $frameworkcode );
1112
    return ( $mss->{$kohafield}{tagfield}, $mss->{$kohafield}{tagsubfield} );
1119
    my @retval;
1120
    foreach( @{ $mss->{$kohafield} } ) {
1121
        push @retval, $_->{tagfield}, $_->{tagsubfield};
1122
    }
1123
    return wantarray ? @retval : $retval[0];
1113
}
1124
}
1114
1125
1115
=head2 GetMarcSubfieldStructureFromKohaField
1126
=head2 GetMarcSubfieldStructureFromKohaField
Lines 1118-1123 sub GetMarcFromKohaField { Link Here
1118
1129
1119
Returns a hashref where keys are marc_subfield_structure column names for the
1130
Returns a hashref where keys are marc_subfield_structure column names for the
1120
row where kohafield=$kohafield for the given framework code.
1131
row where kohafield=$kohafield for the given framework code.
1132
In list context returns a list of those hashrefs in case duplicate Koha to
1133
MARC mappings exist.
1121
1134
1122
$frameworkcode is optional. If not given, then the default framework is used.
1135
$frameworkcode is optional. If not given, then the default framework is used.
1123
1136
Lines 1129-1137 sub GetMarcSubfieldStructureFromKohaField { Link Here
1129
    return unless $kohafield;
1142
    return unless $kohafield;
1130
1143
1131
    my $mss = GetMarcSubfieldStructure( $frameworkcode );
1144
    my $mss = GetMarcSubfieldStructure( $frameworkcode );
1132
    return exists $mss->{$kohafield}
1145
    return unless $mss->{$kohafield};
1133
        ? $mss->{$kohafield}
1146
    return wantarray ? @{$mss->{$kohafield}} : $mss->{$kohafield}->[0];
1134
        : undef;
1135
}
1147
}
1136
1148
1137
=head2 GetMarcBiblio
1149
=head2 GetMarcBiblio
Lines 2140-2160 entry from user entry Link Here
2140
2152
2141
2153
2142
sub TransformKohaToMarc {
2154
sub TransformKohaToMarc {
2143
    my $hash = shift;
2155
    my ( $hash, $frameworkcode, $params ) = @_;
2144
    my $record = MARC::Record->new();
2156
    my $record = MARC::Record->new();
2145
    SetMarcUnicodeFlag( $record, C4::Context->preference("marcflavour") );
2157
    SetMarcUnicodeFlag( $record, C4::Context->preference("marcflavour") );
2146
    # FIXME Do not we want to get the marc subfield structure for the biblio framework?
2158
    # NOTE: Many older calls do not include a frameworkcode. In that case
2147
    my $mss = GetMarcSubfieldStructure();
2159
    # we default to Default framework.
2160
    my $mss = GetMarcSubfieldStructure( $frameworkcode//'' );
2148
    my $tag_hr = {};
2161
    my $tag_hr = {};
2149
    while ( my ($kohafield, $value) = each %$hash ) {
2162
    while ( my ($kohafield, $value) = each %$hash ) {
2150
        next unless exists $mss->{$kohafield};
2163
        foreach my $fld ( @{ $mss->{$kohafield} } ) {
2151
        next unless $mss->{$kohafield};
2164
            my $tagfield    = $fld->{tagfield};
2152
        my $tagfield    = $mss->{$kohafield}{tagfield} . '';
2165
            my $tagsubfield = $fld->{tagsubfield};
2153
        my $tagsubfield = $mss->{$kohafield}{tagsubfield};
2166
            next if !$tagfield;
2154
        foreach my $value ( split(/\s?\|\s?/, $value, -1) ) {
2167
            my @values = $params->{no_split}
2155
            next if $value eq '';
2168
                ? ( $value )
2156
            $tag_hr->{$tagfield} //= [];
2169
                : split(/\s?\|\s?/, $value, -1);
2157
            push @{$tag_hr->{$tagfield}}, [($tagsubfield, $value)];
2170
            foreach my $value ( @values ) {
2171
                next if $value eq '';
2172
                $tag_hr->{$tagfield} //= [];
2173
                push @{$tag_hr->{$tagfield}}, [($tagsubfield, $value)];
2174
            }
2158
        }
2175
        }
2159
    }
2176
    }
2160
    foreach my $tag (sort keys %$tag_hr) {
2177
    foreach my $tag (sort keys %$tag_hr) {
Lines 2542-2548 sub TransformMarcToKoha { Link Here
2542
        return $result;
2559
        return $result;
2543
    }
2560
    }
2544
    $limit_table = $limit_table || 0;
2561
    $limit_table = $limit_table || 0;
2545
    $frameworkcode = '' unless defined $frameworkcode;
2562
    $frameworkcode //= '';
2546
2563
2547
    my $inverted_field_map = _get_inverted_marc_field_map($frameworkcode);
2564
    my $inverted_field_map = _get_inverted_marc_field_map($frameworkcode);
2548
2565
Lines 2563-2576 sub TransformMarcToKoha { Link Here
2563
            my $kohafields = $inverted_field_map->{$tag}->{list};
2580
            my $kohafields = $inverted_field_map->{$tag}->{list};
2564
          ENTRY: foreach my $entry ( @{$kohafields} ) {
2581
          ENTRY: foreach my $entry ( @{$kohafields} ) {
2565
                my ( $subfield, $table, $column ) = @{$entry};
2582
                my ( $subfield, $table, $column ) = @{$entry};
2583
                my $value = $field->data;
2566
                next ENTRY unless exists $tables{$table};
2584
                next ENTRY unless exists $tables{$table};
2585
                next ENTRY if !$value;
2567
                my $key = _disambiguate( $table, $column );
2586
                my $key = _disambiguate( $table, $column );
2568
                if ( $result->{$key} ) {
2587
                if ( $result->{$key} ) {
2569
                    unless ( ( $key eq "biblionumber" or $key eq "biblioitemnumber" ) and ( $field->data() eq "" ) ) {
2588
                    $result->{$key} .= " | " . $value
2570
                        $result->{$key} .= " | " . $field->data();
2589
                        unless $result->{$key} eq $value;
2571
                    }
2572
                } else {
2590
                } else {
2573
                    $result->{$key} = $field->data();
2591
                    $result->{$key} = $value;
2574
                }
2592
                }
2575
            }
2593
            }
2576
        } else {
2594
        } else {
Lines 2583-2593 sub TransformMarcToKoha { Link Here
2583
              SFENTRY: foreach my $entry ( @{ $inverted_field_map->{$tag}->{sfs}->{$code} } ) {
2601
              SFENTRY: foreach my $entry ( @{ $inverted_field_map->{$tag}->{sfs}->{$code} } ) {
2584
                    my ( $table, $column ) = @{$entry};
2602
                    my ( $table, $column ) = @{$entry};
2585
                    next SFENTRY unless exists $tables{$table};
2603
                    next SFENTRY unless exists $tables{$table};
2604
                    next SFENTRY if !$value;
2586
                    my $key = _disambiguate( $table, $column );
2605
                    my $key = _disambiguate( $table, $column );
2587
                    if ( $result->{$key} ) {
2606
                    if ( $result->{$key} ) {
2588
                        unless ( ( $key eq "biblionumber" or $key eq "biblioitemnumber" ) and ( $value eq "" ) ) {
2607
                        $result->{$key} .= " | " . $value
2589
                            $result->{$key} .= " | " . $value;
2608
                            unless $result->{$key} eq $value;
2590
                        }
2591
                    } else {
2609
                    } else {
2592
                        $result->{$key} = $value;
2610
                        $result->{$key} = $value;
2593
                    }
2611
                    }
Lines 2628-2639 sub _get_inverted_marc_field_map { Link Here
2628
    my $mss = GetMarcSubfieldStructure( $frameworkcode );
2646
    my $mss = GetMarcSubfieldStructure( $frameworkcode );
2629
2647
2630
    foreach my $kohafield ( keys %{ $mss } ) {
2648
    foreach my $kohafield ( keys %{ $mss } ) {
2631
        next unless exists $mss->{$kohafield};    # not all columns are mapped to MARC tag & subfield
2649
        foreach my $fld ( @{ $mss->{$kohafield} } ) {
2632
        my $tag      = $mss->{$kohafield}{tagfield};
2650
            my $tag = $fld->{tagfield};
2633
        my $subfield = $mss->{$kohafield}{tagsubfield};
2651
            my $subfield = $fld->{tagsubfield};
2634
        my ( $table, $column ) = split /[.]/, $kohafield, 2;
2652
            my ( $table, $column ) = split /[.]/, $kohafield, 2;
2635
        push @{ $field_map->{$tag}->{list} }, [ $subfield, $table, $column ];
2653
            push @{ $field_map->{$tag}->{list} },
2636
        push @{ $field_map->{$tag}->{sfs}->{$subfield} }, [ $table, $column ];
2654
                [ $subfield, $table, $column ];
2655
            push @{ $field_map->{$tag}->{sfs}->{$subfield} },
2656
                [ $table, $column ];
2657
        }
2637
    }
2658
    }
2638
    return $field_map;
2659
    return $field_map;
2639
}
2660
}
Lines 2686-2803 sub _disambiguate { Link Here
2686
2707
2687
}
2708
}
2688
2709
2689
=head2 get_koha_field_from_marc
2690
2691
  $result->{_disambiguate($table, $field)} = 
2692
     get_koha_field_from_marc($table,$field,$record,$frameworkcode);
2693
2694
Internal function to map data from the MARC record to a specific non-MARC field.
2695
FIXME: this is meant to replace TransformMarcToKohaOneField after more testing.
2696
2697
=cut
2698
2699
sub get_koha_field_from_marc {
2700
    my ( $koha_table, $koha_column, $record, $frameworkcode ) = @_;
2701
    my ( $tagfield, $subfield ) = GetMarcFromKohaField( $koha_table . '.' . $koha_column, $frameworkcode );
2702
    my $kohafield;
2703
    foreach my $field ( $record->field($tagfield) ) {
2704
        if ( $field->tag() < 10 ) {
2705
            if ($kohafield) {
2706
                $kohafield .= " | " . $field->data();
2707
            } else {
2708
                $kohafield = $field->data();
2709
            }
2710
        } else {
2711
            if ( $field->subfields ) {
2712
                my @subfields = $field->subfields();
2713
                foreach my $subfieldcount ( 0 .. $#subfields ) {
2714
                    if ( $subfields[$subfieldcount][0] eq $subfield ) {
2715
                        if ($kohafield) {
2716
                            $kohafield .= " | " . $subfields[$subfieldcount][1];
2717
                        } else {
2718
                            $kohafield = $subfields[$subfieldcount][1];
2719
                        }
2720
                    }
2721
                }
2722
            }
2723
        }
2724
    }
2725
    return $kohafield;
2726
}
2727
2728
=head2 TransformMarcToKohaOneField
2710
=head2 TransformMarcToKohaOneField
2729
2711
2730
  $result = TransformMarcToKohaOneField( $kohatable, $kohafield, $record, $result, $frameworkcode )
2712
    $value = TransformMarcToKohaOneField( 'biblio.title', $record, $frameworkcode );
2731
2713
2732
=cut
2714
=cut
2733
2715
2734
sub TransformMarcToKohaOneField {
2716
sub TransformMarcToKohaOneField {
2735
2717
    my ( $kohafield, $marc, $frameworkcode ) = @_;
2736
    # FIXME ? if a field has a repeatable subfield that is used in old-db,
2718
2737
    # only the 1st will be retrieved...
2719
    # It is not really useful to repeat all code from TransformMarcToKoha here.
2738
    my ( $kohatable, $kohafield, $record, $result, $frameworkcode ) = @_;
2720
    # Since it is fast enough (by caching), we just extract the field.
2739
    my $res = "";
2721
    my $koharec = TransformMarcToKoha( $marc, $frameworkcode );
2740
    my ( $tagfield, $subfield ) = GetMarcFromKohaField( $kohatable . "." . $kohafield, $frameworkcode );
2722
    my @temp = split /\./, $kohafield, 2;
2741
    foreach my $field ( $record->field($tagfield) ) {
2723
    $kohafield = _disambiguate( @temp ) if @temp > 1;
2742
        if ( $field->tag() < 10 ) {
2724
    return $koharec ? $koharec->{$kohafield} : undef;
2743
            if ( $result->{$kohafield} ) {
2744
                $result->{$kohafield} .= " | " . $field->data();
2745
            } else {
2746
                $result->{$kohafield} = $field->data();
2747
            }
2748
        } else {
2749
            if ( $field->subfields ) {
2750
                my @subfields = $field->subfields();
2751
                foreach my $subfieldcount ( 0 .. $#subfields ) {
2752
                    if ( $subfields[$subfieldcount][0] eq $subfield ) {
2753
                        if ( $result->{$kohafield} ) {
2754
                            $result->{$kohafield} .= " | " . $subfields[$subfieldcount][1];
2755
                        } else {
2756
                            $result->{$kohafield} = $subfields[$subfieldcount][1];
2757
                        }
2758
                    }
2759
                }
2760
            }
2761
        }
2762
    }
2763
    return $result;
2764
}
2725
}
2765
2726
2766
2767
#"
2768
2769
#
2770
# true ModZebra commented until indexdata fixes zebraDB crashes (it seems they occur on multiple updates
2771
# at the same time
2772
# replaced by a zebraqueue table, that is filled with ModZebra to run.
2773
# the table is emptied by misc/cronjobs/zebraqueue_start.pl script
2774
# =head2 ModZebrafiles
2775
#
2776
# &ModZebrafiles( $dbh, $biblionumber, $record, $folder, $server );
2777
#
2778
# =cut
2779
#
2780
# sub ModZebrafiles {
2781
#
2782
#     my ( $dbh, $biblionumber, $record, $folder, $server ) = @_;
2783
#
2784
#     my $op;
2785
#     my $zebradir =
2786
#       C4::Context->zebraconfig($server)->{directory} . "/" . $folder . "/";
2787
#     unless ( opendir( DIR, "$zebradir" ) ) {
2788
#         warn "$zebradir not found";
2789
#         return;
2790
#     }
2791
#     closedir DIR;
2792
#     my $filename = $zebradir . $biblionumber;
2793
#
2794
#     if ($record) {
2795
#         open( OUTPUT, ">", $filename . ".xml" );
2796
#         print OUTPUT $record;
2797
#         close OUTPUT;
2798
#     }
2799
# }
2800
2801
=head2 ModZebra
2727
=head2 ModZebra
2802
2728
2803
  ModZebra( $biblionumber, $op, $server, $record );
2729
  ModZebra( $biblionumber, $op, $server, $record );
(-)a/C4/Breeding.pm (-3 / +1 lines)
Lines 332-340 sub _add_rowdata { Link Here
332
        date2 => 'biblioitems.publicationyear', #UNIMARC
332
        date2 => 'biblioitems.publicationyear', #UNIMARC
333
    );
333
    );
334
    foreach my $k (keys %fetch) {
334
    foreach my $k (keys %fetch) {
335
        my ($t, $f)= split '\.', $fetch{$k};
335
        $row->{$k} = C4::Biblio::TransformMarcToKohaOneField( $fetch{$k}, $record, q{} ); # default framework
336
        $row= C4::Biblio::TransformMarcToKohaOneField($t, $f, $record, $row);
337
        $row->{$k}= $row->{$f} if $k ne $f;
338
    }
336
    }
339
    $row->{date}//= $row->{date2};
337
    $row->{date}//= $row->{date2};
340
    $row->{isbn}=_isbn_replace($row->{isbn});
338
    $row->{isbn}=_isbn_replace($row->{isbn});
(-)a/C4/Items.pm (-2 / +7 lines)
Lines 1493-1500 sub Item2Marc { Link Here
1493
            defined($itemrecord->{$_}) && $itemrecord->{$_} ne '' ? ("items.$_" => $itemrecord->{$_}) : ()  
1493
            defined($itemrecord->{$_}) && $itemrecord->{$_} ne '' ? ("items.$_" => $itemrecord->{$_}) : ()  
1494
        } keys %{ $itemrecord } 
1494
        } keys %{ $itemrecord } 
1495
    };
1495
    };
1496
    my $itemmarc = TransformKohaToMarc($mungeditem);
1496
    my $framework = GetFrameworkCode( $biblionumber );
1497
    my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField("items.itemnumber",GetFrameworkCode($biblionumber)||'');
1497
    my $itemmarc = TransformKohaToMarc(
1498
        $mungeditem, $framework, { no_split => 1},
1499
    );
1500
    my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField(
1501
        "items.itemnumber", $framework,
1502
    );
1498
1503
1499
    my $unlinked_item_subfields = _parse_unlinked_item_subfields_from_xml($mungeditem->{'items.more_subfields_xml'});
1504
    my $unlinked_item_subfields = _parse_unlinked_item_subfields_from_xml($mungeditem->{'items.more_subfields_xml'});
1500
    if (defined $unlinked_item_subfields and $#$unlinked_item_subfields > -1) {
1505
    if (defined $unlinked_item_subfields and $#$unlinked_item_subfields > -1) {
(-)a/C4/Ris.pm (-1 lines)
Lines 65-71 use Modern::Perl; Link Here
65
use List::MoreUtils qw/uniq/;
65
use List::MoreUtils qw/uniq/;
66
use vars qw(@ISA @EXPORT);
66
use vars qw(@ISA @EXPORT);
67
67
68
use C4::Biblio qw(GetMarcSubfieldStructureFromKohaField);
69
use Koha::SimpleMARC qw(read_field);
68
use Koha::SimpleMARC qw(read_field);
70
69
71
70
(-)a/C4/XISBN.pm (-1 / +3 lines)
Lines 72-78 sub _get_biblio_from_xisbn { Link Here
72
    return unless ( !$errors && scalar @$results );
72
    return unless ( !$errors && scalar @$results );
73
73
74
    my $record = C4::Search::new_record_from_zebra( 'biblioserver', $results->[0] );
74
    my $record = C4::Search::new_record_from_zebra( 'biblioserver', $results->[0] );
75
    my $biblionumber = C4::Biblio::get_koha_field_from_marc('biblio', 'biblionumber', $record, '');
75
    my $biblionumber = C4::Biblio::TransformMarcToKohaOneField(
76
        'biblio.biblionumber', $record, # Default framework used
77
    );
76
    return unless $biblionumber;
78
    return unless $biblionumber;
77
79
78
    my $biblio = Koha::Biblios->find( $biblionumber );
80
    my $biblio = Koha::Biblios->find( $biblionumber );
(-)a/Koha/MetadataRecord.pm (-21 / +7 lines)
Lines 109-137 sub createMergeHash { Link Here
109
    }
109
    }
110
}
110
}
111
111
112
=head2 getKohaField
113
114
    $metadata->{$key} = $record->getKohaField($kohafield);
115
116
=cut
117
112
sub getKohaField {
118
sub getKohaField {
113
    my ($self, $kohafield) = @_;
119
    my ($self, $kohafield) = @_;
114
115
    if ($self->schema =~ m/marc/) {
120
    if ($self->schema =~ m/marc/) {
116
        my $frameworkcode = ""; # FIXME Why do we use the default framework?
121
        return C4::Biblio::TransformMarcToKohaOneField($kohafield, $self->record); # Default framework used
117
        my $mss = C4::Biblio::GetMarcSubfieldStructure( $frameworkcode );
118
        my $tagfield = $mss->{$kohafield};
119
120
        return '' if ref($tagfield) ne 'HASH';
121
122
        my ($tag, $subfield) = ( $tagfield->{tagfield}, $tagfield->{tagsubfield} );
123
        my @kohafield;
124
        foreach my $field ( $self->record->field($tag) ) {
125
            if ( $field->tag() < 10 ) {
126
                push @kohafield, $field->data();
127
            } else {
128
                foreach my $contents ( $field->subfield($subfield) ) {
129
                    push @kohafield, $contents;
130
                }
131
            }
132
        }
133
134
        return join ' | ', @kohafield;
135
    }
122
    }
136
}
123
}
137
124
138
- 

Return to bug 10306