ld4l-works_rdf 0.1.0

data/lib/ld4l/works_rdf/services/get_metadata_from_marcxml_uri.rb

@@ -0,0 +1,43 @@
+module LD4L
+  module WorksRDF
+    class GetMetadataFromMarcxmlURI
+
+      ##
+      # Get display metadata via content negotiation from an URI known to return MARCXML
+      #
+      # @param [String, RDF::URI] uri for the work
+      #
+      # @returns an instance of LD4L::WorksRDF::WorkMetadata populated with display metadata for the work located at the URI
+      def self.call( uri, localname_prefix="" )
+        raise ArgumentError, 'uri argument must be a uri string or an instance of RDF::URI'  unless
+            uri.kind_of?(String) && uri.size > 0 || uri.kind_of?(RDF::URI)
+
+        baseuri = LD4L::WorksRDF.configuration.base_uri
+        baseuri = "#{baseuri}/" unless baseuri.end_with?("/")
+
+        document_id = URI.parse(uri).path.split('/').last
+
+        bibframe_work_uri = "#{baseuri}#{localname_prefix}#{document_id}"
+
+        marcxml    = LD4L::WorksRDF::GetMarcxmlFromURI.call(uri)
+        metadata   = LD4L::WorksRDF::SetErrorInMetadata.call(uri,'ERROR: Unable to retrieve MARCXML from URI')      unless marcxml && marcxml.size > 0
+
+        rdfxml     = LD4L::WorksRDF::GetRdfxmlFromMarcxml.call(marcxml,baseuri) if marcxml && marcxml.size > 0
+        metadata   = LD4L::WorksRDF::SetErrorInMetadata.call(uri,'ERROR: Unable to convert MARCXML into RDFXMl')    unless rdfxml && rdfxml.size > 0
+
+        graph      = LD4L::WorksRDF::PopulateGraphFromRdfxml.call(rdfxml)       if rdfxml  && rdfxml.size > 0
+        metadata   = LD4L::WorksRDF::SetErrorInMetadata.call(uri,'ERROR: Unable to populate graph from RDFXML')     unless graph
+
+        repository = LD4L::WorksRDF::PopulateRepositoryFromGraph.call(graph)    if graph
+        metadata   = LD4L::WorksRDF::SetErrorInMetadata.call(uri,'ERROR: Unable to populate repository from graph') unless repository
+
+        models     = LD4L::WorksRDF::PopulateBibframeModelsFromRepository.call(bibframe_work_uri,repository)   if repository
+        metadata   = LD4L::WorksRDF::SetErrorInMetadata.call(uri,'ERROR: Unable to populate models from repository') unless models
+
+        metadata   = LD4L::WorksRDF::GetMetadataFromBibframeModels.call(uri, models)   if models
+        metadata
+
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/get_metadata_from_oclc_uri.rb

@@ -0,0 +1,25 @@
+module LD4L
+  module WorksRDF
+    class GetMetadataFromOclcURI
+
+      ##
+      # Get display metadata via content negotiation from an URI known to return OCLC produced triples
+      #
+      # @param [String, RDF::URI] uri for the work
+      #
+      # @returns an instance of LD4L::WorksRDF::WorkMetadata populated with display metadata for the work located at the URI
+      def self.call( uri )
+        raise ArgumentError, 'uri argument must be a uri string or an instance of RDF::URI'  unless
+            uri.kind_of?(String) && uri.size > 0 || uri.kind_of?(RDF::URI)
+
+        turtle     = LD4L::WorksRDF::GetTurtleFromURI.call(uri)
+        graph      = LD4L::WorksRDF::PopulateGraphFromTurtle.call(turtle)
+        repository = LD4L::WorksRDF::PopulateRepositoryFromGraph.call(graph)
+        model      = LD4L::WorksRDF::PopulateOclcModelFromRepository.call(uri,repository)
+        metadata   = LD4L::WorksRDF::GetMetadataFromOclcModel.call(uri,model)
+        metadata
+
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/get_metadata_from_solr_query.rb

