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

(-)a/C4/Installer/PerlDependencies.pm (+15 lines)
Lines 737-742 our $PERL_DEPS = { Link Here
737
        'required' => '0',
737
        'required' => '0',
738
        'min_ver'  => '5.61',
738
        'min_ver'  => '5.61',
739
    },
739
    },
740
    'HTML::Entities' => {
741
        'usage'    => 'Core',
742
        'required' => '1',
743
        'min_ver'  => '3.69',
744
    },
745
    'HTML::Entities::Numbered' => {
746
        'usage'    => 'Core',
747
        'required' => '1',
748
        'min_ver'  => '0.04',
749
    },
750
    'RDF::Trine' => {
751
        'usage'    => 'Core',
752
        'required' => '1',
753
        'min_ver'  => '1.000',
754
    },
740
};
755
};
741
756
742
1;
757
1;
(-)a/C4/Record.pm (-3 / +17 lines)
Lines 218-232 sub marcxml2marc { Link Here
218
218
219
=head2 marc2dcxml - Convert from ISO-2709 to Dublin Core
219
=head2 marc2dcxml - Convert from ISO-2709 to Dublin Core
220
220
221
  my ($error,$dcxml) = marc2dcxml($marc,$qualified);
221
   my ( $error, $dcxml ) = marc2dcxml( $type, $marc, $qualified,
222
                           $entities, $root, $xsi_schemaLocation,
223
                           $rdf_subject, $rdf_format );
222
224
223
Returns a DublinCore::Record object, will eventually return a Dublin Core scalar
225
Returns a DublinCore::Record object, will eventually return a Dublin Core scalar
224
226
225
FIXME: should return actual XML, not just an object
227
FIXME: should return actual XML, not just an object (Koha::DublinCoreTransformer return an XML)
228
229
C<$type> - the recommendation ( simple-dc-rdf, dc-rdf, dc-xml, oai-dc )
226
230
227
C<$marc> - an ISO-2709 scalar or MARC::Record object
231
C<$marc> - an ISO-2709 scalar or MARC::Record object
228
232
229
C<$qualified> - specify whether qualified Dublin Core should be used in the input or output [0]
233
C<$qualified> - specify whether simple or qualified Dublin Core should be used in output [0 or 1]
234
235
C<$entities> placing entities to 0 will codify only the five basic entities e.g., &lt, &gt, &quot, &amp, and &apos. Conversely if it is encoded to 1, all entities will coded into decimal
236
237
C<$root> root element for XML files
238
239
C<$xsi_schemaLocation> the xsischemaLocation for XML files.
240
241
C<$rdf_subject> Represent the main subject of RDF triples (for Koha the URI of the resource)
242
243
C<$rdf_format> Imply multiple formats for RDF (ntriples, nquads, rdfxml, rdfjson, ntriples-canonical, turtle)
230
244
231
=cut
245
=cut
232
246
(-)a/Koha/DublinCoreTransformer.pm (-111 / +187 lines)
Lines 24-29 package Koha::DublinCoreTransformer; Link Here
24
use Modern::Perl;
24
use Modern::Perl;
25
use strict;
25
use strict;
26
use warnings::register;
26
use warnings::register;
27
use utf8;
27
use version;
28
use version;
28
use v5.10.1;
29
use v5.10.1;
29
30
Lines 45-58 BEGIN { Link Here
45
46
46
}
47
}
47
48
48
use utf8;
49
use Encode qw(is_utf8 encode decode);
50
use MARC::File::USMARC;
49
use MARC::File::USMARC;
51
use MARC::Crosswalk::DublinCore;
50
use MARC::Crosswalk::DublinCore;
52
use XML::LibXML;
51
use XML::LibXML;
53
use HTML::Entities;
52
use HTML::Entities;
54
use XML::Entities;
53
use HTML::Entities::Numbered;
55
use RDF::Helper;
54
use RDF::Trine;
56
use base qw(Class::Accessor);
55
use base qw(Class::Accessor);
57
__PACKAGE__->mk_accessors(
56
__PACKAGE__->mk_accessors(
58
    qw(type qualified get_marc_record root xsi_schemaLocation rdf_subject rdf_format entities optional_namespace namespace_url)
57
    qw(type qualified get_marc_record root xsi_schemaLocation rdf_subject rdf_format entities optional_namespace namespace_url)
Lines 66-71 my $dcam = qq(http://purl.org/dc/dcam/); Link Here
66
my $rdfNS       = qq(http://www.w3.org/1999/02/22-rdf-syntax-ns#);
65
my $rdfNS       = qq(http://www.w3.org/1999/02/22-rdf-syntax-ns#);
67
my @elementupcase =
66
my @elementupcase =
68
  qw/tableOfContents dateAccepted dateCopyrighted dateSubmitted isVersionOf hasVersion isReplacedBy isRequiredBy isPartOf hasPart isReferencedBy isFormatOf hasFormat conformsTo accrualMethod accrualPeriodicity accrualPolicy instructionalMethod rightsHolder educationLevel accessRights bibliographicCitation/;
67
  qw/tableOfContents dateAccepted dateCopyrighted dateSubmitted isVersionOf hasVersion isReplacedBy isRequiredBy isPartOf hasPart isReferencedBy isFormatOf hasFormat conformsTo accrualMethod accrualPeriodicity accrualPolicy instructionalMethod rightsHolder educationLevel accessRights bibliographicCitation/;
68
my $map;
69
69
70
#USAGE: Koha::DublinCoreTransformer->new({
70
#USAGE: Koha::DublinCoreTransformer->new({
71
#    type => 'xml|rdf',
71
#    type => 'xml|rdf',
Lines 103-112 sub get_xml_data { Link Here
103
    $self->{root}     = "metadata" unless ( defined $self->{root} );
103
    $self->{root}     = "metadata" unless ( defined $self->{root} );
104
    $self->{entities} = 0          unless ( defined $self->{entities} );
104
    $self->{entities} = 0          unless ( defined $self->{entities} );
105
    my %dataxml = (
105
    my %dataxml = (
106
        xmlroot  => $self->{root},
106
        xmlroot            => $self->{root},
107
        entities => $self->{entities},
107
        entities           => $self->{entities},
108
        optional_namespace => $self->{optional_namespace},
108
        optional_namespace => $self->{optional_namespace},
109
        namespace_url => $self->{namespace_url},
109
        namespace_url      => $self->{namespace_url},
110
    );
110
    );
111
111
112
    if ( exists $self->{xsi_schemaLocation} ) {
112
    if ( exists $self->{xsi_schemaLocation} ) {
Lines 219-227 sub write_xml { Link Here
219
    my $root = $doc->createElement( $dataxml->{'xmlroot'} );
219
    my $root = $doc->createElement( $dataxml->{'xmlroot'} );
220
    $root->setNamespace( $xsi_schema, 'xsi', 0 );
220
    $root->setNamespace( $xsi_schema, 'xsi', 0 );
221
221
222
    if (defined $dataxml->{'optional_namespace'}){
222
    if ( defined $dataxml->{'optional_namespace'} ) {
223
    $root->setNamespace( $dataxml->{'namespace_url'},
223
        $root->setNamespace( $dataxml->{'namespace_url'},
224
                        $dataxml->{'optional_namespace'}, 0 );
224
            $dataxml->{'optional_namespace'}, 0 );
225
    }
225
    }
226
226
227
    if ( $self->type() eq 'xml' ) {
227
    if ( $self->type() eq 'xml' ) {
Lines 258-264 sub write_xml { Link Here
258
    #Enabling or desabling entities and print the xml
258
    #Enabling or desabling entities and print the xml
259
    if ( $dataxml->{'entities'} == 1 ) {
259
    if ( $dataxml->{'entities'} == 1 ) {
260
        my $serialized_data = $doc->toString(1);
260
        my $serialized_data = $doc->toString(1);
261
        my ($dcxml_entity_encoded) = XML_entity_encode( $serialized_data );
261
        my ($dcxml_entity_encoded) = XML_entity_encode($serialized_data);
262
        $serialized_data = $dcxml_entity_encoded;
262
        $serialized_data = $dcxml_entity_encoded;
263
        return $serialized_data;
263
        return $serialized_data;
264
    }
264
    }
Lines 271-278 sub write_rdf { Link Here
271
    my $self           = shift;
271
    my $self           = shift;
272
    my $rdfdescription = $self->get_rdf_data();
272
    my $rdfdescription = $self->get_rdf_data();
273
    my $dc             = $self->conversion_to_dc();
273
    my $dc             = $self->conversion_to_dc();
274
    my $rdf;
274
    my $serializer;
275
    my $subject = $rdfdescription->{'rdf_subject'};
275
    my %namespaces;
276
276
277
    #Looking for bad data
277
    #Looking for bad data
278
    if ( ( $self->type() ne 'xml' and $self->type() ne 'rdf' )
278
    if ( ( $self->type() ne 'xml' and $self->type() ne 'rdf' )
Lines 293-346 sub write_rdf { Link Here
293
        die "Set entities => " . $self->entities() . " is no good, stopped";
293
        die "Set entities => " . $self->entities() . " is no good, stopped";
294
    }
294
    }
295
295
296
    # Creating the triple store in temporary data
297
    my $store = RDF::Trine::Store::Memory->new();
298
299
    # Creating the model
300
    my $rdf = RDF::Trine::Model->new($store);
301
302
    # Creating the subject
303
    my $subject =
304
      RDF::Trine::Node::Resource->new( $rdfdescription->{'rdf_subject'} );
305
306
    $namespaces{'rdf'} = $rdfNS;
307
296
    if ( $self->qualified() == 0 ) {
308
    if ( $self->qualified() == 0 ) {
297
309
298
        #Creating RDF::Helper object
310
        # Declaring all namespaces in a hash
299
        $rdf = RDF::Helper->new(
311
        $namespaces{'dc'} = $unqualified;
300
            BaseInterface => 'RDF::Trine',
301
            namespaces    => {
302
                rdf => $rdfNS,
303
                dc  => $unqualified,
304
            },
305
            ExpandQNames => 1,
306
            base_uri     => '',
307
        );
308
    }
312
    }
309
    else {
313
    else {
310
        $rdf = RDF::Helper->new(
314
311
            BaseInterface => 'RDF::Trine',
315
        # Declaring all namespaces in a hash
312
            namespaces    => {
316
        $namespaces{'dcterms'} = $qualified;
313
                rdf     => $rdfNS,
317
        $namespaces{'dcam'}    = $dcam;
314
                dcterms => $qualified,
315
                dcam    => $dcam,
316
            },
317
            ExpandQNames => 1,
318
            base_uri     => '',
319
        );
320
    }
318
    }
321
319
320
    # Creating namespaces
321
    $map = RDF::Trine::NamespaceMap->new( \%namespaces );
322
322
    if ( $self->type() eq 'rdf' ) {
323
    if ( $self->type() eq 'rdf' ) {
323
        $self->dc_order_execution( $dc, $rdf, $subject );
324
        $self->dc_order_execution( $dc, $rdf, $subject );
324
    }
325
    }
325
326
326
   #Enabling or desabling entities and print the xml, fixing encode with rdfjson
327
   #Enabling or desabling entities and print the xml, fixing encode with rdfjson
327
    if (   $rdfdescription->{'entities'} == 1
328
    if ( $rdfdescription->{'rdf_format'} eq 'rdfxml' ) {
328
        && $rdfdescription->{'rdf_format'} eq 'rdfxml' )
329
        if ( $rdfdescription->{'entities'} == 1 ) {
329
    {
330
            $serializer =
330
        my $serialized_data = $rdf->serialize( format => $rdfdescription->{'rdf_format'} );
331
              RDF::Trine::Serializer::RDFXML->new(
331
        my ($dcxml_entity_encoded) = XML_entity_encode( $serialized_data );
332
                namespaces => {%namespaces} );
332
        $serialized_data = $dcxml_entity_encoded;
333
            my $serialized_data = $serializer->serialize_model_to_string($rdf);
333
        return $serialized_data;
334
            my ($dcxml_entity_encoded) = XML_entity_encode($serialized_data);
335
            return $serialized_data = $dcxml_entity_encoded;
336
        }
337
        else {
338
            $serializer =
339
              RDF::Trine::Serializer::RDFXML->new(
340
                namespaces => {%namespaces} );
341
            return $serializer->serialize_model_to_string($rdf);
342
        }
334
    }
343
    }
335
    elsif ( $rdfdescription->{'rdf_format'} eq 'rdfjson' ) {
344
    elsif ( $rdfdescription->{'rdf_format'} eq 'turtle' ) {
336
        my $encoding =
345
        $serializer =
337
          $rdf->serialize( format => $rdfdescription->{'rdf_format'} );
346
          RDF::Trine::Serializer::Turtle->new( namespaces => {%namespaces} );
338
        my $enc = Encode::find_encoding('iso-8859-1');
347
        return $serializer->serialize_model_to_string($rdf);
339
        Encode::is_utf8 ( $encoding ) ? $encoding : $enc->decode ( $encoding );
340
        return $encoding;
341
    }
348
    }
342
    else {
349
    else {
343
        return $rdf->serialize( format => $rdfdescription->{'rdf_format'} );
350
        $serializer =
351
          RDF::Trine::Serializer->new( $rdfdescription->{'rdf_format'} );
352
        return $serializer->serialize_model_to_string($rdf);
344
    }
353
    }
345
}
354
}
346
355
Lines 376-383 sub XML_entity_encode { Link Here
376
    foreach my $string (@strings) {
385
    foreach my $string (@strings) {
377
        utf8::decode($string);
386
        utf8::decode($string);
378
        my $html_entities =
387
        my $html_entities =
379
          HTML::Entities::encode_entities( $string, '^\n\t\x20-\x26\x28-\x7e' );
388
          HTML::Entities::encode_entities( $string, '^\n\t\x20-\x7e' );
380
        my $xml_entities = XML::Entities::numify( 'all', $html_entities );
389
        my $xml_entities =
390
          HTML::Entities::Numbered::name2hex_xml($html_entities);
381
        push @strings_entity_encoded, $xml_entities;
391
        push @strings_entity_encoded, $xml_entities;
382
    }
392
    }
383
    return @strings_entity_encoded;
393
    return @strings_entity_encoded;
Lines 503-582 sub rdf_constructor { Link Here
503
    if ( ( $namespace eq "dc" or "dcterms" ) and $attr == 0 ) {
513
    if ( ( $namespace eq "dc" or "dcterms" ) and $attr == 0 ) {
504
514
505
        # This will do something like: <dc:title>Title</dc:title>
515
        # This will do something like: <dc:title>Title</dc:title>
506
        my $predicate = $namespace . ':' . $lowercase;
516
        my $predicate = undef;
507
        my $object    = $element_content;
517
        if ( $namespace eq "dc" ) {
508
        $rdf->assert_literal( $subject, $predicate, $object );
518
            $predicate = $map->dc($lowercase);
519
        }
520
        else {
521
            $predicate = $map->dcterms($lowercase);
522
        }
523
        my $object = RDF::Trine::Node::Literal->new($element_content);
524
        my $statement =
525
          RDF::Trine::Statement->new( $subject, $predicate, $object );
526
        $rdf->add_statement($statement);
509
    }
527
    }
510
    elsif ( ( $namespace eq "dc" ) and $attr == 2 ) {
528
    elsif ( ( $namespace eq "dc" ) and $attr == 2 ) {
511
529
512
        # This will do something like: <dcterms:title>Title</dcterms:title>
530
        # This will do something like: <dcterms:title>Title</dcterms:title>
513
        my $predicate = 'dcterms:' . $lowercase;
531
        my $predicate = $map->dcterms($lowercase);
514
        my $object    = $element_content;
532
        my $object    = RDF::Trine::Node::Literal->new($element_content);
515
        $rdf->assert_literal( $subject, $predicate, $object );
533
        my $statement =
534
          RDF::Trine::Statement->new( $subject, $predicate, $object );
535
        $rdf->add_statement($statement);
516
    }
536
    }
517
    elsif ( ( $namespace eq "dc" ) and $attr == 1 ) {
537
    elsif ( ( $namespace eq "dc" ) and $attr == 1 ) {
518
        $deletespaces = $element_scheme;
538
        $deletespaces = $element_scheme;
519
        $deletespaces =~ s/\s//;
539
        $deletespaces =~ s/\s//;
520
        my $predicate = 'dcterms:' . $lowercase;
540
      SWITCH:
521
        my $object    = $element_content;
522
        SWITCH:
523
        for ($element_scheme) {
541
        for ($element_scheme) {
524
            if ( /^ISO 3166/ ) {
542
            if (/^ISO 3166/) {
525
543
526
              #  Dublin core returns DCMI Type Vocabulary
544
       #  Dublin core returns DCMI Type Vocabulary
527
              #  This will do something like:
545
       #  This will do something like:
528
              #    <rdf:Description rdf:nodeID="country">
546
       #    <rdf:Description rdf:nodeID="country">
529
              #        <dcam:memberOf rdf:resource="http://purl.org/dc/terms/ISO3166"/>
547
       #        <dcam:memberOf rdf:resource="http://purl.org/dc/terms/ISO3166"/>
530
              #        <rdf:value>us</rdf:value>
548
       #        <rdf:value>us</rdf:value>
531
              #    </rdf:Description>
549
       #    </rdf:Description>
532
              #    <dcterms:spatial rdf:nodeID="country"/>
550
       #    <dcterms:spatial rdf:nodeID="country"/>
533
                my $bnode        = $rdf->new_bnode("country");
551
                my $objectbnode = RDF::Trine::Node::Blank->new('country');
534
                my $uri_resource = join "", $qualified, $deletespaces;
552
                my $predicate   = $map->dcterms($lowercase);
535
                my $resource     = $rdf->new_resource($uri_resource);
553
                my $object = RDF::Trine::Node::Literal->new($element_content);
536
                $rdf->assert_literal( $subject, $predicate,      $bnode );
554
                my $dcam_member_of  = $map->dcam('memberOf');
537
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
555
                my $resource_schema = $map->dcterms($deletespaces);
538
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
556
                my $rdf_value       = $map->rdf('value');
557
                my $statement1 =
558
                  RDF::Trine::Statement->new( $subject, $predicate,
559
                    $objectbnode );
560
                my $statement2 =
561
                  RDF::Trine::Statement->new( $objectbnode, $dcam_member_of,
562
                    $resource_schema );
563
                my $statement3 =
564
                  RDF::Trine::Statement->new( $objectbnode, $rdf_value,
565
                    $object );
566
                $rdf->add_statement($statement1);
567
                $rdf->add_statement($statement2);
568
                $rdf->add_statement($statement3);
539
                last SWITCH;
569
                last SWITCH;
540
            }
570
            }
541
            if ( /^DCMI Type Vocabulary/ )
571
            if (/^DCMI Type Vocabulary/) {    #Changing for DCMIType
542
            {    #Changing for DCMIType
572
                my $objectbnode = RDF::Trine::Node::Blank->new('DCMIType');
543
                my $bnode        = $rdf->new_bnode('DCMIType');
573
                my $predicate   = $map->dcterms($lowercase);
544
                my $uri_resource = $qualified . 'DCMIType';
574
                my $object = RDF::Trine::Node::Literal->new($element_content);
545
                my $resource     = $rdf->new_resource($uri_resource);
575
                my $dcam_member_of  = $map->dcam('memberOf');
546
                $rdf->assert_literal( $subject, $predicate,      $bnode );
576
                my $resource_schema = $map->dcterms('DCMIType');
547
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
577
                my $rdf_value       = $map->rdf('value');
548
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
578
                my $statement1 =
579
                  RDF::Trine::Statement->new( $subject, $predicate,
580
                    $objectbnode );
581
                my $statement2 =
582
                  RDF::Trine::Statement->new( $objectbnode, $dcam_member_of,
583
                    $resource_schema );
584
                my $statement3 =
585
                  RDF::Trine::Statement->new( $objectbnode, $rdf_value,
586
                    $object );
587
                $rdf->add_statement($statement1);
588
                $rdf->add_statement($statement2);
589
                $rdf->add_statement($statement3);
549
                last SWITCH;
590
                last SWITCH;
550
            }
591
            }
551
            if ( /^ISO 639-2/ )
592
            if (/^ISO 639-2/) {    #Changing bnodeId ISO639-2 for language
552
            {    #Changing bnodeId ISO639-2 for language
593
                my $objectbnode = RDF::Trine::Node::Blank->new('language');
553
                my $bnode        = $rdf->new_bnode('language');
594
                my $predicate   = $map->dcterms($lowercase);
554
                my $uri_resource = join "", $qualified, $deletespaces;
595
                my $object = RDF::Trine::Node::Literal->new($element_content);
555
                my $resource     = $rdf->new_resource($uri_resource);
596
                my $dcam_member_of  = $map->dcam('memberOf');
556
                $rdf->assert_literal( $subject, $predicate,      $bnode );
597
                my $resource_schema = $map->dcterms($deletespaces);
557
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
598
                my $rdf_value       = $map->rdf('value');
558
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
599
                my $statement1 =
600
                  RDF::Trine::Statement->new( $subject, $predicate,
601
                    $objectbnode );
602
                my $statement2 =
603
                  RDF::Trine::Statement->new( $objectbnode, $dcam_member_of,
604
                    $resource_schema );
605
                my $statement3 =
606
                  RDF::Trine::Statement->new( $objectbnode, $rdf_value,
607
                    $object );
608
                $rdf->add_statement($statement1);
609
                $rdf->add_statement($statement2);
610
                $rdf->add_statement($statement3);
559
                last SWITCH;
611
                last SWITCH;
560
            }
612
            }
561
            if ( /^RFC 1766/ )
613
            if (/^RFC 1766/) {    #Changing bnodeId RFC1766 for languagetag
562
            {    #Changing bnodeId RFC1766 for languagetag
614
                my $objectbnode = RDF::Trine::Node::Blank->new('languagetag');
563
                my $bnode        = $rdf->new_bnode('languagetag');
615
                my $predicate   = $map->dcterms($lowercase);
564
                my $uri_resource = join "", $qualified, $deletespaces;
616
                my $object = RDF::Trine::Node::Literal->new($element_content);
565
                my $resource     = $rdf->new_resource($uri_resource);
617
                my $dcam_member_of  = $map->dcam('memberOf');
566
                $rdf->assert_literal( $subject, $predicate,      $bnode );
618
                my $resource_schema = $map->dcterms($deletespaces);
567
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
619
                my $rdf_value       = $map->rdf('value');
568
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
620
                my $statement1 =
621
                  RDF::Trine::Statement->new( $subject, $predicate,
622
                    $objectbnode );
623
                my $statement2 =
624
                  RDF::Trine::Statement->new( $objectbnode, $dcam_member_of,
625
                    $resource_schema );
626
                my $statement3 =
627
                  RDF::Trine::Statement->new( $objectbnode, $rdf_value,
628
                    $object );
629
                $rdf->add_statement($statement1);
630
                $rdf->add_statement($statement2);
631
                $rdf->add_statement($statement3);
569
                last SWITCH;
632
                last SWITCH;
570
            }
633
            }
571
            if ( /^LCSH/ || /^MeSH/ || /^LCC/ || /^DDC/ ||
634
            if ( /^LCSH/ || /^MeSH/ || /^LCC/ || /^DDC/ ||
572
                 /^UDC/ || /^IMT/ || /^URI/ || /^TGN/ )
635
                 /^UDC/ || /^IMT/ || /^URI/ || /^TGN/ )
573
            {    #Scheme sharing common elements
636
            {    #Scheme sharing common elements
574
                my $bnode        = $rdf->new_bnode($deletespaces);
637
                my $objectbnode = RDF::Trine::Node::Blank->new($deletespaces);
575
                my $uri_resource = join "", $qualified, $deletespaces;
638
                my $predicate   = $map->dcterms($lowercase);
576
                my $resource     = $rdf->new_resource($uri_resource);
639
                my $object = RDF::Trine::Node::Literal->new($element_content);
577
                $rdf->assert_literal( $subject, $predicate,      $bnode );
640
                my $dcam_member_of  = $map->dcam('memberOf');
578
                $rdf->assert_literal( $bnode,   'dcam:memberOf', $resource );
641
                my $resource_schema = $map->dcterms($deletespaces);
579
                $rdf->assert_literal( $bnode,   'rdf:value',     $object );
642
                my $rdf_value       = $map->rdf('value');
643
                my $statement1 =
644
                  RDF::Trine::Statement->new( $subject, $predicate,
645
                    $objectbnode );
646
                my $statement2 =
647
                  RDF::Trine::Statement->new( $objectbnode, $dcam_member_of,
648
                    $resource_schema );
649
                my $statement3 =
650
                  RDF::Trine::Statement->new( $objectbnode, $rdf_value,
651
                    $object );
652
                $rdf->add_statement($statement1);
653
                $rdf->add_statement($statement2);
654
                $rdf->add_statement($statement3);
580
                last SWITCH;
655
                last SWITCH;
581
            }
656
            }
582
        }
657
        }
Lines 909-929 version 0.01 Link Here
909
984
910
This package requires the following modules:
985
This package requires the following modules:
911
986
912
DublinCore::Record
987
L<DublinCore::Record>
913
988
914
MARC::Record
989
L<MARC::Record>
915
990
916
MARC::File::USMARC
991
L<MARC::File::USMARC>
917
992
918
MARC::Crosswalk::DublinCore
993
L<MARC::Crosswalk::DublinCore>
919
994
920
HTML::Entities
995
L<HTML::Entities>
921
996
922
XML::Entities
997
L<HTML::Entities::Numbered>
923
998
924
XML::LibXML
999
L<XML::LibXML>
925
1000
926
RDF::Helper
1001
L<RDF::Trine>
927
1002
928
=head2 SEE ALSO
1003
=head2 SEE ALSO
929
1004
Lines 939-941 Hector Eduardo Catro Avalos E<lt> hector.hecaxmmx at gmail dot com E<gt> Link Here
939
and the Koha Development Team.
1014
and the Koha Development Team.
940
1015
941
=cut
1016
=cut
1017
(-)a/debian/control (-1 / +6 lines)
Lines 52-58 Build-Depends: libalgorithm-checkdigits-perl, Link Here
52
 libgd-gd2-noxpm-perl | libgd-gd2-perl,
52
 libgd-gd2-noxpm-perl | libgd-gd2-perl,
53
 libgraphics-magick-perl,
53
 libgraphics-magick-perl,
54
 libgravatar-url-perl,
54
 libgravatar-url-perl,
55
 libhtml-entities-numbered-perl,
55
 libhtml-format-perl,
56
 libhtml-format-perl,
57
 libhtml-parser-perl,
56
 libhtml-scrubber-perl,
58
 libhtml-scrubber-perl,
57
 libhttp-cookies-perl,
59
 libhttp-cookies-perl,
58
 libhttp-message-perl,
60
 libhttp-message-perl,
Lines 86-91 Build-Depends: libalgorithm-checkdigits-perl, Link Here
86
 libpdf-reuse-barcode-perl,
88
 libpdf-reuse-barcode-perl,
87
 libpdf-reuse-perl,
89
 libpdf-reuse-perl,
88
 libpdf-table-perl,
90
 libpdf-table-perl,
91
 librdf-trine-perl,
89
 libreadonly-perl,
92
 libreadonly-perl,
90
 libreadonly-xs-perl,
93
 libreadonly-xs-perl,
91
 libscalar-list-utils-perl,
94
 libscalar-list-utils-perl,
Lines 251-257 Depends: libalgorithm-checkdigits-perl, Link Here
251
 libgd-gd2-noxpm-perl | libgd-gd2-perl,
254
 libgd-gd2-noxpm-perl | libgd-gd2-perl,
252
 libgraphics-magick-perl,
255
 libgraphics-magick-perl,
253
 libgravatar-url-perl,
256
 libgravatar-url-perl,
257
 libhtml-entities-numbered-perl,
254
 libhtml-format-perl,
258
 libhtml-format-perl,
259
 libhtml-parser-perl,
255
 libhtml-scrubber-perl,
260
 libhtml-scrubber-perl,
256
 libhttp-cookies-perl,
261
 libhttp-cookies-perl,
257
 libhttp-message-perl,
262
 libhttp-message-perl,
Lines 285-290 Depends: libalgorithm-checkdigits-perl, Link Here
285
 libpdf-reuse-barcode-perl,
290
 libpdf-reuse-barcode-perl,
286
 libpdf-reuse-perl,
291
 libpdf-reuse-perl,
287
 libpdf-table-perl,
292
 libpdf-table-perl,
293
 librdf-trine-perl,
288
 libreadonly-perl,
294
 libreadonly-perl,
289
 libreadonly-xs-perl,
295
 libreadonly-xs-perl,
290
 libscalar-list-utils-perl,
296
 libscalar-list-utils-perl,
291
- 

Return to bug 13642