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

(-)a/C4/MarcModificationTemplates.pm (-62 / +80 lines)
Lines 523-605 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
            if ( $conditional_comparison eq 'exists' ) {
528
            if ( $conditional_comparison eq 'exists' ) {
552
                my $exists = field_exists( $record, $conditional_field,
529
                my $exists = field_exists({
553
                    $conditional_subfield );
530
                        record =>$record,
554
                $do =
531
                        field => $conditional_field,
555
                    $conditional eq 'if'
532
                        subfield => $conditional_subfield,
556
                  ? $exists
533
                    });
557
                  : not $exists;
534
                $do = $conditional eq 'if'
535
                    ? $exists
536
                    : not $exists;
558
            }
537
            }
559
            elsif ( $conditional_comparison eq 'not_exists' ) {
538
            elsif ( $conditional_comparison eq 'not_exists' ) {
560
                my $exists = field_exists( $record, $conditional_field,
539
                my $exists = field_exists({
561
                    $conditional_subfield );
540
                        record => $record,
562
                $do =
541
                        field => $conditional_field,
563
                  $conditional eq 'if'
542
                        subfield => $conditional_subfield
564
                  ? not $exists
543
                    });
565
                  : $exists;
544
                $do = $conditional eq 'if'
545
                    ? not $exists
546
                    : $exists;
566
            }
547
            }
567
            elsif ( $conditional_comparison eq 'equals' ) {
548
            elsif ( $conditional_comparison eq 'equals' ) {
568
                my $equals = field_equals(
549
                my $equals = field_equals({
569
                    $record,            $conditional_value,
550
                    record => $record,
570
                    $conditional_field, $conditional_subfield,
551
                    value => $conditional_value,
571
                    $conditional_regex
552
                    field => $conditional_field,
572
                );
553
                    subfield => $conditional_subfield,
573
                $do =
554
                    regex => $conditional_regex
574
                    $conditional eq 'if'
555
                });
575
                  ? $equals
556
                $do = $conditional eq 'if'
576
                  : not $equals;
557
                    ? $equals
558
                    : not $equals;
577
            }
559
            }
578
            elsif ( $conditional_comparison eq 'not_equals' ) {
560
            elsif ( $conditional_comparison eq 'not_equals' ) {
579
                my $equals = field_equals(
561
                my $equals = field_equals({
580
                    $record,            $conditional_value,
562
                    record => $record,
581
                    $conditional_field, $conditional_subfield,
563
                    value => $conditional_value,
582
                    $conditional_regex
564
                    field => $conditional_field,
583
                );
565
                    subfield => $conditional_subfield,
584
                $do =
566
                    regex => $conditional_regex
585
                  $conditional eq 'if'
567
                });
586
                  ? not $equals
568
                $do = $conditional eq 'if'
587
                  : $equals;
569
                    ? not $equals
570
                    : $equals;
588
            }
571
            }
589
        }
572
        }
590
573
591
        if ($do) {
574
        if ( $do ) {
592
            if ( $action eq 'copy_field' ) {
575
            if ( $action eq 'copy_field' ) {
593
                copy_field(@params);
576
                copy_field({
577
                    record => $record,
578
                    from_field => $from_field,
579
                    from_subfield => $from_subfield,
580
                    to_field => $to_field,
581
                    to_subfield => $to_subfield,
582
                    regex => {
583
                        search => $to_regex_search,
584
                        replace => $to_regex_replace,
585
                        modifiers => $to_regex_modifiers
586
                    },
587
                    n => $field_number,
588
                });
594
            }
589
            }
595
            elsif ( $action eq 'update_field' ) {
590
596
                update_field(@params);
591
            elsif ( $action eq 'copy_field' ) {
592
                update_field({
593
                    record => $record,
594
                    field => $from_field,
595
                    subfield => $from_subfield,
596
                    values => [ $field_value ],
597
                });
597
            }
598
            }
598
            elsif ( $action eq 'move_field' ) {
599
            elsif ( $action eq 'copy_field' ) {
599
                move_field(@params);
600
                move_field({
601
                    record => $record,
602
                    from_field => $from_field,
603
                    from_subfield => $from_subfield,
604
                    to_field => $to_field,
605
                    to_subfield => $to_subfield,
606
                    regex => {
607
                        search => $to_regex_search,
608
                        replace => $to_regex_replace,
609
                        modifiers => $to_regex_modifiers
610
                    },
611
                    n => $field_number,
612
                });
600
            }
613
            }
601
            elsif ( $action eq 'delete_field' ) {
614
            elsif ( $action eq 'copy_field' ) {
602
                delete_field(@params);
615
                delete_field({
616
                    record => $record,
617
                    field => $from_field,
618
                    subfield => $from_subfield,
619
                    n => $field_number,
620
                });
603
            }
621
            }
604
        }
622
        }
605
623
(-)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 103-109 sub copy_field { Link Here
103
        }
111
        }
104
    }
112
    }
105
  }
113
  }