@@ -0,0 +1,29 @@
+module LD4L
+  module WorksRDF
+    class GetMetadataFromSolrQuery
+
+      ##
+      # Get display metadata via content negotiation from an Cornell Solr
+      #
+      # @param [String, RDF::URI] uri for the work
+      #
+      # @returns an instance of LD4L::WorksRDF::WorkMetadata populated with display metadata for the work located at the URI
+      def self.call( solr_query_url, solr_field_translations, localname_prefix="" )
+        raise ArgumentError, 'solr_query_url argument must be a uri string'  unless solr_query_url.kind_of?(String)
+
+        results  = LD4L::WorksRDF::GetSolrResultsFromSolrQuery.call(solr_query_url)
+        return LD4L::WorksRDF::SetErrorInMetadata.call(solr_query_url,'ERROR: Unable to retrieve SOLR documents from URI') unless results && results.size > 0
+
+        results_hash = Hash.from_xml(results)
+        solr_docs = results_hash["response"]["result"]["doc"]
+        solr_docs = [ solr_docs ] unless solr_docs.is_a? Array
+
+        metadata = []
+        solr_docs.each do |solr_doc|
+          metadata << LD4L::WorksRDF::GetMetadataFromSolrDoc.call(solr_doc, solr_field_translations)
+        end
+        metadata
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/get_metadata_from_vivo_uri.rb

@@ -0,0 +1,25 @@
+module LD4L
+  module WorksRDF
+    class GetMetadataFromVivoURI
+
+      ##
+      # Get display metadata via content negotiation from an URI known to return VIVO produced triples
+      #
+      # @param [String, RDF::URI] uri for the work
+      #
+      # @returns an instance of LD4L::WorksRDF::WorkMetadata populated with display metadata for the work located at the URI
+      def self.call( uri )
+        raise ArgumentError, 'uri argument must be a uri string or an instance of RDF::URI'  unless
+            uri.kind_of?(String) && uri.size > 0 || uri.kind_of?(RDF::URI)
+
+        turtle     = LD4L::WorksRDF::GetTurtleFromURI.call(uri)
+        graph      = LD4L::WorksRDF::PopulateGraphFromTurtle.call(turtle)
+        repository = LD4L::WorksRDF::PopulateRepositoryFromGraph.call(graph)
+        model      = LD4L::WorksRDF::PopulateVivoModelFromRepository.call(uri,repository)
+        metadata   = LD4L::WorksRDF::GetMetadataFromVivoModel.call(uri,model)
+        metadata
+
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/get_model_from_uri.rb

@@ -0,0 +1,62 @@
+module LD4L
+  module WorksRDF
+    class GetModelFromURI
+
+      ##
+      # Attempt to get metadata from the source of the URI via content negotiation.
+      #
+      # @param [String, RDF::URI] uri for the work
+      #
+      # @returns an instance of one of the generic work models
+      def self.call( uri )
+        uri = uri.to_s if uri.kind_of?(RDF::URI)
+
+        # curl -L -D - -H "Accept: text/turtle" http://vivo.cornell.edu/individual/n56611
+        http = Curl.get(uri) do |curl|
+          curl.headers['Accept'] = 'text/turtle'
+          curl.headers['Content-Type'] = 'text/turtle'
+          curl.headers['Api-Version'] = '2.2'
+          curl.follow_location = true
+          curl.max_redirects = 3
+          curl.connect_timeout = 30
+          curl.useragent = "curb"
+        end
+        result = http.body_str
+        header = http.header_str
+
+        work_graph = RDF::Graph.new.from_ttl result
+        repo_name = SecureRandom.uuid.to_sym
+        # r = RDF::Repository.new
+        r = ActiveTriples::Repositories.add_repository repo_name, RDF::Repository.new
+        r << work_graph
+
+        # Get work as a generic work
+        the_work = self.get_generic_work( r, uri )
+        types = []
+        the_work.type.each do |t|
+          types << t.to_s
+        end
+
+        # Try to get more specific work
+        the_work = self.get_vivo_book( r, uri )    if types.include? RDFVocabularies::BIBO.Book.to_s
+        the_work = self.get_schema_book( r, uri )  if types.include? RDF::SCHEMA.Book.to_s
+        the_work
+      end
+
+      def self.get_generic_work( repo, uri )
+        LD4L::WorksRDF::GenericWork.new(uri, :data => repo)
+      end
+
+      def self.get_vivo_book( repo, uri )
+        LD4L::WorksRDF::VivoBook.new(uri, :data => repo)
+      end
+
+      def self.get_schema_book( repo, uri )
+        LD4L::WorksRDF::SchemaBook.new(uri, :data => repo)
+      end
+
+    end
+  end
+end
+
+

