view release on metacpan or  search on metacpan

lib/MARC/Transform.pm  view on Meta::CPAN

            foreach my $rul ( @$rule ) {
                my ($actionsin, $actionsinter, $actionsout)= parseactions($rul);#warn Data::Dumper::Dumper ($rul);
                my $boolcondition = testrule($rul, $actionsin, $actionsinter, $actionsout, $subs);
                #warn $boolcondition;warn "actionsin : ".$actionsin;warn "actionsout : ".$actionsout;
                if ($boolcondition) {
                    last;
                }
            }
        }
        elsif ( ref($rule) eq "HASH" ) {
            my $subs="";
            if ( defnonull ( $$rule{'subs'} ) ) {
                $subs.=$$rule{'subs'};
            }
            if ( defnonull ( $$rule{'LUT'} ) ) {
                $$global_LUT{"lookuptableforthis"}=$$rule{'LUT'};
            }
            my ($actionsin, $actionsinter, $actionsout)= parseactions($rule);
            my $boolcondition = testrule($rule, $actionsin, $actionsinter, $actionsout, $subs);
        }
        else {
            push(@errors, 'Invalid yaml : you try to use a scalar rule.'); #error
        }
    }
    foreach my $error (@errors) {
        print "\n$error";
    }
    ReplaceAllInRecord("after");
    $record;
}

sub defnonull { my $var = shift; if (defined $var and $var ne "") { return 1; } else { return 0; } }

sub LUT {
    my ( $inLUT, $type ) = @_;
    if (!defined($type)) {
        $type = "lookuptableforthis";
    }
    my $outLUT=$inLUT;
    my $boolnocor = 1;
    if ( ref($global_LUT) eq "HASH") {
        if (exists($$global_LUT{$type})) {
            my $correspondance=$$global_LUT{$type};
            if ( ref($correspondance) eq "HASH") {
                foreach my $cor (keys(%$correspondance)) {
                    if ($inLUT eq $cor) {
                        $outLUT=$$correspondance{$cor};
                        $boolnocor = 0;
                    }
                }
                if ($boolnocor) {
                    $outLUT=$$correspondance{"_default_value_"} if (defnonull($$correspondance{"_default_value_"}));
                    push (@{$$mth{"_defaultLUT_to_mth_"}->{"$type"}} , $inLUT) if $mth;
                }
            }
        }
    }
    return $outLUT;
}

sub update {
    my ($field,$subfields)=@_;
    transform ("update",$field,$subfields);
    return 1;
}
sub forceupdate {
    my ($field,$subfields)=@_;
    transform ("forceupdate",$field,$subfields);
    return 1;
}
sub updatefirst {
    my ($field,$subfields)=@_;
    transform ("updatefirst",$field,$subfields);
    return 1;
}
sub forceupdatefirst {
    my ($field,$subfields)=@_;
    transform ("forceupdatefirst",$field,$subfields);
    return 1;
}
sub create {
    my ($field,$subfields)=@_;
    transform ("create",$field,$subfields);
    return 1;
}

sub transform {
    my ($ttype,$field,$subfields)=@_;
    #print "\n------------$ttype------------ : \n".Data::Dumper::Dumper (@_);
    if ($ttype eq "forceupdate" or $ttype eq "forceupdatefirst" ) {
        if (ref($field) eq "" or ref($field) eq "SCALAR") {
            if (!defined $record->field($field) ) {$ttype="create"}
        }
    }
    if (ref($field) eq "MARC::Field") {
        #print "\n------------$ttype------------ : \n".Data::Dumper::Dumper ($subfields);
        foreach my $tag(keys(%$subfields)) {
            if ( $tag eq 'i1' or  $tag eq 'µ') {
                #print "\n------------$ttype------------ : \n";
                $this=$field->indicator(1);
                my $finalvalue=parsestringactions($$subfields{$tag});
                $field->update( ind1 => $finalvalue ) if ( ref($$subfields{$tag}) eq "" or ref($$subfields{$tag}) eq "SCALAR" );
            }
            elsif ( $tag eq 'i2' or  $tag eq '£') {
                $this=$field->indicator(2);
                my $finalvalue=parsestringactions($$subfields{$tag});
                $field->update( ind2 => $finalvalue ) if ( ref($$subfields{$tag}) eq "" or ref($$subfields{$tag}) eq "SCALAR" );
            }
            else {
                if( ref($$subfields{$tag}) eq "" or ref($$subfields{$tag}) eq "SCALAR" ) {
                    if($field->is_control_field()) {
                        $this=$field->data();
                        my $finalvalue=parsestringactions($$subfields{$tag});
                        $field->update($finalvalue);
                    }
                    else {
                        if ($ttype eq "create") {
                            $this="";
                            my $finalvalue=parsestringactions($$subfields{$tag});
                            $field->add_subfields( $tag => $finalvalue );
                        }
                        elsif ($ttype eq "updatefirst") {
                            if ( defined $field->subfield( $tag ) ) {
                                $this=$field->subfield( $tag );
                                my $finalvalue=parsestringactions($$subfields{$tag});
                                $field->update( $tag => $finalvalue );
                            }
                            #warn $tag.$$subfields{$tag};
                        }
                        elsif ($ttype eq "forceupdatefirst") {
                            if ( defined $field->subfield( $tag ) ) {