|
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 |
|