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

(-)a/C4/MarcModificationTemplates.pm (-31 / +63 lines)
Lines 523-574 sub ModifyRecordWithTemplate { Link Here
523
            $field_value =~ s/__BRANCHCODE__/$branchcode/g;
523
            $field_value =~ s/__BRANCHCODE__/$branchcode/g;
524
        }
524
        }
525
525
526
        my @params = ( $record, $from_field, $from_subfield );
527
        if ( $action eq 'update_field' ) {
528
            push @params,
529
                ( $field_value
530
                    ? ( undef, $field_value )
531
                    : ()
532
                );
533
        } else {
534
            push @params,
535
                ( $field_value
536
                    ? $field_value
537
                    : ()
538
                );
539
        }
540
        push @params, (
541
                ( ( not $field_value and $to_field )
542
                    ? ( $to_field, $to_subfield, { search => $to_regex_search, replace => $to_regex_replace, modifiers => $to_regex_modifiers} )
543
                    : () ),
544
                ( $field_number
545
                    ? $field_number
546
                    : () )
547
        );
548
549
        my $do = 1;
526
        my $do = 1;
550
        if ( $conditional ) {
527
        if ( $conditional ) {
551
            for ( $conditional_comparison ) {
528
            for ( $conditional_comparison ) {
552
                when ( /^exists$/ ) {
529
                when ( /^exists$/ ) {
553
                    my $exists = field_exists( $record, $conditional_field, $conditional_subfield );
530
                    my $exists = field_exists({
531
                            record =>$record,
532
                            field => $conditional_field,
533
                            subfield => $conditional_subfield,
534
                        });
554
                    $do = $conditional eq 'if'
535
                    $do = $conditional eq 'if'
555
                        ? $exists
536
                        ? $exists
556
                        : not $exists;
537
                        : not $exists;
557
                }
538
                }
558
                when ( /^not_exists$/ ) {
539
                when ( /^not_exists$/ ) {
559
                    my $exists = field_exists( $record, $conditional_field, $conditional_subfield );
540
                    my $exists = field_exists({
541
                            record => $record,
542
                            field => $conditional_field,
543
                            subfield => $conditional_subfield
544
                        });
560
                    $do = $conditional eq 'if'
545
                    $do = $conditional eq 'if'
561
                        ? not $exists
546
                        ? not $exists
562
                        : $exists;
547
                        : $exists;
563
                }
548
                }
564
                when ( /^equals$/ ) {
549
                when ( /^equals$/ ) {
565
                    my $equals = field_equals( $record, $conditional_value, $conditional_field, $conditional_subfield, $conditional_regex );
550
                    my $equals = field_equals({
551
                        record => $record,
552
                        value => $conditional_value,
553
                        field => $conditional_field,
554
                        subfield => $conditional_subfield,
555
                        regex => $conditional_regex
556
                    });
566
                    $do = $conditional eq 'if'
557
                    $do = $conditional eq 'if'
567
                        ? $equals
558
                        ? $equals
568
                        : not $equals;
559
                        : not $equals;
569
                }
560
                }
570
                when ( /^not_equals$/ ) {
561
                when ( /^not_equals$/ ) {
571
                    my $equals = field_equals( $record, $conditional_value, $conditional_field, $conditional_subfield, $conditional_regex );
562
                    my $equals = field_equals({
563
                        record => $record,
564
                        value => $conditional_value,
565
                        field => $conditional_field,
566
                        subfield => $conditional_subfield,
567
                        regex => $conditional_regex
568
                    });
572
                    $do = $conditional eq 'if'
569
                    $do = $conditional eq 'if'
573
                        ? not $equals
570
                        ? not $equals
574
                        : $equals;
571
                        : $equals;
Lines 579-594 sub ModifyRecordWithTemplate { Link Here
579
        if ( $do ) {
576
        if ( $do ) {
580
            for ( $action ) {
577
            for ( $action ) {
581
                when ( /^copy_field$/ ) {
578
                when ( /^copy_field$/ ) {
582
                    copy_field( @params );
579
                    copy_field({
580
                        record => $record,
581
                        from_field => $from_field,
582
                        from_subfield => $from_subfield,
583
                        to_field => $to_field,
584
                        to_subfield => $to_subfield,
585
                        regex => {
586
                            search => $to_regex_search,
587
                            replace => $to_regex_replace,
588
                            modifiers => $to_regex_modifiers
589
                        },
590
                        n => $field_number,
591
                    });
583
                }
592
                }
593
584
                when ( /^update_field$/ ) {
594
                when ( /^update_field$/ ) {
585
                    update_field( @params );
595
                    update_field({
596
                        record => $record,
597
                        field => $from_field,
598
                        subfield => $from_subfield,
599
                        values => [ $field_value ],
600
                    });
586
                }
601
                }
587
                when ( /^move_field$/ ) {
602
                when ( /^move_field$/ ) {
588
                    move_field( @params );
603
                    move_field({
604
                        record => $record,
605
                        from_field => $from_field,
606
                        from_subfield => $from_subfield,
607
                        to_field => $to_field,
608
                        to_subfield => $to_subfield,
609
                        regex => {
610
                            search => $to_regex_search,
611
                            replace => $to_regex_replace,
612
                            modifiers => $to_regex_modifiers
613
                        },
614
                        n => $field_number,
615
                    });
589
                }
616
                }
590
                when ( /^delete_field$/ ) {
617
                when ( /^delete_field$/ ) {
591
                    delete_field( @params );
618
                    delete_field({
619
                        record => $record,
620
                        field => $from_field,
621
                        subfield => $from_subfield,
622
                        n => $field_number,
623
                    });
592
                }
624
                }
593
            }
625
            }
594
        }
626
        }
(-)a/Koha/SimpleMARC.pm (-12 / +50 lines)
Lines 73-83 at your option, any later version of Perl 5 you may have available. Link Here
73
=cut
73
=cut
74
74
75
sub copy_field {
75
sub copy_field {
76
  my ( $record, $fromFieldName, $fromSubfieldName, $toFieldName, $toSubfieldName, $regex, $n, $dont_erase ) = @_;
76
  my ( $params ) = @_;
77
  my $record = $params->{record};
78
  my $fromFieldName = $params->{from_field};
79
  my $fromSubfieldName = $params->{from_subfield};
80
  my $toFieldName = $params->{to_field};
81
  my $toSubfieldName = $params->{to_subfield};
82
  my $regex = $params->{regex};
83
  my $n = $params->{n};
84
  my $dont_erase = $params->{dont_erase};
77
85
78
  if ( ! ( $record && $fromFieldName && $toFieldName ) ) { return; }
86
  if ( ! ( $record && $fromFieldName && $toFieldName ) ) { return; }
79
87
80
  my @values = read_field( $record, $fromFieldName, $fromSubfieldName );
88
  my @values = read_field({ record => $record, field => $fromFieldName, subfield => $fromSubfieldName });
81
  @values = ( $values[$n-1] ) if ( $n );
89
  @values = ( $values[$n-1] ) if ( $n );
82
90
83
  if ( $regex and $regex->{search} ) {
91
  if ( $regex and $regex->{search} ) {
Lines 105-111 sub copy_field { Link Here
105
      }
113
      }
106
    }
114
    }
107
  }
115
  }
108
  update_field( $record, $toFieldName, $toSubfieldName, $dont_erase, @values );
116
  update_field({ record => $record, field => $toFieldName, subfield => $toSubfieldName, dont_erase => $dont_erase, values => \@values });
109
}
117
}
110
118
111
=head2 update_field
119
=head2 update_field
Lines 123-129 sub copy_field { Link Here
123
=cut
131
=cut
124
132
125
sub update_field {
133
sub update_field {
126
  my ( $record, $fieldName, $subfieldName, $dont_erase, @values ) = @_;
134
  my ( $params ) = @_;
135
  my $record = $params->{record};
136
  my $fieldName = $params->{field};
137
  my $subfieldName = $params->{subfield};
138
  my $dont_erase = $params->{dont_erase};
139
  my @values = @{ $params->{values} };
127
140
128
  if ( ! ( $record && $fieldName ) ) { return; }
141
  if ( ! ( $record && $fieldName ) ) { return; }
129
142
Lines 181-187 sub update_field { Link Here
181
=cut
194
=cut
182
195
183
sub read_field {
196
sub read_field {
184
  my ( $record, $fieldName, $subfieldName, $n ) = @_;
197
  my ( $params ) = @_;
198
  my $record = $params->{record};
199
  my $fieldName = $params->{field};
200
  my $subfieldName = $params->{subfield};
201
  my $n = $params->{n};
185
202
186
  my @fields = $record->field( $fieldName );
203
  my @fields = $record->field( $fieldName );
187
204
Lines 209-215 sub read_field { Link Here
209
=cut
226
=cut
210
227
211
sub field_exists {
228
sub field_exists {
212
  my ( $record, $fieldName, $subfieldName ) = @_;
229
  my ( $params ) = @_;
230
  my $record = $params->{record};
231
  my $fieldName = $params->{field};
232
  my $subfieldName = $params->{subfield};
213
233
214
  if ( ! $record ) { return; }
234
  if ( ! $record ) { return; }
215
235
Lines 238-249 sub field_exists { Link Here
238
=cut
258
=cut
239
259
240
sub field_equals {
260
sub field_equals {
241
  my ( $record, $value, $fieldName, $subfieldName, $regex, $n ) = @_;
261
  my ( $params ) = @_;
262
  my $record = $params->{record};
263
  my $value = $params->{value};
264
  my $fieldName = $params->{field};
265
  my $subfieldName = $params->{subfield};
266
  my $regex = $params->{regex};
267
  my $n = $params->{n};
242
  $n = 1 unless ( $n ); ## $n defaults to first field of a repeatable field series
268
  $n = 1 unless ( $n ); ## $n defaults to first field of a repeatable field series
243
269
244
  if ( ! $record ) { return; }
270
  if ( ! $record ) { return; }
245
271
246
  my @field_values = read_field( $record, $fieldName, $subfieldName, $n );
272
  my @field_values = read_field({ record => $record, field => $fieldName, subfield => $subfieldName, n => $n });
247
  my $field_value = $field_values[$n-1];
273
  my $field_value = $field_values[$n-1];
248
274
249
  if ( $regex ) {
275
  if ( $regex ) {
Lines 267-275 sub field_equals { Link Here
267
=cut
293
=cut
268
294
269
sub move_field {
295
sub move_field {
270
  my ( $record, $fromFieldName, $fromSubfieldName, $toFieldName, $toSubfieldName, $regex, $n ) = @_;
296
  my ( $params ) = @_;
271
  copy_field( $record, $fromFieldName, $fromSubfieldName, $toFieldName, $toSubfieldName, $regex, $n , 'dont_erase' );
297
  my $record = $params->{record};
272
  delete_field( $record, $fromFieldName, $fromSubfieldName, $n );
298
  my $fromFieldName = $params->{from_field};
299
  my $fromSubfieldName = $params->{from_subfield};
300
  my $toFieldName = $params->{to_field};
301
  my $toSubfieldName = $params->{to_subfield};
302
  my $regex = $params->{regex};
303
  my $n = $params->{n};
304
305
  copy_field({ record => $record, from_field => $fromFieldName, from_subfield => $fromSubfieldName, to_field => $toFieldName, to_subfield => $toSubfieldName, regex => $regex, n => $n , dont_erase => 1 });
306
  delete_field({ record => $record, field => $fromFieldName, subfield => $fromSubfieldName, n => $n });
273
}
307
}
274
308
275
=head2 delete_field
309
=head2 delete_field
Lines 284-290 sub move_field { Link Here
284
=cut
318
=cut
285
319
286
sub delete_field {
320
sub delete_field {
287
  my ( $record, $fieldName, $subfieldName, $n ) = @_;
321
  my ( $params ) = @_;
322
  my $record = $params->{record};
323
  my $fieldName = $params->{field};
324
  my $subfieldName = $params->{subfield};
325
  my $n = $params->{n};
288
326
289
  my @fields = $record->field( $fieldName );
327
  my @fields = $record->field( $fieldName );
290
328
(-)a/t/SimpleMARC.t (-68 / +65 lines)
Lines 40-47 sub new_record { Link Here
40
my $record = new_record;
40
my $record = new_record;
41
41
42
# field_exists
42
# field_exists
43
is( field_exists( $record, '650', 'a'), 'Computer programming.', '650$a exists' );
43
is( field_exists({ record => $record, field => '650', subfield => 'a' }), 'Computer programming.', '650$a exists' );
44
is( field_exists( $record, '650', 'b'), undef, '650$b does not exist' );
44
is( field_exists({ record => $record, field => '650', subfield => 'b' }), undef, '650$b does not exist' );
45
45
46
$record->append_fields(
46
$record->append_fields(
47
    MARC::Field->new(
47
    MARC::Field->new(
Lines 51-111 $record->append_fields( Link Here
51
    )
51
    )
52
);
52
);
53
53
54
is( field_exists( $record, '650', 'a'), 'Computer programming.', '650$a exists, field_exists returns the first one' );
54
is( field_exists({ record => $record, field => '650', subfield => 'a' }), 'Computer programming.', '650$a exists, field_exists returns the first one' );
55
55
56
# read_field
56
# read_field
57
my @fields_650a = read_field( $record, '650', 'a');
57
my @fields_650a = read_field({ record => $record, field => '650', subfield => 'a' });
58
is( $fields_650a[0], 'Computer programming.', 'first 650$a' );
58
is( $fields_650a[0], 'Computer programming.', 'first 650$a' );
59
is( $fields_650a[1], 'Computer algorithms.', 'second 650$a' );
59
is( $fields_650a[1], 'Computer algorithms.', 'second 650$a' );
60
is( read_field( $record, '650', 'a', 1 ), 'Computer programming.', 'first 650$a bis' );
60
is( read_field({ record => $record, field => '650', subfield => 'a', n => 1 }), 'Computer programming.', 'first 650$a bis' );
61
is( read_field( $record, '650', 'a', 2 ), 'Computer algorithms.', 'second 650$a bis' );
61
is( read_field({ record => $record, field => '650', subfield => 'a', n => 2 }), 'Computer algorithms.', 'second 650$a bis' );
62
is( read_field( $record, '650', 'a', 3 ), undef, 'There is no 3 650$a' );
62
is( read_field({ record => $record, field => '650', subfield => 'a', n => 3 }), undef, 'There is no 3 650$a' );
63
63
64
# copy_field
64
# copy_field
65
copy_field( $record, '245', 'a', '246', 'a' );
65
copy_field({ record => $record, from_field => '245', from_subfield => 'a', to_field => '246', to_subfield => 'a' });
66
is_deeply( read_field( $record, '245', 'a' ), 'The art of computer programming', 'After copy 245$a still exists' );
66
is_deeply( read_field({ record => $record, field => '245', subfield => 'a' }), 'The art of computer programming', 'After copy 245$a still exists' );
67
is_deeply( read_field( $record, '246', 'a' ), 'The art of computer programming', '246$a is a new field' );
67
is_deeply( read_field({ record => $record, field => '246', subfield => 'a' }), 'The art of computer programming', '246$a is a new field' );
68
delete_field( $record, '246' );
68
delete_field({ record => $record, field => '246' });
69
is( field_exists( $record, '246', 'a', '246$a does not exist anymore' ), undef );
69
is( field_exists({ record => $record, field => '246', subfield => 'a' }), undef, '246$a does not exist anymore' );
70
70
71
copy_field( $record, '650', 'a', '651', 'a' );
71
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a' });
72
my @fields_651a = read_field( $record, '651', 'a' );
72
my @fields_651a = read_field({ record =>  $record, field => '651', subfield => 'a' });
73
is_deeply( \@fields_651a, ['Computer programming.', 'Computer algorithms.'], 'Copy multivalued field' );
73
is_deeply( \@fields_651a, ['Computer programming.', 'Computer algorithms.'], 'Copy multivalued field' );
74
delete_field( $record, '651' );
74
delete_field({ record => $record, field => '651' });
75
75
76
copy_field( $record, '650', 'a', '651', 'a', undef, 1 );
76
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', n => 1 });
77
@fields_651a = read_field( $record, '651', 'a' );
77
is_deeply( read_field({record => $record, field => '651', subfield => 'a' }), 'Computer programming.', 'Copy first field 650$a' );
78
is_deeply( read_field( $record, '651', 'a' ), 'Computer programming.', 'Copy first field 650$a' );
78
delete_field({ record => $record, field => '652' });
79
delete_field( $record, '651' );
80
79
81
copy_field( $record, '650', 'a', '651', 'a', undef, 2 );
80
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', n => 2 });
82
@fields_651a = read_field( $record, '651', 'a' );
81
is_deeply( read_field({ record => $record, field => '651', subfield => 'a' }), 'Computer algorithms.', 'Copy second field 650$a' );
83
is_deeply( read_field( $record, '651', 'a' ), 'Computer algorithms.', 'Copy second field 650$a' );
82
delete_field({ record => $record, field => '651' });
84
delete_field( $record, '651' );
85
83
86
copy_field( $record, '650', 'a', '651', 'a', { search => 'Computer', replace => 'The art of' } );
84
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The art of' } } );
87
@fields_651a = read_field( $record, '651', 'a' );
85
@fields_651a = read_field({ record =>  $record, field => '651', subfield => 'a' });
88
is_deeply( \@fields_651a, ['The art of programming.', 'The art of algorithms.'], 'Copy field using regex' );
86
is_deeply( \@fields_651a, ['The art of programming.', 'The art of algorithms.'], 'Copy field using regex' );
89
87
90
copy_field( $record, '650', 'a', '651', 'a', { search => 'Computer', replace => 'The mistake of' } );
88
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The mistake of' } } );
91
@fields_651a = read_field( $record, '651', 'a' );
89
@fields_651a = read_field({ record =>  $record, field => '651', subfield => 'a' });
92
is_deeply( \@fields_651a, ['The mistake of programming.', 'The mistake of algorithms.'], 'Copy fields using regex on existing fields' );
90
is_deeply( \@fields_651a, ['The mistake of programming.', 'The mistake of algorithms.'], 'Copy fields using regex on existing fields' );
93
delete_field( $record, '651' );
91
delete_field({ record => $record, field => '651' });
94
92
95
copy_field( $record, '650', 'a', '651', 'a', { search => 'Computer', replace => 'The art of' } );
93
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The art of' } } );
96
copy_field( $record, '650', 'a', '651', 'a', { search => 'Computer', replace => 'The mistake of' }, 1, "dont_erase" );
94
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The mistake of' }, n => 1, dont_erase => 1 } );
97
@fields_651a = read_field( $record, '651', 'a' );
95
@fields_651a = read_field({ record => $record, field => '651', subfield => 'a' });
98
is_deeply( \@fields_651a, [
96
is_deeply( \@fields_651a, [
99
    'The art of programming.',
97
    'The art of programming.',
100
    'The mistake of programming.',
98
    'The mistake of programming.',
101
    'The art of algorithms.',
99
    'The art of algorithms.',
102
    'The mistake of programming.'
100
    'The mistake of programming.'
103
], 'Copy first field using regex on existing fields without erase existing values' );
101
], 'Copy first field using regex on existing fields without erase existing values' );
104
delete_field( $record, '651' );
102
delete_field({ record => $record, field => '651' });
105
103
106
copy_field( $record, '650', 'a', '651', 'a', { search => 'Computer', replace => 'The art of' } );
104
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The art of' }  });
107
copy_field( $record, '650', 'a', '651', 'a', { search => 'Computer', replace => 'The mistake of' }, undef , "dont_erase" );
105
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The mistake of' }, dont_erase => 1 });
108
@fields_651a = read_field( $record, '651', 'a' );
106
@fields_651a = read_field({ record =>  $record, field => '651', subfield => 'a' });
109
is_deeply( \@fields_651a, [
107
is_deeply( \@fields_651a, [
110
    'The art of programming.',
108
    'The art of programming.',
111
    'The mistake of programming.',
109
    'The mistake of programming.',
Lines 114-146 is_deeply( \@fields_651a, [ Link Here
114
    'The mistake of programming.',
112
    'The mistake of programming.',
115
    'The mistake of algorithms.'
113
    'The mistake of algorithms.'
116
], 'Copy fields using regex on existing fields without erase existing values' );
114
], 'Copy fields using regex on existing fields without erase existing values' );
117
delete_field( $record, '651' );
115
delete_field({ record => $record, field => '651' });
118
116
119
# Copy with regex modifiers
117
# Copy with regex modifiers
120
copy_field( $record, '650', 'a', '652', 'a', { search => 'o', replace => 'foo' } );
118
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '652', to_subfield => 'a', regex => { search => 'o', replace => 'foo' } });
121
my @fields_652a = read_field( $record, '652', 'a' );
119
my @fields_652a = read_field({ record => $record, field => '652', subfield => 'a' });
122
is_deeply( \@fields_652a, ['Cfoomputer programming.', 'Cfoomputer algorithms.'], 'Copy field using regex' );
120
is_deeply( \@fields_652a, ['Cfoomputer programming.', 'Cfoomputer algorithms.'], 'Copy field using regex' );
123
121
124
copy_field( $record, '650', 'a', '653', 'a', { search => 'o', replace => 'foo', modifiers => 'g' } );
122
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '653', to_subfield => 'a', regex => { search => 'o', replace => 'foo', modifiers => 'g' } });
125
my @fields_653a = read_field( $record, '653', 'a' );
123
my @fields_653a = read_field({ record =>  $record, field => '653', subfield => 'a' });
126
is_deeply( \@fields_653a, ['Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.'], 'Copy field using regex' );
124
is_deeply( \@fields_653a, ['Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.'], 'Copy field using regex' );
127
125
128
copy_field( $record, '650', 'a', '654', 'a', { search => 'O', replace => 'foo', modifiers => 'i' } );
126
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '654', to_subfield => 'a', regex => { search => 'O', replace => 'foo', modifiers => 'i' } });
129
my @fields_654a = read_field( $record, '654', 'a' );
127
my @fields_654a = read_field({ record =>  $record, field => '654', subfield => 'a' });
130
is_deeply( \@fields_654a, ['Cfoomputer programming.', 'Cfoomputer algorithms.'], 'Copy field using regex' );
128
is_deeply( \@fields_654a, ['Cfoomputer programming.', 'Cfoomputer algorithms.'], 'Copy field using regex' );
131
129
132
copy_field( $record, '650', 'a', '655', 'a', { search => 'O', replace => 'foo', modifiers => 'gi' } );
130
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '655', to_subfield => 'a', regex => { search => 'O', replace => 'foo', modifiers => 'gi' } });
133
my @fields_655a = read_field( $record, '655', 'a' );
131
my @fields_655a = read_field({ record =>  $record, field => '655', subfield => 'a' });
134
is_deeply( \@fields_655a, ['Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.'], 'Copy field using regex' );
132
is_deeply( \@fields_655a, ['Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.'], 'Copy field using regex' );
135
133
136
# update_field
134
# update_field
137
update_field( $record, '952', 'p', undef, '3010023918' );
135
update_field({ record => $record, field => '952', subfield => 'p', values => ['3010023918'] });
138
is_deeply( read_field( $record, '952', 'p' ), '3010023918', 'update existing subfield 952$p' );
136
is_deeply( read_field({ record => $record, field => '952', subfield => 'p' }), '3010023918', 'update existing subfield 952$p' );
139
delete_field( $record, '952' );
137
delete_field({ record => $record, field => '952' });
140
update_field( $record, '952', 'p', undef, '3010023918' );
138
update_field({ record => $record, field => '952', subfield => 'p', values => ['3010023918'] });
141
update_field( $record, '952', 'y', undef, 'BK' );
139
update_field({ record => $record, field => '952', subfield => 'y', values => ['BK'] });
142
is_deeply( read_field( $record, '952', 'p' ), '3010023918', 'create subfield 952$p' );
140
is_deeply( read_field({ record => $record, field => '952', subfield => 'p' }), '3010023918', 'create subfield 952$p' );
143
is_deeply( read_field( $record, '952', 'y' ), 'BK', 'create subfield 952$k on existing 952 field' );
141
is_deeply( read_field({ record => $record, field => '952', subfield => 'y' }), 'BK', 'create subfield 952$k on existing 952 field' );
144
$record->append_fields(
142
$record->append_fields(
145
    MARC::Field->new(
143
    MARC::Field->new(
146
        952, ' ', ' ',
144
        952, ' ', ' ',
Lines 148-159 $record->append_fields( Link Here
148
        y => 'BK',
146
        y => 'BK',
149
    ),
147
    ),
150
);
148
);
151
update_field( $record, '952', 'p', undef, '3010023919' );
149
update_field({ record => $record, field => '952', subfield => 'p', values => ['3010023919'] });
152
my @fields_952p = read_field( $record, '952', 'p' );
150
my @fields_952p = read_field({ record =>  $record, field => '952', subfield => 'p' });
153
is_deeply( \@fields_952p, ['3010023919', '3010023919'], 'update all subfields 952$p with the same value' );
151
is_deeply( \@fields_952p, ['3010023919', '3010023919'], 'update all subfields 952$p with the same value' );
154
152
155
update_field( $record, '952', 'p', undef, ('3010023917', '3010023918') );
153
update_field({ record => $record, field => '952', subfield => 'p', values => ['3010023917', '3010023918'] });
156
@fields_952p = read_field( $record, '952', 'p' );
154
@fields_952p = read_field({ record => $record, field => '952', subfield => 'p' });
157
is_deeply( \@fields_952p, ['3010023917', '3010023918'], 'update all subfields 952$p with the different values' );
155
is_deeply( \@fields_952p, ['3010023917', '3010023918'], 'update all subfields 952$p with the different values' );
158
156
159
# move_field
157
# move_field
Lines 166-184 $record->append_fields( Link Here
166
        y => 'BK',
164
        y => 'BK',
167
    ),
165
    ),
168
);
166
);
169
copy_field( $record, '952', 'd', '952', 'd' );
167
copy_field({ record => $record, from_field => '952', from_subfield => 'd', to_field => '952', to_subfield => 'd' });
170
@fields_952d = read_field( $record, '952', 'd' );
168
@fields_952d = read_field({ record =>  $record, field => '952', subfield => 'd' });
171
is_deeply( \@fields_952d, ['2001-06-25', '2001-06-25'], 'copy 952$d into others 952 field' );
169
is_deeply( \@fields_952d, ['2001-06-25', '2001-06-25'], 'copy 952$d into others 952 field' );
172
170
173
move_field( $record, '952', 'c', '954', 'c' );
171
move_field({ record => $record, from_field => '952', from_subfield => 'c', to_field => '954', to_subfield => 'c' });
174
@fields_952c = read_field( $record, '952', 'c' );
172
@fields_952c = read_field({ record =>  $record, field => '952', subfield => 'c' });
175
@fields_954c = read_field( $record, '954', 'c' );
173
@fields_954c = read_field({ record =>  $record, field => '954', subfield => 'c' });
176
is_deeply( \@fields_952c, [], 'The 952$c has moved' );
174
is_deeply( \@fields_952c, [], 'The 952$c has moved' );
177
is_deeply( \@fields_954c, ['GEN'], 'Now 954$c exists' );
175
is_deeply( \@fields_954c, ['GEN'], 'Now 954$c exists' );
178
176
179
move_field( $record, '952', 'p', '954', 'p', undef, 1 ); # Move the first field
177
move_field({ record => $record, from_field => '952', from_subfield => 'p', to_field => '954', to_subfield => 'p', n => 1 }); # Move the first field
180
@fields_952p = read_field( $record, '952', 'p' );
178
@fields_952p = read_field({ record =>  $record, field => '952', subfield => 'p' });
181
@fields_954p = read_field( $record, '954', 'p' );
179
@fields_954p = read_field({ record =>  $record, field => '954', subfield => 'p' });
182
is_deeply( \@fields_952p, ['3010023917'], 'One of 952$p has moved' );
180
is_deeply( \@fields_952p, ['3010023917'], 'One of 952$p has moved' );
183
is_deeply( \@fields_954p, ['3010023917'], 'Now 954$p exists' );
181
is_deeply( \@fields_954p, ['3010023917'], 'Now 954$p exists' );
184
182
Lines 191-199 $record->append_fields( Link Here
191
    ),
189
    ),
192
);
190
);
193
191
194
move_field( $record, '952', 'p', '954', 'p' ); # Move all field
192
move_field({ record => $record, from_field => '952', from_subfield => 'p', to_field => '954', to_subfield => 'p' }); # Move all field
195
@fields_952p = read_field( $record, '952', 'p' );
193
@fields_952p = read_field({ record =>  $record, field => '952', subfield => 'p' });
196
@fields_954p = read_field( $record, '954', 'p' );
194
@fields_954p = read_field({ record =>  $record, field => '954', subfield => 'p' });
197
is_deeply( \@fields_952p, [], 'All 952$p have moved' );
195
is_deeply( \@fields_952p, [], 'All 952$p have moved' );
198
is_deeply( \@fields_954p, ['3010023917', '3010023917'], 'Now 2 954$p exist' );
196
is_deeply( \@fields_954p, ['3010023917', '3010023917'], 'Now 2 954$p exist' );
199
197
200
- 

Return to bug 11319