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

(-)a/C4/Installer/PerlDependencies.pm (-2 / +2 lines)
Lines 750-761 our $PERL_DEPS = { Link Here
750
    'RDF::Trine' => {
750
    'RDF::Trine' => {
751
        'usage'    => 'Core',
751
        'usage'    => 'Core',
752
        'required' => '1',
752
        'required' => '1',
753
        'min_ver'  => '1.012',
753
        'min_ver'  => '1.000',
754
    },
754
    },
755
    'RDF::Helper' => {
755
    'RDF::Helper' => {
756
        'usage'    => 'Core',
756
        'usage'    => 'Core',
757
        'required' => '1',
757
        'required' => '1',
758
        'min_ver'  => '2.01',
758
        'min_ver'  => '2.0',
759
    },
759
    },
760
};
760
};
761
761
(-)a/Koha/DublinCoreTransformer.pm (-17 / +60 lines)
Lines 45-51 BEGIN { Link Here
45
45
46
}
46
}
47
47
48
use Encode qw(encode decode);
48
use Encode qw(is_utf8 encode decode);
49
use MARC::File::USMARC;
49
use MARC::File::USMARC;
50
use MARC::Crosswalk::DublinCore;
50
use MARC::Crosswalk::DublinCore;
51
use XML::LibXML;
51
use XML::LibXML;
Lines 258-266 sub write_xml { Link Here
258
    if ( $dataxml->{'entities'} == 1 ) {
258
    if ( $dataxml->{'entities'} == 1 ) {
259
        my @xml = $doc->toString(1);
259
        my @xml = $doc->toString(1);
260
        foreach (@xml) {
260
        foreach (@xml) {
261
            my ($dcxml_entity_encoded) =
261
            my $enc = Encode::find_encoding('utf-8');
262
              XML_entity_encode( Encode::decode( 'UTF-8', $_ ) );
262
            if ( Encode::is_utf8( $_ ) ) {
263
            $xml[-1] = $dcxml_entity_encoded;
263
                my ($dcxml_entity_encoded) =
264
                  XML_entity_encode( $_ );
265
                $xml[-1] = $dcxml_entity_encoded;
266
            } elsif ( $enc ) {
267
                 my ($dcxml_entity_encoded) =
268
                  XML_entity_encode( $enc->decode( $_ ) );
269
                $xml[-1] = $dcxml_entity_encoded;
270
            }
264
        }
271
        }
265
        my $xmljoiner = join "", @xml;
272
        my $xmljoiner = join "", @xml;
266
        return $xmljoiner;
273
        return $xmljoiner;
Lines 332-340 sub write_rdf { Link Here
332
    {
339
    {
333
        my @xml = $rdf->serialize( format => $rdfdescription->{'rdf_format'} );
340
        my @xml = $rdf->serialize( format => $rdfdescription->{'rdf_format'} );
334
        foreach (@xml) {
341
        foreach (@xml) {
335
            my ($dcxml_entity_encoded) =
342
            my $enc = Encode::find_encoding('utf-8');
336
              XML_entity_encode( Encode::decode( 'UTF-8', $_ ) );
343
            if ( Encode::is_utf8( $_ ) ) {
337
            $xml[-1] = $dcxml_entity_encoded;
344
                my ($dcxml_entity_encoded) =
345
                  XML_entity_encode( $_ );
346
                $xml[-1] = $dcxml_entity_encoded;
347
            } elsif ( $enc ) {
348
                my ($dcxml_entity_encoded) =
349
                  XML_entity_encode( $enc->decode( $_ ) );
350
                $xml[-1] = $dcxml_entity_encoded;
351
            }
338
        }
352
        }
339
        my $xmljoiner = join "", @xml;
353
        my $xmljoiner = join "", @xml;
340
        return $xmljoiner;
354
        return $xmljoiner;
Lines 342-348 sub write_rdf { Link Here
342
    elsif ( $rdfdescription->{'rdf_format'} eq 'rdfjson' ) {
356
    elsif ( $rdfdescription->{'rdf_format'} eq 'rdfjson' ) {
343
        my $encoding =
357
        my $encoding =
344
          $rdf->serialize( format => $rdfdescription->{'rdf_format'} );
358
          $rdf->serialize( format => $rdfdescription->{'rdf_format'} );
345
        $encoding = Encode::encode( 'UTF-8', $encoding );
359
        my $enc = Encode::find_encoding('iso-8859-1');
360
        Encode::is_utf8 ( $encoding ) ? $encoding : $enc->decode ( $encoding );
346
        return $encoding;
361
        return $encoding;
347
    }
362
    }
348
    else {
363
    else {
Lines 524-547 sub rdf_constructor { Link Here
524
        $deletespaces =~ s/\s//;
539
        $deletespaces =~ s/\s//;
525
        my $predicate = 'dcterms:' . $lowercase;
540
        my $predicate = 'dcterms:' . $lowercase;
526
        my $object    = $element_content;
541
        my $object    = $element_content;
527
        given ($element_scheme) {
542
        SWITCH:
528
            when ( $element_scheme ne "DCMI Type Vocabulary" ) {
543
        for ($element_scheme) {
544
            if ( /^ISO 3166/ ) {
529
545
530
              #  Dublin core returns DCMI Type Vocabulary
546
              #  Dublin core returns DCMI Type Vocabulary
531
              #  This will do something like:
547
              #  This will do something like:
532
              #    <rdf:Description rdf:nodeID="ISO3166">
548
              #    <rdf:Description rdf:nodeID="country">
533
              #        <dcam:memberOf rdf:resource="http://purl.org/dc/terms/ISO3166"/>
549
              #        <dcam:memberOf rdf:resource="http://purl.org/dc/terms/ISO3166"/>
534
              #        <rdf:value>us</rdf:value>
550
              #        <rdf:value>us</rdf:value>
535
              #    </rdf:Description>
551
              #    </rdf:Description>
536
              #    <dcterms:spatial rdf:nodeID="ISO3166"/>
552
              #    <dcterms:spatial rdf:nodeID="country"/>
537
                my $bnode        = $rdf->new_bnode($deletespaces);
553
                my $bnode        = $rdf->new_bnode("country");
538
                my $uri_resource = join "", $qualified, $deletespaces;
554
                my $uri_resource = join "", $qualified, $deletespaces;
539
                my $resource     = $rdf->new_resource($uri_resource);
555
                my $resource     = $rdf->new_resource($uri_resource);
540
                $rdf->assert_literal( $subject, $predicate,      $bnode );
556
                $rdf->assert_literal( $subject, $predicate,      $bnode );
541
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
557
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
542
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
558
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
559
                last SWITCH;
543
            }
560
            }
544
            when ( $element_scheme eq "DCMI Type Vocabulary" )
561
            if ( /^DCMI Type Vocabulary/ )
545
            {    #Changing for DCMIType
562
            {    #Changing for DCMIType
546
                my $bnode        = $rdf->new_bnode('DCMIType');
563
                my $bnode        = $rdf->new_bnode('DCMIType');
547
                my $uri_resource = $qualified . 'DCMIType';
564
                my $uri_resource = $qualified . 'DCMIType';
Lines 550-555 sub rdf_constructor { Link Here
550
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
567
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
551
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
568
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
552
            }
569
            }
570
            if ( /^ISO 639-2/ )
571
            {    #Changing bnodeId ISO639-2 for language
572
                my $bnode        = $rdf->new_bnode('language');
573
                my $uri_resource = join "", $qualified, $deletespaces;
574
                my $resource     = $rdf->new_resource($uri_resource);
575
                $rdf->assert_literal( $subject, $predicate,      $bnode );
576
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
577
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
578
            }
579
            if ( /^RFC 1766/ )
580
            {    #Changing bnodeId RFC1766 for languagetag
581
                my $bnode        = $rdf->new_bnode('languagetag');
582
                my $uri_resource = join "", $qualified, $deletespaces;
583
                my $resource     = $rdf->new_resource($uri_resource);
584
                $rdf->assert_literal( $subject, $predicate,      $bnode );
585
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
586
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
587
            }
588
            if ( /^LCSH/ || /^MeSH/ || /^LCC/ || /^DDC/ ||
589
                 /^UDC/ || /^IMT/ || /^URI/ || /^TGN/ )
590
            {    #Scheme sharing common elements
591
                my $bnode        = $rdf->new_bnode($deletespaces);
592
                my $uri_resource = join "", $qualified, $deletespaces;
593
                my $resource     = $rdf->new_resource($uri_resource);
594
                $rdf->assert_literal( $subject, $predicate,      $bnode );
595
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
596
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
597
            }
553
        }
598
        }
554
    }    #if-elsif
599
    }    #if-elsif
555
    return $rdf;
600
    return $rdf;
Lines 750-756 into metadata in XML or RDF format. Link Here
750
795
751
  #Or if you want to generate a file
796
  #Or if you want to generate a file
752
  open (OUTPUT, '> dc2xml.xml') or die $!;
797
  open (OUTPUT, '> dc2xml.xml') or die $!;
753
  print OUTPUT print $XML-DC;
798
  print OUTPUT $XML-DC;
754
  close(OUTPUT);
799
  close(OUTPUT);
755
800
756
=head2 DC-RDF
801
=head2 DC-RDF
Lines 783-789 into metadata in XML or RDF format. Link Here
783
828
784
  my $XML-RDF = $objectDC->write_rdf();
829
  my $XML-RDF = $objectDC->write_rdf();
785
  print $XML-RDF;
830
  print $XML-RDF;
786
787
  #Close the file according to MARC::File::USMARC
831
  #Close the file according to MARC::File::USMARC
788
  $batch->close();
832
  $batch->close();
789
  undef $marc;
833
  undef $marc;
790
- 

Return to bug 13642