ld4l-works_rdf 0.1.0

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

@@ -0,0 +1,45 @@
+module LD4L
+  module WorksRDF
+    class GetMetadataFromVivoModel
+
+      ##
+      # Get standard display metadata from an vivo model
+      #
+      # @param [String, RDF::URI] uri for the work
+      # @param [Model] an vivo 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_vivo_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_vivo_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.pub_info         = "#{model.place_of_publication.first} : #{model.publisher.first.label.first}"  if
+            model.place_of_publication && model.place_of_publication.size > 0 &&
+            model.publisher && model.publisher.size > 0 && model.publisher.first.label
+        metadata.oclc_id          = model.oclcnum.first                  if model.oclcnum && model.oclcnum.size > 0
+        metadata.source           = "VIVO"
+        metadata.set_source_to_cornell_vivo
+        metadata
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module LD4L
+  module WorksRDF
+    class SetErrorInMetadata
+
+      ##
+      # Set an error message and basic metadata for an error state
+      #
+      # @param [String, RDF::URI] uri for the work
+      # @param [String]  error message
+      #
+      # @returns an instance of LD4L::WorksRDF::WorkMetadata with error state set
+      def self.call( uri, error_message )
+        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)
+
+        # TODO it may make more sense for handling of error messages to be in the WorkMessage model itself instead of here
+        metadata = LD4L::WorksRDF::WorkMetadata.new(nil)
+        metadata.uri              = uri
+        metadata.title            = uri
+        metadata.error            = true
+        metadata.error_message    = error_message
+        metadata
+      end
+
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/model_services/populate_bibframe_models_from_repository.rb

@@ -0,0 +1,46 @@
+module LD4L
+  module WorksRDF
+    class PopulateBibframeModelsFromRepository
+
+      ##
+      # Create a Bibframe model and populate it with metadata from the repository.
+      #
+      # @param [RDF::Repository] repository holding triples
+      #
+      # @returns an instance of one of the Bibframe work models
+      def self.call( bibframe_work_uri, repository )
+        raise ArgumentError, 'bibframe_work_uri argument must be a uri string or an instance of RDF::URI'  unless
+            bibframe_work_uri.kind_of?(String) && bibframe_work_uri.size > 0 || bibframe_work_uri.kind_of?(RDF::URI)
+
+        raise ArgumentError, 'repository argument must be an instance of RDF::Repository'  unless
+            repository.kind_of?(RDF::Repository)
+
+        bibframe_work_uri = RDF::URI(bibframe_work_uri) unless bibframe_work_uri.kind_of?(RDF::URI)
+
+        # TODO: Move to common place because this code is repeated in each model_from_repository file
+        # # Get work as a generic work
+        # work = LD4L::WorksRDF::GenericWork.new(uri, :data => repository)
+        # types = []
+        # work.type.each do |t|
+        #   types << t.to_s
+        # end
+
+        query = RDF::Query.new({
+                                   :instance => {
+                                       RDF.type =>  RDFVocabularies::BF.Instance,
+                                       RDFVocabularies::BF.instanceOf => bibframe_work_uri,
+                                   }
+                               })
+        instances = []
+        results = query.execute(repository)
+        results.each { |r| instances << r.to_hash[:instance] }
+        instances
+
+        work     = LD4L::WorksRDF::BibframeWork.new(bibframe_work_uri, :data => repository)
+        instance = LD4L::WorksRDF::BibframeInstance.new(instances.first, :data=>repository)
+
+        { :work => work, :instance => instance }
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/model_services/populate_generic_model_from_repository.rb

@@ -0,0 +1,30 @@
+module LD4L
+  module WorksRDF
+    class PopulateGenericModelFromRepository
+
+      ##
+      # Create a OCLC model and populate it with metadata from the repository.
+      #
+      # @param [RDF::Repository] repository holding triples
+      #
+      # @returns an instance of one of the OCLC work models
+      def self.call( uri, repository )
+
+        # TODO: Move to common place because this code is repeated in each model_from_repository file
+        # Get work as a generic work
+        work = LD4L::WorksRDF::GenericWork.new(uri, :data => repository)
+        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.
+        work = LD4L::WorksRDF::BiboBook.new(uri, :data => repository)      if types.include? RDFVocabularies::BIBO.Book.to_s
+        work = LD4L::WorksRDF::BiboDocument.new(uri, :data => repository)  if types.include? RDFVocabularies::BIBO.Document.to_s
+        work = LD4L::WorksRDF::PopulateBibframeModelsFromRepository.call(uri,repository)  if types.include?(RDFVocabularies::BF.Work.to_s) || types.include?(RDFVocabularies::BF.Instance.to_s)
+        work = LD4L::WorksRDF::SchemaBook.new(uri, :data => repository)    if types.include? RDF::SCHEMA.Book.to_s
+        work
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/model_services/populate_oclc_model_from_repository.rb