data/lib/ld4l/works_rdf/services/metadata_services/get_metadata_from_bibframe_models.rb

@@ -0,0 +1,60 @@
+module LD4L
+  module WorksRDF
+    class GetMetadataFromBibframeModels
+
+      ##
+      # Get standard display metadata from a oclc model
+      #
+      # @param [String, RDF::URI] uri for the work
+      # @param [Model] a oclc model
+      #
+      # @returns an instance of LD4L::WorksRDF::WorkMetadata
+      def self.call( uri, models )
+        raise ArgumentError, 'uri argument must be a uri string or an instance of RDF::URI'  unless
+            uri.kind_of?(String) && uri.size > 0 || uri.kind_of?(RDF::URI)
+
+        uri = uri.to_s if uri.kind_of?(RDF::URI)
+
+        # TODO: Determine type of work from the model.  Right now, only processing books.
+        metadata = self.populate_with_bibframe_book( models )  # if model.type.include? RDF::SCHEMA.Book.to_s
+        metadata.uri              = uri
+        metadata.local_id         = URI.parse(uri).path.split('/').last
+        metadata
+      end
+
+      def self.populate_with_bibframe_book( models )
+        work     = models[:work]
+        instance = models[:instance]
+
+        metadata = LD4L::WorksRDF::WorkMetadata.new(instance)
+        metadata.set_type_to_book   # TODO Hardcoding to book for now
+        metadata.title            = instance.title.first.label.first       if instance.title && instance.title.first && instance.title.first.label
+        metadata.title            = instance.title.first.title_value.first if instance.title && instance.title.first && instance.title.first.title_value
+        metadata.subtitle         = instance.title.first.subtitle.first    if instance.title && instance.title.first && instance.title.first.subtitle
+        metadata.title = "#{metadata.title} : #{metadata.subtitle}"        if metadata.subtitle && metadata.subtitle.size > 0
+        metadata.title            = instance.title_statement.first         if instance.title_statement && instance.title_statement.first
+        metadata.author           = work.contributor.first.label.first     if work.contributor && work.contributor.first && work.contributor.first.label
+        metadata.author           = work.creator.first.label.first         if work.creator && work.creator.first && work.creator.first.label
+        metadata.pub_date         = instance.publication.first.provider_date.first
+        metadata.pub_info         = instance.provider_statement.first
+        # metadata.language         = model.in_language.first
+        metadata.edition          = instance.book_edition.first
+
+        system_numbers = instance.system_number
+        system_numbers.each do |sysnum|
+          uri = sysnum.rdf_subject.to_s
+          if uri.match('.*\/oclc\/(.*)')
+            parts = URI.parse(uri).path.split('/')
+            metadata.oclc_id = parts.last     if parts.include?("oclc")
+          end
+        end
+
+
+        metadata.source           = "Bibframe"
+        # metadata.set_source_to_bibframe
+        metadata
+      end
+
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/metadata_services/get_metadata_from_bibo_model.rb