106
  update_field( $record, $toFieldName, $toSubfieldName, $dont_erase, @values );
114
  update_field({ record => $record, field => $toFieldName, subfield => $toSubfieldName, dont_erase => $dont_erase, values => \@values });
107
}
115
}
108
116
109
=head2 update_field
117
=head2 update_field
Lines 121-127 sub copy_field { Link Here
121
=cut
129
=cut
122
130
123
sub update_field {
131
sub update_field {
124
  my ( $record, $fieldName, $subfieldName, $dont_erase, @values ) = @_;
132
  my ( $params ) = @_;
133
  my $record = $params->{record};
134
  my $fieldName = $params->{field};
135
  my $subfieldName = $params->{subfield};
136
  my $dont_erase = $params->{dont_erase};
137
  my @values = @{ $params->{values} };
125
138
126
  if ( ! ( $record && $fieldName ) ) { return; }
139
  if ( ! ( $record && $fieldName ) ) { return; }
127
140
Lines 179-185 sub update_field { Link Here
179
=cut
192
=cut
180
193
181
sub read_field {
194
sub read_field {
182
  my ( $record, $fieldName, $subfieldName, $n ) = @_;
195
  my ( $params ) = @_;
196
  my $record = $params->{record};
197
  my $fieldName = $params->{field};
198
  my $subfieldName = $params->{subfield};
199
  my $n = $params->{n};
183
200
184
  my @fields = $record->field( $fieldName );
201
  my @fields = $record->field( $fieldName );
185
202
Lines 207-213 sub read_field { Link Here
207
=cut
224
=cut
208
225
209
sub field_exists {
226
sub field_exists {
210
  my ( $record, $fieldName, $subfieldName ) = @_;
227
  my ( $params ) = @_;
228
  my $record = $params->{record};
229
  my $fieldName = $params->{field};
230
  my $subfieldName = $params->{subfield};
211
231
212
  if ( ! $record ) { return; }
232
  if ( ! $record ) { return; }
213
233
Lines 236-247 sub field_exists { Link Here
236
=cut
256
=cut
237
257
238
sub field_equals {
258
sub field_equals {
239
  my ( $record, $value, $fieldName, $subfieldName, $regex, $n ) = @_;
259
  my ( $params ) = @_;
260
  my $record = $params->{record};
261
  my $value = $params->{value};
262
  my $fieldName = $params->{field};
263
  my $subfieldName = $params->{subfield};
264
  my $regex = $params->{regex};
265
  my $n = $params->{n};
240
  $n = 1 unless ( $n ); ## $n defaults to first field of a repeatable field series
266
  $n = 1 unless ( $n ); ## $n defaults to first field of a repeatable field series
241
267
242
  if ( ! $record ) { return; }
268
  if ( ! $record ) { return; }
243
269
244
  my @field_values = read_field( $record, $fieldName, $subfieldName, $n );
270
  my @field_values = read_field({ record => $record, field => $fieldName, subfield => $subfieldName, n => $n });
245
  my $field_value = $field_values[$n-1];
271
  my $field_value = $field_values[$n-1];
246
272
247
  if ( $regex ) {
273
  if ( $regex ) {
Lines 265-273 sub field_equals { Link Here
265
=cut
291
=cut
266
292
267
sub move_field {
293
sub move_field {
268
  my ( $record, $fromFieldName, $fromSubfieldName, $toFieldName, $toSubfieldName, $regex, $n ) = @_;
294
  my ( $params ) = @_;
269
  copy_field( $record, $fromFieldName, $fromSubfieldName, $toFieldName, $toSubfieldName, $regex, $n , 'dont_erase' );
295
  my $record = $params->{record};
270
  delete_field( $record, $fromFieldName, $fromSubfieldName, $n );
296
  my $fromFieldName = $params->{from_field};
297
  my $fromSubfieldName = $params->{from_subfield};
298
  my $toFieldName = $params->{to_field};
299
  my $toSubfieldName = $params->{to_subfield};
300
  my $regex = $params->{regex};
301
  my $n = $params->{n};
302
303
  copy_field({ record => $record, from_field => $fromFieldName, from_subfield => $fromSubfieldName, to_field => $toFieldName, to_subfield => $toSubfieldName, regex => $regex, n => $n , dont_erase => 1 });
304
  delete_field({ record => $record, field => $fromFieldName, subfield => $fromSubfieldName, n => $n });
271
}
305
}
272
306
273
=head2 delete_field
307
=head2 delete_field
Lines 282-288 sub move_field { Link Here
282
=cut
316
=cut
283
317
284
sub delete_field {
318
sub delete_field {
285
  my ( $record, $fieldName, $subfieldName, $n ) = @_;
319
  my ( $params ) = @_;
320
  my $record = $params->{record};
321
  my $fieldName = $params->{field};
322
  my $subfieldName = $params->{subfield};
323
  my $n = $params->{n};
286
324
287
  my @fields = $record->field( $fieldName );
325
  my @fields = $record->field( $fieldName );
288
326
(-)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