@@ -0,0 +1,27 @@
+module LD4L
+  module WorksRDF
+    class PopulateOclcModelFromRepository
+
+      ##
+      # Create a OCLC model and populate it with metadata from the repository.
+      #
+      # @param [RDF::Repository] repository holding triples
+      #
+      # @returns an instance of one of the OCLC work models
+      def self.call( uri, repository )
+
+        # TODO: Move to common place because this code is repeated in each model_from_repository file
+        # Get work as a generic work
+        work = LD4L::WorksRDF::GenericWork.new(uri, :data => repository)
+        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.
+        work = LD4L::WorksRDF::OclcSchemaBook.new(uri, :data => repository)  if types.include? RDF::SCHEMA.Book.to_s
+        work
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/model_services/populate_vivo_model_from_repository.rb

@@ -0,0 +1,27 @@
+module LD4L
+  module WorksRDF
+    class PopulateVivoModelFromRepository
+
+      ##
+      # Create a VIVO model and populate it with metadata from the repository.
+      #
+      # @param [RDF::Repository] repository holding triples
+      #
+      # @returns an instance of one of the VIVO work models
+      def self.call( uri, repository )
+
+        # TODO: Move to common place because this code is repeated in each model_from_repository file
+        # Get work as a generic work
+        work = LD4L::WorksRDF::GenericWork.new(uri, :data => repository)
+        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.
+        work = LD4L::WorksRDF::VivoBook.new(uri, :data => repository)  if types.include? RDFVocabularies::BIBO.Book.to_s
+        work
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/negotiation_services/get_marcxml_from_uri.rb

@@ -0,0 +1,35 @@
+module LD4L
+  module WorksRDF
+    class GetMarcxmlFromURI
+
+      ##
+      # Get marcxml populated from the URI via content negotiation.
+      #
+      # @param [String, RDF::URI] uri for the work
+      #
+      # @returns a string holding marcxml
+      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)
+
+        uri = uri.to_s if uri.kind_of?(RDF::URI)
+
+        http = Curl.get(uri) do |curl|
+          curl.headers['Accept'] = 'application/marcxml+xml'
+          curl.headers['Content-Type'] = 'application/marcxml+xml'
+          curl.headers['Api-Version'] = '2.2'
+          curl.follow_location = true
+          curl.max_redirects = 3
+          curl.connect_timeout = 30
+          curl.useragent = "curb"
+        end
+        header = http.header_str
+        response_content_type = LD4L::WorksRDF::ResponseHeader.get_content_type(header)
+        raise EncodingError, "uri returned results of type '#{response_content_type}' instead of expected 'application/marcxml+xml'"  unless response_content_type == 'application/marcxml+xml'
+
+        result = http.body_str
+        result
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/negotiation_services/get_rdfxml_from_uri.rb

@@ -0,0 +1,37 @@
+module LD4L
+  module WorksRDF
+    class GetRdfxmlFromURI
+
+      ##
+      # Get triples as rdfxml populated from the URI via content negotiation.
+      #
+      # @param [String, RDF::URI] uri for the work
+      #
+      # @returns a string holding triples as rdfxml
+      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)
+
+        uri = uri.to_s if uri.kind_of?(RDF::URI)
+
+        http = Curl.get(uri) do |curl|
+          curl.headers['Accept'] = 'application/rdf+xml'
+          curl.headers['Content-Type'] = 'application/rdf+xml'
+          curl.headers['Api-Version'] = '2.2'
+          curl.follow_location = true
+          curl.max_redirects = 3
+          curl.connect_timeout = 30
+          curl.useragent = "curb"
+        end
+        header = http.header_str
+        response_content_type = LD4L::WorksRDF::ResponseHeader.get_content_type(header)
+        raise EncodingError, "uri returned results of type '#{response_content_type}' instead of expected 'application/rdf+xml'" unless response_content_type == 'application/rdf+xml'
+
+        result = http.body_str
+        result
+      end
+    end
+  end
+end
+
+

data/lib/ld4l/works_rdf/services/negotiation_services/get_solr_results_from_solr_query.rb

@@ -0,0 +1,35 @@
+module LD4L
+  module WorksRDF
+    class GetSolrResultsFromSolrQuery
+
+      ##
+      # Get solr documents populated from the solr query url via content negotiation.
+      #
+      # @param [String] solr_query_url for the work(s)
+      #
+      # @returns a string holding solr results which may include multiple solr documents
+      def self.call( solr_query_url )
+        raise ArgumentError, 'solr_query_url argument must be a uri string'  unless solr_query_url.kind_of?(String)
+
+        http = Curl.get(solr_query_url) do |curl|
+          curl.headers['Accept'] = 'application/xml'
+          curl.headers['Api-Version'] = '2.2'
+          curl.follow_location = true
+          curl.max_redirects = 3
+          curl.connect_timeout = 30
+          curl.useragent = "curb"
+        end
+        header = http.header_str
+
+        status = LD4L::WorksRDF::ResponseHeader.get_status(header)
+        raise EncodingError, "Status #{status} returned from query"  unless status == '200'
+
+        response_content_type = LD4L::WorksRDF::ResponseHeader.get_content_type(header)
+        raise EncodingError, "uri returned results of type '#{response_content_type}' instead of expected 'application/xml'"  unless response_content_type == 'application/xml'
+
+        results = http.body_str
+        results
+      end
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/negotiation_services/get_turtle_from_uri.rb