@@ -0,0 +1,42 @@
+module LD4L
+  module WorksRDF
+    class GetMetadataFromBiboModel
+
+      ##
+      # Get standard display metadata from an bibo model
+      #
+      # @param [String, RDF::URI] uri for the work
+      # @param [Model] an bibo model
+      #
+      # @returns an instance of LD4L::WorksRDF::WorkMetadata
+      def self.call( uri, model )
+        raise ArgumentError, 'uri argument must be a uri string or an instance of RDF::URI'  unless
+            uri.kind_of?(String) && uri.size > 0 || uri.kind_of?(RDF::URI)
+
+        uri = uri.to_s if uri.kind_of?(RDF::URI)
+
+        # TODO: Determine type of work from the model.  Right now, only processing books.
+        metadata = self.populate_with_bibo_book( model )  if
+            model.type.include?(RDFVocabularies::BIBO.Book.to_s) || model.type.include?(RDFVocabularies::BIBO.Document.to_s)
+        metadata.uri      = uri
+        metadata.local_id = URI.parse(uri).path.split('/').last
+        metadata
+      end
+
+      def self.populate_with_bibo_book( model )
+        # TODO: Could reach out to OCLC and get more info OR could make multiple calls to VIVO to get more info
+        metadata = LD4L::WorksRDF::WorkMetadata.new(model)
+        metadata.set_type_to_book
+        if model.title && model.title.size > 0
+          metadata.title            = model.title.first
+        elsif model.label && model.label.size > 0
+          metadata.title            = model.label.first
+        end
+        metadata.oclc_id          = model.oclcnum.first  if model.oclcnum && model.oclcnum.size > 0
+        # metadata.source           = "BIBO"
+        metadata.set_source_to_unknown
+        metadata
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/metadata_services/get_metadata_from_generic_model.rb

@@ -0,0 +1,41 @@
+module LD4L
+  module WorksRDF
+    class GetMetadataFromGenericModel
+
+      ##
+      # Attempt to get standard display metadata from a various models.
+      #
+      # @param [String, RDF::URI] uri for the work
+      # @param [Model] one of the supported models
+      #
+      # @returns an instance of one of the OCLC work models
+      def self.call( uri, model )
+        raise ArgumentError, 'uri argument must be a uri string or an instance of RDF::URI'  unless
+            uri.kind_of?(String) && uri.size > 0 || uri.kind_of?(RDF::URI)
+
+        uri = uri.to_s if uri.kind_of?(RDF::URI)
+
+        work = model[:work]  if     model.kind_of? Hash
+        work = model         unless model.kind_of? Hash
+
+        # TODO: Move to common place because this code is repeated in each model_from_repository file
+        # Get work as a generic work
+        types = []
+        work.type.each do |t|
+          types << t.to_s
+        end
+
+        # TODO: Need to support multiple types (e.g. book, music, video).  Currently only supporting books.
+        metadata = LD4L::WorksRDF::GetMetadataFromBiboModel.call(uri,model)   if types.include? RDFVocabularies::BIBO.Book.to_s
+        metadata = LD4L::WorksRDF::GetMetadataFromBiboModel.call(uri,model)   if types.include? RDFVocabularies::BIBO.Document.to_s
+        metadata = LD4L::WorksRDF::PopulateBibframeModelsFromRepository.call(uri,model)  if types.include? RDFVocabularies::BF.Work.to_s
+        metadata = LD4L::WorksRDF::GetMetadataFromOclcModel.new(uri,model)    if types.include? RDF::SCHEMA.Book.to_s
+
+        metadata.source = URI.parse(uri).host
+        metadata.set_source_to_unknown
+
+        metadata
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/metadata_services/get_metadata_from_oclc_model.rb

