| 
      
            Lines 80-86
          sub copy_field {
      
      
        Link Here
      
     | 
  
        
          | 80 | 
              my $toFieldName = $params->{to_field}; | 
          80 | 
              my $toFieldName = $params->{to_field}; | 
        
        
          | 81 | 
              my $toSubfieldName = $params->{to_subfield}; | 
          81 | 
              my $toSubfieldName = $params->{to_subfield}; | 
        
        
          | 82 | 
              my $regex = $params->{regex}; | 
          82 | 
              my $regex = $params->{regex}; | 
        
          
            
              | 83 | 
                  my $n = $params->{n}; | 
              83 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 84 | 
           | 
          84 | 
           | 
        
        
          | 85 | 
              if ( ! ( $record && $fromFieldName && $toFieldName ) ) { return; } | 
          85 | 
              if ( ! ( $record && $fromFieldName && $toFieldName ) ) { return; } | 
        
        
          | 86 | 
           | 
          86 | 
           | 
        
  
    | 
      
            Lines 93-99
          sub copy_field {
      
      
        Link Here
      
     | 
  
        
          | 93 | 
                      from_field => $fromFieldName,  | 
          93 | 
                      from_field => $fromFieldName,  | 
        
        
          | 94 | 
                      to_field => $toFieldName,  | 
          94 | 
                      to_field => $toFieldName,  | 
        
        
          | 95 | 
                      regex => $regex,  | 
          95 | 
                      regex => $regex,  | 
        
          
            
              | 96 | 
                          n => $n  | 
              96 | 
                          field_numbers => $field_numbers,  | 
            
        
          | 97 | 
                  });  | 
          97 | 
                  });  | 
        
        
          | 98 | 
              } else { | 
          98 | 
              } else { | 
        
        
          | 99 | 
                  _copy_subfield({ | 
          99 | 
                  _copy_subfield({ | 
        
  
    | 
      
            Lines 103-109
          sub copy_field {
      
      
        Link Here
      
     | 
  
        
          | 103 | 
                      to_field => $toFieldName,  | 
          103 | 
                      to_field => $toFieldName,  | 
        
        
          | 104 | 
                      to_subfield => $toSubfieldName,  | 
          104 | 
                      to_subfield => $toSubfieldName,  | 
        
        
          | 105 | 
                      regex => $regex,  | 
          105 | 
                      regex => $regex,  | 
        
          
            
              | 106 | 
                          n => $n  | 
              106 | 
                          field_numbers => $field_numbers,  | 
            
        
          | 107 | 
                  });  | 
          107 | 
                  });  | 
        
        
          | 108 | 
              }  | 
          108 | 
              }  | 
        
        
          | 109 | 
           | 
          109 | 
           | 
        
  
    | 
      
            Lines 115-128
          sub _copy_field {
      
      
        Link Here
      
     | 
  
        
          | 115 | 
              my $fromFieldName = $params->{from_field}; | 
          115 | 
              my $fromFieldName = $params->{from_field}; | 
        
        
          | 116 | 
              my $toFieldName = $params->{to_field}; | 
          116 | 
              my $toFieldName = $params->{to_field}; | 
        
        
          | 117 | 
              my $regex = $params->{regex}; | 
          117 | 
              my $regex = $params->{regex}; | 
        
          
            
              | 118 | 
                  my $n = $params->{n}; | 
              118 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 119 | 
           | 
          119 | 
           | 
        
        
          | 120 | 
              _copy_move_field({ | 
          120 | 
              _copy_move_field({ | 
        
        
          | 121 | 
                  record => $record,  | 
          121 | 
                  record => $record,  | 
        
        
          | 122 | 
                  from_field => $fromFieldName,  | 
          122 | 
                  from_field => $fromFieldName,  | 
        
        
          | 123 | 
                  to_field => $toFieldName,  | 
          123 | 
                  to_field => $toFieldName,  | 
        
        
          | 124 | 
                  regex => $regex,  | 
          124 | 
                  regex => $regex,  | 
        
          
            
              | 125 | 
                      n => $n  | 
              125 | 
                      field_numbers => $field_numbers,  | 
            
        
          | 126 | 
              });  | 
          126 | 
              });  | 
        
        
          | 127 | 
          }  | 
          127 | 
          }  | 
        
        
          | 128 | 
           | 
          128 | 
           | 
        
  
    | 
      
            Lines 134-143
          sub _copy_subfield {
      
      
        Link Here
      
     | 
  
        
          | 134 | 
              my $toFieldName = $params->{to_field}; | 
          134 | 
              my $toFieldName = $params->{to_field}; | 
        
        
          | 135 | 
              my $toSubfieldName = $params->{to_subfield}; | 
          135 | 
              my $toSubfieldName = $params->{to_subfield}; | 
        
        
          | 136 | 
              my $regex = $params->{regex}; | 
          136 | 
              my $regex = $params->{regex}; | 
        
          
            
              | 137 | 
                  my $n = $params->{n}; | 
              137 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 138 | 
           | 
          138 | 
           | 
        
        
          | 139 | 
              my @values = read_field({ record => $record, field => $fromFieldName, subfield => $fromSubfieldName }); | 
          139 | 
              my @values = read_field({ record => $record, field => $fromFieldName, subfield => $fromSubfieldName }); | 
        
          
            
              | 140 | 
                  @values = ( $values[$n-1] ) if ( $n );  | 
              140 | 
                  if ( @$field_numbers ) { | 
            
            
               | 
               | 
              141 | 
                      @values = map { $_ <= @values ? $values[ $_ - 1 ] : () } @$field_numbers; | 
            
            
              | 142 | 
                  }  | 
            
        
          | 141 | 
              _modify_values({ values => \@values, regex => $regex }); | 
          143 | 
              _modify_values({ values => \@values, regex => $regex }); | 
        
        
          | 142 | 
           | 
          144 | 
           | 
        
        
          | 143 | 
              update_field({ record => $record, field => $toFieldName, subfield => $toSubfieldName, values => \@values }); | 
          145 | 
              update_field({ record => $record, field => $toFieldName, subfield => $toSubfieldName, values => \@values }); | 
        
  
    | 
      
            Lines 149-154
          sub update_field {
      
      
        Link Here
      
     | 
  
        
          | 149 | 
              my $fieldName = $params->{field}; | 
          151 | 
              my $fieldName = $params->{field}; | 
        
        
          | 150 | 
              my $subfieldName = $params->{subfield}; | 
          152 | 
              my $subfieldName = $params->{subfield}; | 
        
        
          | 151 | 
              my @values = @{ $params->{values} }; | 
          153 | 
              my @values = @{ $params->{values} }; | 
        
            
               | 
               | 
              154 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 152 | 
           | 
          155 | 
           | 
        
        
          | 153 | 
              if ( ! ( $record && $fieldName ) ) { return; } | 
          156 | 
              if ( ! ( $record && $fieldName ) ) { return; } | 
        
        
          | 154 | 
           | 
          157 | 
           | 
        
  
    | 
      
            Lines 157-163
          sub update_field {
      
      
        Link Here
      
     | 
  
        
          | 157 | 
                  die "This action is not implemented yet";  | 
          160 | 
                  die "This action is not implemented yet";  | 
        
        
          | 158 | 
                  #_update_field({ record => $record, field => $fieldName, values => \@values }); | 
          161 | 
                  #_update_field({ record => $record, field => $fieldName, values => \@values }); | 
        
        
          | 159 | 
              } else { | 
          162 | 
              } else { | 
        
          
            
              | 160 | 
                      _update_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, values => \@values }); | 
              163 | 
                      _update_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, values => \@values, field_numbers => $field_numbers }); | 
            
        
          | 161 | 
              }  | 
          164 | 
              }  | 
        
        
          | 162 | 
          }  | 
          165 | 
          }  | 
        
        
          | 163 | 
           | 
          166 | 
           | 
        
  
    | 
      
            Lines 194-202
          sub _update_subfield {
      
      
        Link Here
      
     | 
  
        
          | 194 | 
              my $subfieldName = $params->{subfield}; | 
          197 | 
              my $subfieldName = $params->{subfield}; | 
        
        
          | 195 | 
              my @values = @{ $params->{values} }; | 
          198 | 
              my @values = @{ $params->{values} }; | 
        
        
          | 196 | 
              my $dont_erase = $params->{dont_erase}; | 
          199 | 
              my $dont_erase = $params->{dont_erase}; | 
        
            
               | 
               | 
              200 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 197 | 
              my $i = 0;  | 
          201 | 
              my $i = 0;  | 
        
        
          | 198 | 
           | 
          202 | 
           | 
        
          
            
              | 199 | 
                  if ( my @fields = $record->field( $fieldName ) ) { | 
              203 | 
                  my @fields = $record->field( $fieldName );  | 
            
            
               | 
               | 
              204 | 
               | 
            
            
              | 205 | 
                  if ( @$field_numbers ) { | 
            
            
              | 206 | 
                      @fields = map { $_ <= @fields ? $fields[ $_ - 1 ] : () } @$field_numbers; | 
            
            
              | 207 | 
                  }  | 
            
            
              | 208 | 
               | 
            
            
              | 209 | 
                  if ( @fields ) { | 
            
        
          | 200 | 
                  unless ( $dont_erase ) { | 
          210 | 
                  unless ( $dont_erase ) { | 
        
        
          | 201 | 
                      @values = ($values[0]) x scalar( @fields )  | 
          211 | 
                      @values = ($values[0]) x scalar( @fields )  | 
        
        
          | 202 | 
                          if @values == 1;  | 
          212 | 
                          if @values == 1;  | 
        
  
    | 
      
            Lines 236-247
          sub read_field {
      
      
        Link Here
      
     | 
  
        
          | 236 | 
              my $record = $params->{record}; | 
          246 | 
              my $record = $params->{record}; | 
        
        
          | 237 | 
              my $fieldName = $params->{field}; | 
          247 | 
              my $fieldName = $params->{field}; | 
        
        
          | 238 | 
              my $subfieldName = $params->{subfield}; | 
          248 | 
              my $subfieldName = $params->{subfield}; | 
        
          
            
              | 239 | 
                  my $n = $params->{n}; | 
              249 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 240 | 
           | 
          250 | 
           | 
        
        
          | 241 | 
              if ( not $subfieldName or $subfieldName eq '' ) { | 
          251 | 
              if ( not $subfieldName or $subfieldName eq '' ) { | 
        
          
            
              | 242 | 
                      _read_field({ record => $record, field => $fieldName, n => $n }); | 
              252 | 
                      _read_field({ record => $record, field => $fieldName, field_numbers => $field_numbers }); | 
            
        
          | 243 | 
              } else { | 
          253 | 
              } else { | 
        
          
            
              | 244 | 
                      _read_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, n => $n }); | 
              254 | 
                      _read_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, field_numbers => $field_numbers }); | 
            
        
          | 245 | 
              }  | 
          255 | 
              }  | 
        
        
          | 246 | 
          }  | 
          256 | 
          }  | 
        
        
          | 247 | 
           | 
          257 | 
           | 
        
  
    | 
      
            Lines 249-255
          sub _read_field {
      
      
        Link Here
      
     | 
  
        
          | 249 | 
              my ( $params ) = @_;  | 
          259 | 
              my ( $params ) = @_;  | 
        
        
          | 250 | 
              my $record = $params->{record}; | 
          260 | 
              my $record = $params->{record}; | 
        
        
          | 251 | 
              my $fieldName = $params->{field}; | 
          261 | 
              my $fieldName = $params->{field}; | 
        
          
            
              | 252 | 
                  my $n = $params->{n}; | 
              262 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 253 | 
           | 
          263 | 
           | 
        
        
          | 254 | 
              my @fields = $record->field( $fieldName );  | 
          264 | 
              my @fields = $record->field( $fieldName );  | 
        
        
          | 255 | 
           | 
          265 | 
           | 
        
  
    | 
      
            Lines 259-268
          sub _read_field {
      
      
        Link Here
      
     | 
  
        
          | 259 | 
                  if $fieldName < 10;  | 
          269 | 
                  if $fieldName < 10;  | 
        
        
          | 260 | 
           | 
          270 | 
           | 
        
        
          | 261 | 
              my @values;  | 
          271 | 
              my @values;  | 
        
          
            
              | 262 | 
                  if ( $n ) { | 
              272 | 
                  if ( @$field_numbers ) { | 
            
            
              | 263 | 
                      if ( $n <= scalar( @fields ) ) { | 
              273 | 
                      for my $field_number ( @$field_numbers ) { | 
            
            
              | 264 | 
                          for my $sf ( $fields[$n - 1]->subfields ) { | 
              274 | 
                          if ( $field_number <= scalar( @fields ) ) { | 
            
            
              | 265 | 
                              push @values, $sf->[1];  | 
              275 | 
                              for my $sf ( $fields[$field_number - 1]->subfields ) { | 
            
            
               | 
               | 
              276 | 
                                  push @values, $sf->[1];  | 
            
            
              | 277 | 
                              }  | 
            
        
          | 266 | 
                      }  | 
          278 | 
                      }  | 
        
        
          | 267 | 
                  }  | 
          279 | 
                  }  | 
        
        
          | 268 | 
              } else { | 
          280 | 
              } else { | 
        
  
    | 
      
            Lines 281-287
          sub _read_subfield {
      
      
        Link Here
      
     | 
  
        
          | 281 | 
              my $record = $params->{record}; | 
          293 | 
              my $record = $params->{record}; | 
        
        
          | 282 | 
              my $fieldName = $params->{field}; | 
          294 | 
              my $fieldName = $params->{field}; | 
        
        
          | 283 | 
              my $subfieldName = $params->{subfield}; | 
          295 | 
              my $subfieldName = $params->{subfield}; | 
        
          
            
              | 284 | 
                  my $n = $params->{n}; | 
              296 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 285 | 
           | 
          297 | 
           | 
        
        
          | 286 | 
              my @fields = $record->field( $fieldName );  | 
          298 | 
              my @fields = $record->field( $fieldName );  | 
        
        
          | 287 | 
           | 
          299 | 
           | 
        
  
    | 
      
            Lines 293-308
          sub _read_subfield {
      
      
        Link Here
      
     | 
  
        
          | 293 | 
                  push( @values, @sf );  | 
          305 | 
                  push( @values, @sf );  | 
        
        
          | 294 | 
              }  | 
          306 | 
              }  | 
        
        
          | 295 | 
           | 
          307 | 
           | 
        
          
            
              | 296 | 
                  return $n  | 
              308 | 
                  if ( @values and @$field_numbers ) { | 
            
            
              | 297 | 
                      ? $values[$n-1]  | 
              309 | 
                      @values = map { $_ <= @values ? $values[ $_ - 1 ] : () } @$field_numbers; | 
            
            
              | 298 | 
                      : @values;  | 
              310 | 
                  }  | 
            
            
               | 
               | 
              311 | 
               | 
            
            
              | 312 | 
                  return @values;  | 
            
        
          | 299 | 
          }  | 
          313 | 
          }  | 
        
        
          | 300 | 
           | 
          314 | 
           | 
        
        
          | 301 | 
          =head2 field_exists  | 
          315 | 
          =head2 field_exists  | 
        
        
          | 302 | 
           | 
          316 | 
           | 
        
          
            
              | 303 | 
                $bool = field_exists( $record, $fieldName[, $subfieldName ]);  | 
              317 | 
                @field_numbers = field_exists( $record, $fieldName[, $subfieldName ]);  | 
            
        
          | 304 | 
           | 
          318 | 
           | 
        
          
            
              | 305 | 
                Returns true if the field exits, false otherwise.  | 
              319 | 
                Returns the field numbers or an empty array.  | 
            
        
          | 306 | 
           | 
          320 | 
           | 
        
        
          | 307 | 
          =cut  | 
          321 | 
          =cut  | 
        
        
          | 308 | 
           | 
          322 | 
           | 
        
  
    | 
      
            Lines 314-341
          sub field_exists {
      
      
        Link Here
      
     | 
  
        
          | 314 | 
           | 
          328 | 
           | 
        
        
          | 315 | 
            if ( ! $record ) { return; } | 
          329 | 
            if ( ! $record ) { return; } | 
        
        
          | 316 | 
           | 
          330 | 
           | 
        
          
            
              | 317 | 
                my $return = 0;  | 
              331 | 
                my @field_numbers = ();  | 
            
            
              | 318 | 
                if ( $fieldName && $subfieldName ) { | 
              332 | 
                my $current_field_number = 1;  | 
            
            
              | 319 | 
                  $return = $record->field( $fieldName ) && $record->subfield( $fieldName, $subfieldName );  | 
              333 | 
                for my $field ( $record->field( $fieldName ) ) { | 
            
            
              | 320 | 
                } elsif ( $fieldName ) { | 
              334 | 
                  if ( $subfieldName ) { | 
            
            
              | 321 | 
                  $return = $record->field( $fieldName ) && 1;  | 
              335 | 
                    push @field_numbers, $current_field_number  | 
            
            
               | 
               | 
              336 | 
                      if $field->subfield( $subfieldName );  | 
            
            
              | 337 | 
                  } else { | 
            
            
              | 338 | 
                    push @field_numbers, $current_field_number;  | 
            
            
              | 339 | 
                  }  | 
            
            
              | 340 | 
                  $current_field_number++;  | 
            
        
          | 322 | 
            }  | 
          341 | 
            }  | 
        
        
          | 323 | 
           | 
          342 | 
           | 
        
          
            
              | 324 | 
                return $return;  | 
              343 | 
                return \@field_numbers;  | 
            
        
          | 325 | 
          }  | 
          344 | 
          }  | 
        
        
          | 326 | 
           | 
          345 | 
           | 
        
        
          | 327 | 
          =head2 field_equals  | 
          346 | 
          =head2 field_equals  | 
        
        
          | 328 | 
           | 
          347 | 
           | 
        
          
            
              | 329 | 
                $bool = field_equals( $record, $value, $fieldName[, $subfieldName[, $regex [, $n ] ] ]);  | 
              348 | 
                $bool = field_equals( $record, $value, $fieldName[, $subfieldName[, $regex ] ]);  | 
            
        
          | 330 | 
           | 
          349 | 
           | 
        
        
          | 331 | 
            Returns true if the field equals the given value, false otherwise.  | 
          350 | 
            Returns true if the field equals the given value, false otherwise.  | 
        
        
          | 332 | 
           | 
          351 | 
           | 
        
        
          | 333 | 
            If a regular expression ( $regex ) is supplied, the value will be compared using  | 
          352 | 
            If a regular expression ( $regex ) is supplied, the value will be compared using  | 
        
        
          | 334 | 
            the given regex. Example: $regex = 'sought_text'  | 
          353 | 
            the given regex. Example: $regex = 'sought_text'  | 
        
        
          | 335 | 
           | 
          354 | 
           | 
        
            
              | 336 | 
                If $n is passed, the Nth field of a repeatable series will be used for comparison.  | 
               | 
               | 
            
            
              | 337 | 
                Set $n to 1 or leave empty for a non-repeatable field.  | 
            
            
              | 338 | 
               | 
            
        
          | 339 | 
          =cut  | 
          355 | 
          =cut  | 
        
        
          | 340 | 
           | 
          356 | 
           | 
        
        
          | 341 | 
          sub field_equals { | 
          357 | 
          sub field_equals { | 
        
  
    | 
      
            Lines 345-363
          sub field_equals {
      
      
        Link Here
      
     | 
  
        
          | 345 | 
            my $fieldName = $params->{field}; | 
          361 | 
            my $fieldName = $params->{field}; | 
        
        
          | 346 | 
            my $subfieldName = $params->{subfield}; | 
          362 | 
            my $subfieldName = $params->{subfield}; | 
        
        
          | 347 | 
            my $regex = $params->{regex}; | 
          363 | 
            my $regex = $params->{regex}; | 
        
            
              | 348 | 
                my $n = $params->{n}; | 
               | 
               | 
            
            
              | 349 | 
                $n = 1 unless ( $n ); ## $n defaults to first field of a repeatable field series  | 
            
        
          | 350 | 
           | 
          364 | 
           | 
        
        
          | 351 | 
            if ( ! $record ) { return; } | 
          365 | 
            if ( ! $record ) { return; } | 
        
        
          | 352 | 
           | 
          366 | 
           | 
        
          
            
              | 353 | 
                my @field_values = read_field({ record => $record, field => $fieldName, subfield => $subfieldName, n => $n }); | 
              367 | 
                my @field_numbers = ();  | 
            
            
              | 354 | 
                my $field_value = $field_values[$n-1];  | 
              368 | 
                my $current_field_number = 1;  | 
            
            
              | 355 | 
               | 
              369 | 
                FIELDS: for my $field ( $record->field( $fieldName ) ) { | 
            
            
              | 356 | 
                if ( $regex ) { | 
              370 | 
                  my @subfield_values = $subfieldName  | 
            
            
              | 357 | 
                  return $field_value =~ m/$value/;  | 
              371 | 
                      ? $field->subfield( $subfieldName )  | 
            
            
              | 358 | 
                } else { | 
              372 | 
                      : map { $_->[1] } $field->subfields; | 
            
            
              | 359 | 
                  return $field_value eq $value;  | 
              373 | 
               | 
            
            
               | 
               | 
              374 | 
                  SUBFIELDS: for my $subfield_value ( @subfield_values ) { | 
            
            
              | 375 | 
                    if (  | 
            
            
              | 376 | 
                        (  | 
            
            
              | 377 | 
                            $regex and $subfield_value =~ m/$value/  | 
            
            
              | 378 | 
                        ) or (  | 
            
            
              | 379 | 
                            $subfield_value eq $value  | 
            
            
              | 380 | 
                        )  | 
            
            
              | 381 | 
                    ) { | 
            
            
              | 382 | 
                        push @field_numbers, $current_field_number;  | 
            
            
              | 383 | 
                        last SUBFIELDS;  | 
            
            
              | 384 | 
                    }  | 
            
            
              | 385 | 
                  }  | 
            
            
              | 386 | 
                  $current_field_number++;  | 
            
        
          | 360 | 
            }  | 
          387 | 
            }  | 
        
            
               | 
               | 
              388 | 
               | 
            
            
              | 389 | 
                return \@field_numbers;  | 
            
        
          | 361 | 
          }  | 
          390 | 
          }  | 
        
        
          | 362 | 
           | 
          391 | 
           | 
        
        
          | 363 | 
          =head2 move_field  | 
          392 | 
          =head2 move_field  | 
        
  
    | 
      
            Lines 381-387
          sub move_field {
      
      
        Link Here
      
     | 
  
        
          | 381 | 
              my $toFieldName = $params->{to_field}; | 
          410 | 
              my $toFieldName = $params->{to_field}; | 
        
        
          | 382 | 
              my $toSubfieldName = $params->{to_subfield}; | 
          411 | 
              my $toSubfieldName = $params->{to_subfield}; | 
        
        
          | 383 | 
              my $regex = $params->{regex}; | 
          412 | 
              my $regex = $params->{regex}; | 
        
          
            
              | 384 | 
                  my $n = $params->{n}; | 
              413 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 385 | 
           | 
          414 | 
           | 
        
        
          | 386 | 
              if ( not $fromSubfieldName or $fromSubfieldName eq ''  | 
          415 | 
              if ( not $fromSubfieldName or $fromSubfieldName eq ''  | 
        
        
          | 387 | 
                  or not $toSubfieldName or $toSubfieldName eq ''  | 
          416 | 
                  or not $toSubfieldName or $toSubfieldName eq ''  | 
        
  
    | 
      
            Lines 391-397
          sub move_field {
      
      
        Link Here
      
     | 
  
        
          | 391 | 
                      from_field => $fromFieldName,  | 
          420 | 
                      from_field => $fromFieldName,  | 
        
        
          | 392 | 
                      to_field => $toFieldName,  | 
          421 | 
                      to_field => $toFieldName,  | 
        
        
          | 393 | 
                      regex => $regex,  | 
          422 | 
                      regex => $regex,  | 
        
          
            
              | 394 | 
                          n => $n,  | 
              423 | 
                          field_numbers => $field_numbers,  | 
            
        
          | 395 | 
                  });  | 
          424 | 
                  });  | 
        
        
          | 396 | 
              } else { | 
          425 | 
              } else { | 
        
        
          | 397 | 
                  _move_subfield({ | 
          426 | 
                  _move_subfield({ | 
        
  
    | 
      
            Lines 401-407
          sub move_field {
      
      
        Link Here
      
     | 
  
        
          | 401 | 
                      to_field => $toFieldName,  | 
          430 | 
                      to_field => $toFieldName,  | 
        
        
          | 402 | 
                      to_subfield => $toSubfieldName,  | 
          431 | 
                      to_subfield => $toSubfieldName,  | 
        
        
          | 403 | 
                      regex => $regex,  | 
          432 | 
                      regex => $regex,  | 
        
          
            
              | 404 | 
                          n => $n,  | 
              433 | 
                          field_numbers => $field_numbers,  | 
            
        
          | 405 | 
                  });  | 
          434 | 
                  });  | 
        
        
          | 406 | 
              }  | 
          435 | 
              }  | 
        
        
          | 407 | 
          }  | 
          436 | 
          }  | 
        
  
    | 
      
            Lines 412-424
          sub _move_field {
      
      
        Link Here
      
     | 
  
        
          | 412 | 
              my $fromFieldName = $params->{from_field}; | 
          441 | 
              my $fromFieldName = $params->{from_field}; | 
        
        
          | 413 | 
              my $toFieldName = $params->{to_field}; | 
          442 | 
              my $toFieldName = $params->{to_field}; | 
        
        
          | 414 | 
              my $regex = $params->{regex}; | 
          443 | 
              my $regex = $params->{regex}; | 
        
          
            
              | 415 | 
                  my $n = $params->{n}; | 
              444 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
            
               | 
               | 
              445 | 
               | 
            
        
          | 416 | 
              _copy_move_field({ | 
          446 | 
              _copy_move_field({ | 
        
        
          | 417 | 
                  record => $record,  | 
          447 | 
                  record => $record,  | 
        
        
          | 418 | 
                  from_field => $fromFieldName,  | 
          448 | 
                  from_field => $fromFieldName,  | 
        
        
          | 419 | 
                  to_field => $toFieldName,  | 
          449 | 
                  to_field => $toFieldName,  | 
        
        
          | 420 | 
                  regex => $regex,  | 
          450 | 
                  regex => $regex,  | 
        
          
            
              | 421 | 
                      n => $n,  | 
              451 | 
                      field_numbers => $field_numbers,  | 
            
        
          | 422 | 
                  action => 'move',  | 
          452 | 
                  action => 'move',  | 
        
        
          | 423 | 
              });  | 
          453 | 
              });  | 
        
        
          | 424 | 
          }  | 
          454 | 
          }  | 
        
  
    | 
      
            Lines 431-441
          sub _move_subfield {
      
      
        Link Here
      
     | 
  
        
          | 431 | 
              my $toFieldName = $params->{to_field}; | 
          461 | 
              my $toFieldName = $params->{to_field}; | 
        
        
          | 432 | 
              my $toSubfieldName = $params->{to_subfield}; | 
          462 | 
              my $toSubfieldName = $params->{to_subfield}; | 
        
        
          | 433 | 
              my $regex = $params->{regex}; | 
          463 | 
              my $regex = $params->{regex}; | 
        
          
            
              | 434 | 
                  my $n = $params->{n}; | 
              464 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 435 | 
           | 
          465 | 
           | 
        
        
          | 436 | 
              # Copy  | 
          466 | 
              # Copy  | 
        
        
          | 437 | 
              my @values = read_field({ record => $record, field => $fromFieldName, subfield => $fromSubfieldName }); | 
          467 | 
              my @values = read_field({ record => $record, field => $fromFieldName, subfield => $fromSubfieldName }); | 
        
          
            
              | 438 | 
                  @values = ( $values[$n-1] ) if $n;  | 
              468 | 
                  if ( @$field_numbers ) { | 
            
            
               | 
               | 
              469 | 
                      @values = map { $_ <= @values ? $values[ $_ - 1 ] : () } @$field_numbers; | 
            
            
              | 470 | 
                  }  | 
            
        
          | 439 | 
              _modify_values({ values => \@values, regex => $regex }); | 
          471 | 
              _modify_values({ values => \@values, regex => $regex }); | 
        
        
          | 440 | 
              _update_subfield({ record => $record, field => $toFieldName, subfield => $toSubfieldName, dont_erase => 1, values => \@values }); | 
          472 | 
              _update_subfield({ record => $record, field => $toFieldName, subfield => $toSubfieldName, dont_erase => 1, values => \@values }); | 
        
        
          | 441 | 
           | 
          473 | 
           | 
        
  
    | 
      
            Lines 444-450
          sub _move_subfield {
      
      
        Link Here
      
     | 
  
        
          | 444 | 
                  record => $record,  | 
          476 | 
                  record => $record,  | 
        
        
          | 445 | 
                  field => $fromFieldName,  | 
          477 | 
                  field => $fromFieldName,  | 
        
        
          | 446 | 
                  subfield => $fromSubfieldName,  | 
          478 | 
                  subfield => $fromSubfieldName,  | 
        
          
            
              | 447 | 
                      n => $n,  | 
              479 | 
                      field_numbers => $field_numbers,  | 
            
        
          | 448 | 
              });  | 
          480 | 
              });  | 
        
        
          | 449 | 
          }  | 
          481 | 
          }  | 
        
        
          | 450 | 
           | 
          482 | 
           | 
        
  
    | 
      
            Lines 464-475
          sub delete_field {
      
      
        Link Here
      
     | 
  
        
          | 464 | 
              my $record = $params->{record}; | 
          496 | 
              my $record = $params->{record}; | 
        
        
          | 465 | 
              my $fieldName = $params->{field}; | 
          497 | 
              my $fieldName = $params->{field}; | 
        
        
          | 466 | 
              my $subfieldName = $params->{subfield}; | 
          498 | 
              my $subfieldName = $params->{subfield}; | 
        
          
            
              | 467 | 
                  my $n = $params->{n}; | 
              499 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 468 | 
           | 
          500 | 
           | 
        
        
          | 469 | 
              if ( not $subfieldName or $subfieldName eq '' ) { | 
          501 | 
              if ( not $subfieldName or $subfieldName eq '' ) { | 
        
          
            
              | 470 | 
                      _delete_field({ record => $record, field => $fieldName, n => $n }); | 
              502 | 
                      _delete_field({ record => $record, field => $fieldName, field_numbers => $field_numbers }); | 
            
        
          | 471 | 
              } else { | 
          503 | 
              } else { | 
        
          
            
              | 472 | 
                      _delete_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, n => $n }); | 
              504 | 
                      _delete_subfield({ record => $record, field => $fieldName, subfield => $subfieldName, field_numbers => $field_numbers }); | 
            
        
          | 473 | 
              }  | 
          505 | 
              }  | 
        
        
          | 474 | 
          }  | 
          506 | 
          }  | 
        
        
          | 475 | 
           | 
          507 | 
           | 
        
  
    | 
      
            Lines 477-487
          sub _delete_field {
      
      
        Link Here
      
     | 
  
        
          | 477 | 
              my ( $params ) = @_;  | 
          509 | 
              my ( $params ) = @_;  | 
        
        
          | 478 | 
              my $record = $params->{record}; | 
          510 | 
              my $record = $params->{record}; | 
        
        
          | 479 | 
              my $fieldName = $params->{field}; | 
          511 | 
              my $fieldName = $params->{field}; | 
        
          
            
              | 480 | 
                  my $n = $params->{n}; | 
              512 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 481 | 
           | 
          513 | 
           | 
        
        
          | 482 | 
              my @fields = $record->field( $fieldName );  | 
          514 | 
              my @fields = $record->field( $fieldName );  | 
        
        
          | 483 | 
           | 
          515 | 
           | 
        
          
            
              | 484 | 
                  @fields = ( $fields[$n-1] ) if ( $n );  | 
              516 | 
                  if ( @$field_numbers ) { | 
            
            
               | 
               | 
              517 | 
                      @fields = map { $_ <= @fields ? $fields[ $_ - 1 ] : () } @$field_numbers; | 
            
            
              | 518 | 
                  }  | 
            
        
          | 485 | 
              foreach my $field ( @fields ) { | 
          519 | 
              foreach my $field ( @fields ) { | 
        
        
          | 486 | 
                  $record->delete_field( $field );  | 
          520 | 
                  $record->delete_field( $field );  | 
        
        
          | 487 | 
              }  | 
          521 | 
              }  | 
        
  
    | 
      
            Lines 492-502
          sub _delete_subfield {
      
      
        Link Here
      
     | 
  
        
          | 492 | 
              my $record = $params->{record}; | 
          526 | 
              my $record = $params->{record}; | 
        
        
          | 493 | 
              my $fieldName = $params->{field}; | 
          527 | 
              my $fieldName = $params->{field}; | 
        
        
          | 494 | 
              my $subfieldName = $params->{subfield}; | 
          528 | 
              my $subfieldName = $params->{subfield}; | 
        
          
            
              | 495 | 
                  my $n = $params->{n}; | 
              529 | 
                  my $field_numbers = $params->{field_numbers} // []; | 
            
        
          | 496 | 
           | 
          530 | 
           | 
        
        
          | 497 | 
              my @fields = $record->field( $fieldName );  | 
          531 | 
              my @fields = $record->field( $fieldName );  | 
        
        
          | 498 | 
           | 
          532 | 
           | 
        
          
            
              | 499 | 
                  @fields = ( $fields[$n-1] ) if ( $n );  | 
              533 | 
                  if ( @$field_numbers ) { | 
            
            
               | 
               | 
              534 | 
                      @fields = map { $_ <= @fields ? $fields[ $_ - 1 ] : () } @$field_numbers; | 
            
            
              | 535 | 
                  }  | 
            
        
          | 500 | 
           | 
          536 | 
           | 
        
        
          | 501 | 
              foreach my $field ( @fields ) { | 
          537 | 
              foreach my $field ( @fields ) { | 
        
        
          | 502 | 
                  $field->delete_subfield( code => $subfieldName );  | 
          538 | 
                  $field->delete_subfield( code => $subfieldName );  | 
        
  
    | 
      
            Lines 510-521
          sub _copy_move_field {
      
      
        Link Here
      
     | 
  
        
          | 510 | 
              my $fromFieldName = $params->{from_field}; | 
          546 | 
              my $fromFieldName = $params->{from_field}; | 
        
        
          | 511 | 
              my $toFieldName = $params->{to_field}; | 
          547 | 
              my $toFieldName = $params->{to_field}; | 
        
        
          | 512 | 
              my $regex = $params->{regex}; | 
          548 | 
              my $regex = $params->{regex}; | 
        
          
            
              | 513 | 
                  my $n = $params->{n}; | 
              549 | 
                  my $field_numbers = $params->{field_numbers}; | 
            
        
          | 514 | 
              my $action = $params->{action} || 'copy'; | 
          550 | 
              my $action = $params->{action} || 'copy'; | 
        
        
          | 515 | 
           | 
          551 | 
           | 
        
        
          | 516 | 
              my @fields = $record->field( $fromFieldName );  | 
          552 | 
              my @fields = $record->field( $fromFieldName );  | 
        
          
            
              | 517 | 
                  if ( $n and $n <= scalar( @fields ) ) { | 
              553 | 
                  if ( @$field_numbers ) { | 
            
            
              | 518 | 
                      @fields = ( $fields[$n - 1] );  | 
              554 | 
                      @fields = map { $_ <= @fields ? $fields[ $_ - 1 ] : () } @$field_numbers; | 
            
        
          | 519 | 
              }  | 
          555 | 
              }  | 
        
        
          | 520 | 
           | 
          556 | 
           | 
        
        
          | 521 | 
              for my $field ( @fields ) { | 
          557 | 
              for my $field ( @fields ) { |