@@ -0,0 +1,37 @@
+module LD4L
+  module WorksRDF
+    class GetTurtleFromURI
+
+      ##
+      # Get triples as turtle populated from the URI via content negotiation.
+      #
+      # @param [String, RDF::URI] uri for the work
+      #
+      # @returns a string holding triples as turtle
+      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)
+
+        uri = uri.to_s if uri.kind_of?(RDF::URI)
+
+        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
+        header = http.header_str
+        response_content_type = LD4L::WorksRDF::ResponseHeader.get_content_type(header)
+        raise EncodingError, "uri returned results of type '#{response_content_type}' instead of expected 'text/turtle'" unless response_content_type == 'text/turtle'
+
+        result = http.body_str
+        result
+      end
+    end
+  end
+end
+
+

data/lib/ld4l/works_rdf/services/negotiation_services/response_header.rb

@@ -0,0 +1,51 @@
+module LD4L
+  module WorksRDF
+    class ResponseHeader
+
+      def self.get_content_type( header )
+        parsed_header = self.parse(header)
+        content_type = parsed_header["Content-Type"]
+        content_type = content_type[0]  if content_type && content_type.kind_of?(Array) && content_type.size > 0
+        content_type
+      end
+
+      def self.get_status( header )
+        parsed_header = self.parse(header)
+        parsed_header["Status"]
+      end
+
+      # "HTTP/1.1 400 Bad Request\r\n
+      # Date: Sat, 22 Aug 2015 18:49:49 GMT\r\n
+      # Last-Modified: Sat, 22 Aug 2015 18:49:49 GMT\r\n
+      # ETag: \"14f56bed06e\"\r\n
+      # Cache-Control: no-cache, no-store\r\n
+      # Pragma: no-cache\r\n
+      # Expires: Sat, 01 Jan 2000 01:00:00 GMT\r\n
+      # Content-Type: application/xml;charset=UTF-8\r\n
+      # Connection: close\r\n\r\n"
+
+      def self.parse(header)
+        parts_hash = {}
+        parts_array = header.split("\r\n")
+        parts_array.each do |p|
+          match_data = p.match("(.*): (.*)")
+          value = nil
+          field = "Status"        if p.start_with? "HTTP/1.1"
+          value = p[9..11]        if p.start_with? "HTTP/1.1"
+          field = match_data[1]   if match_data && match_data.size > 1
+          value = match_data[2]   if match_data && match_data.size > 2
+          semicolon_split = value.split(";")  if value
+          comma_split     = value.split(",")  if value
+          if semicolon_split && semicolon_split.size > 1
+            value = semicolon_split.collect { |v| v.strip }
+          elsif comma_split && comma_split.size > 1
+            value = comma_split.collect { |v| v.strip }
+          end
+          parts_hash[field] = value  if value
+        end
+        parts_hash
+      end
+
+    end
+  end
+end

data/lib/ld4l/works_rdf/services/repository_services/populate_graph_from_rdfxml.rb

@@ -0,0 +1,22 @@
+module LD4L
+  module WorksRDF
+    class PopulateGraphFromRdfxml
+
+      ##
+      # Create an RDF::Graph populated rdfxml triples
+      #
+      # @param [String] triples represented in rdfxml
+      #
+      # @returns a populated graph with passed in rdfxml triples
+      def self.call( rdfxml )
+        raise ArgumentError, 'rdfxml argument must be a non-empty string'  unless
+            rdfxml.kind_of?(String) && rdfxml.size > 0
+
+        RDF::Graph.new.from_rdfxml rdfxml
+      end
+
+    end
+  end
+end
+
+

data/lib/ld4l/works_rdf/services/repository_services/populate_graph_from_turtle.rb

@@ -0,0 +1,21 @@
+module LD4L
+  module WorksRDF
+    class PopulateGraphFromTurtle
+
+      ##
+      # Create an RDF::Graph populated turtle triples
+      #
+      # @param [String] triples represented in turtle
+      #
+      # @returns a populated graph with passed in turtle triples
+      def self.call( turtle )
+        raise ArgumentError, 'turtle argument must be a non-empty string'  unless
+            turtle.kind_of?(String) && turtle.size > 0
+
+        RDF::Graph.new.from_ttl turtle
+      end
+    end
+  end
+end
+
+