@@ -0,0 +1,42 @@
+module LD4L
+  module WorksRDF
+    class GetMetadataFromOclcModel
+
+      ##
+      # Get standard display metadata from a oclc model
+      #
+      # @param [String, RDF::URI] uri for the work
+      # @param [Model] a oclc model
+      #
+      # @returns an instance of LD4L::WorksRDF::WorkMetadata
+      def self.call( uri, model )
+        raise ArgumentError, 'uri argument must be a uri string or an instance of RDF::URI'  unless
+            uri.kind_of?(String) && uri.size > 0 || uri.kind_of?(RDF::URI)
+
+        uri = uri.to_s if uri.kind_of?(RDF::URI)
+
+        # TODO: Determine type of work from the model.  Right now, only processing books.
+        metadata = self.populate_with_schema_book( model )  if model.type.include? RDF::SCHEMA.Book.to_s
+        metadata.uri      = uri
+        metadata.local_id = URI.parse(uri).path.split('/').last
+        metadata
+      end
+
+      def self.populate_with_schema_book( model )
+        metadata = LD4L::WorksRDF::WorkMetadata.new(model)
+        metadata.set_type_to_book
+        metadata.title            = model.title.first                    if model.title && model.title.size > 0
+        metadata.author           = model.creator.first.full_name.first  if model.creator && model.creator.size > 0 && model.creator.first.full_name
+        metadata.pub_date         = model.date_published.first           if model.date_published && model.date_published.size > 0
+        metadata.pub_info         = "#{model.place_of_publication.first} : #{model.publisher.first}, #{model.date_published.first}"
+        metadata.language         = model.in_language.first              if model.in_language && model.in_language.size > 0
+        metadata.edition          = model.book_edition.first             if model.book_edition && model.book_edition.size > 0
+        metadata.oclc_id          = model.oclcnum.first
+        metadata.source           = "OCLC Worldcat"
+        metadata.set_source_to_oclc
+        metadata
+      end
+
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/metadata_services/get_metadata_from_solr_doc.rb

@@ -0,0 +1,67 @@
+module LD4L
+  module WorksRDF
+    class GetMetadataFromSolrDoc
+
+      # TODO This is Cornell specific.  Need a general processor of solr OR a callback to an institution specific processor.
+      ##
+      # Get metadata from solr document.
+      #
+      # @param [Hash] solr document
+      # @param [Hash] translations identifying location in solr doc for metadata fields
+      #
+      # @returns an instance of one of the OCLC work models
+      def self.call( solr_doc, solr_field_translations )
+        flat_doc = flatten(solr_doc["arr"])
+        flat_doc.merge! interpret_str(solr_doc["str"])
+        metadata = self.populate_with_solr_values(flat_doc, solr_field_translations)
+        metadata
+      end
+
+      def self.populate_with_solr_values( solr_doc, solr_field_translations )
+        metadata = LD4L::WorksRDF::WorkMetadata.new()
+
+        metadata.source           = "Cornell Library"
+        metadata.set_source_to_cornell_library
+
+        # metadata.format           = solr_doc["format"].upcase.to_sym
+        metadata.set_type(solr_doc["format"])
+        metadata.local_id         = solr_doc["id"]
+        metadata.uri              = "https://newcatalog.library.cornell.edu/catalog/"+metadata.local_id
+        metadata.title            = solr_doc["title"]
+        metadata.author           = solr_doc["author"]
+        metadata.pub_date         = solr_doc["pub_date_display"]
+        metadata.pub_info         = solr_doc["pub_info_display"]
+        metadata.language         = solr_doc["language_display"]
+        metadata.edition          = solr_doc["edition_display"]
+
+        other_ids = solr_doc["other_id_display"]
+        oclc_id = nil
+        oclc_id = other_ids.select { |id| id.start_with? "(OCoLC)" } if other_ids.is_a? Array
+        oclc_id = oclc_id.first if (oclc_id.is_a? Array) && (oclc_id.size > 0)
+        oclc_id = other_ids if (other_ids.is_a? String) && (other_ids.start_with? "(OCoLC)")
+        metadata.oclc_id = oclc_id[7..-1] unless (oclc_id.nil?) || (!oclc_id.is_a? String)
+
+        metadata
+      end
+
+      def self.flatten( solr_doc )
+        flat_hash = {}
+        solr_doc.each do |h|
+          name = h["name"]
+          value = h["str"]
+          flat_hash[name] = value
+        end
+        flat_hash
+      end
+
+      def self.interpret_str( str_field )
+        flat_hash = {}
+        flat_hash["id"] = str_field.first
+        flat_hash["author"] = str_field[1] if str_field.size > 3
+        flat_hash["title"] = str_field.last
+        flat_hash
+      end
+
+    end
+  end
+end