exlibris-primo 0.1.5 → 1.0.0

data/lib/exlibris/primo/link.rb

@@ -0,0 +1,32 @@
+module Exlibris
+  module Primo
+    # 
+    # Abstract class representing a link in Primo.
+    # 
+    class Link
+      include Abstract
+      include Config::Attributes
+      include WriteAttributes
+
+      self.abstract = true
+
+      attr_accessor :record_id, :original_id,
+        :url, :display, :notes, :subfields
+    end
+
+    # 
+    # Primo fulltext link.
+    # 
+    class Fulltext < Link; end
+
+    # 
+    # Primo table of contents link.
+    # 
+    class TableOfContents < Link; end
+
+    # 
+    # Primo related link.
+    # 
+    class RelatedLink < Link; end
+  end
+end

data/lib/exlibris/primo/namespaces.rb

@@ -0,0 +1,44 @@
+module Exlibris
+  module Primo
+    # 
+    # Primo namespaces used in Primo XML
+    # 
+    module Namespaces
+      def self.included(klass)
+        klass.class_eval do
+          extend ClassAttributes
+        end
+      end
+
+      module ClassAttributes
+        def response_namespaces
+          @response_namespaces = {
+            "search" => "http://www.exlibrisgroup.com/xsd/jaguar/search",
+            "eshelf" => "http://www.exlibris.com/primo/xsd/primoeshelffolder",
+            "pnx" => "http://www.exlibrisgroup.com/xsd/primo/primo_nm_bib",
+            "tags_reviews" => "http://com/exlibris/primo/xsd/tagsAndReview/config"
+          }
+        end
+
+        def request_namespaces
+          @request_namespaces = {
+            "xmlns" => "http://www.exlibris.com/primo/xsd/wsRequest",
+            "xmlns:uic" => "http://www.exlibris.com/primo/xsd/primoview/uicomponents"
+          }
+        end
+      end
+
+      # Returns response namespaces
+      def response_namespaces
+        @response_namespaces ||= self.class.response_namespaces
+      end
+      protected :response_namespaces
+
+      # Returns request namespaces
+      def request_namespaces
+        @request_namespaces ||= self.class.request_namespaces
+      end
+      protected :request_namespaces
+    end
+  end
+end

data/lib/exlibris/primo/pnx/dedup_mgr.rb

@@ -0,0 +1,91 @@
+module Exlibris
+  module Primo
+    module Pnx
+      # 
+      # Handle PNX dedupmgr elements
+      # 
+      module DedupMgr
+
+        def self.included(klass)
+          klass.class_eval do
+            extend ClassAttributes
+          end
+        end
+
+        module ClassAttributes
+          def duplicated_control_attributes
+            @duplicated_control_attributes ||= self.superclass.respond_to?(:duplicated_control_attributes) ?
+              self.superclass.duplicated_control_attributes.dup : []
+          end
+
+          def add_duplicated_control_attributes *elements
+            elements.each do |element|
+              duplicated_control_attributes << element unless duplicated_control_attributes.include? element
+            end
+          end
+          protected :add_duplicated_control_attributes
+
+          def remove_duplicated_control_attributes *elements
+            duplicated_control_attributes.delete_if do |element|
+              elements.include? element
+            end
+          end
+          protected :remove_duplicated_control_attributes
+        end
+
+        #
+        # Is the record a dedupmrg record?
+        #
+        def dedupmgr?
+          @dedupmgr ||= recordid.match /\Adedupmrg/
+        end
+
+        #
+        # Return the class level duplicated control attributes
+        #
+        def duplicated_control_attributes
+          @duplicated_control_attributes ||= self.class.duplicated_control_attributes
+        end
+        protected :duplicated_control_attributes
+
+        #
+        # Dynamically set the duplicated control attributes.
+        #
+        def method_missing(method, *args, &block)
+          if(duplicated_control_attributes.include? method)
+            control_attribute = method.id2name.singularize
+            self.class.send(:define_method, method) do
+              eval("@#{method} ||= (dedupmgr?) ?
+                map_values_to_origins(\"#{control_attribute}\") : {recordid => #{control_attribute}}")
+            end
+            send method, *args, &block
+          else
+            super
+          end
+        end
+
+        #
+        # Tell users we respond to pluralized PNX control elements
+        #
+        def respond_to?(method, include_private=false)
+          (duplicated_control_attributes.include? method) ? true : super
+        end
+
+        #
+        # Map values to origins for the given field
+        #
+        def map_values_to_origins(field)
+          values_to_origins_map = {}
+          xml.root.xpath("control/#{field}").each do |element|
+            # Parse subfields, O is origin, V is value
+            subfields = parse_subfields(element.inner_text)
+            # Map values to the origin
+            values_to_origins_map[subfields["O"]] = subfields["V"]
+          end
+          values_to_origins_map
+        end
+        private :map_values_to_origins
+      end
+    end
+  end
+end

data/lib/exlibris/primo/pnx/elements.rb

@@ -0,0 +1,79 @@
+module Exlibris
+  module Primo
+    module Pnx
+      # 
+      # Provides access to PNX elements
+      # 
+      module Elements
+        #
+        # Parses elements from PNX base on the pattern
+        # parentname_childname e.g.
+        #     record.display_title #=> "Travels with my aunt"
+        # based on the XML
+        #     <record>
+        #       ...
+        #       <display>
+        #         ...
+        #         <title>Travels with my aunt</title>
+        #         ...
+        #       </display>
+        #       ...
+        #     </record>
+        #
+        def method_missing(method, *args, &block)
+          if(attr_read(method))
+            self.class.send(:define_method, method) {
+              if "#{method}".start_with? "all_"
+                eval("@#{method} ||= #{attr_read(method).inspect}")
+              else
+                eval("@#{method} ||= #{attr_read(method).inspect}")
+              end
+            }
+            send method, *args, &block
+          else
+            super
+          end
+        end
+
+        #
+        # Tell user we respond to PNX elements
+        #
+        def respond_to?(method, include_private=false)
+          (attr_read(method)) ? true : super
+        end
+
+        def attr_read method
+          if("#{method}".start_with? "all_")
+            (inner_text_all(xpathize(method)) || inner_text_all(controlize(method)))
+          else
+            (inner_text_at(xpathize(method)) || inner_text_at(controlize(method)))
+          end
+        end
+        private :attr_read
+
+        def inner_text_all xpath
+          xml.root.xpath(xpath).collect do |element|
+            element.inner_text
+          end
+        end
+        private :inner_text_all
+
+        def inner_text_at xpath
+          xml_at = xml.root.at_xpath(xpath)
+          xml_at.inner_text if xml_at
+        end
+        private :inner_text_at
+
+        def controlize s
+          "control/#{xpathize s.to_s}"
+        end
+        private :controlize
+
+        def xpathize s
+          "#{s.to_s}".gsub(/^all_/, "").gsub(/_/, "/").gsub(/[=\[\]]/, "")
+        end
+        private :xpathize
+      end
+    end
+  end
+end

data/lib/exlibris/primo/pnx/frbr.rb

@@ -0,0 +1,24 @@
+module Exlibris
+  module Primo
+    module Pnx
+      # 
+      # Handle frbr records
+      # 
+      module Frbr
+        #
+        # Is this a frbr'd record
+        #
+        def frbr?
+          @frbr ||= (respond_to? :facets_frbrgroupid)
+        end
+
+        #
+        # Returns the frbr id of this record if there is one.
+        #
+        def frbr_id
+          @frbr_id ||= facets_frbrgroupid if frbr?
+        end
+      end
+    end
+  end
+end

data/lib/exlibris/primo/pnx/holdings.rb

@@ -0,0 +1,36 @@
+module Exlibris
+  module Primo
+    module Pnx
+      # 
+      # Handle holdings in availlibrary tags.
+      # 
+      module Holdings
+        #
+        # Gather Holdings for this record.
+        #
+        def holdings
+          @holdings ||=  xml.root.xpath("display/availlibrary").collect do |availlibrary|
+            subfields = parse_subfields availlibrary.inner_text
+            # Get original id for dealing w/ dedup merger records
+            original_id = (subfields["O"]) ? subfields["O"] : recordid
+            # Get some info that may or may not be in the PNX metadata
+            title = self.display_title if self.respond_to? :display_title
+            author = self.display_creator if self.respond_to? :display_creator
+            display_type = self.display_type if self.respond_to? :display_type
+            # Add a new holding to the record's holdings.
+            Exlibris::Primo::Holding.new(
+              :availlibrary => availlibrary.inner_text,
+              :record_id => recordid, :original_id => original_id,
+              :title => title, :author => author, :display_type => display_type,
+              :original_source_id => originalsourceids[original_id], :source_id => sourceids[original_id],
+              :source_record_id => sourcerecordids[original_id], :ils_api_id => ilsapiids[original_id],
+              :institution_code => subfields["I"],
+              :library_code => subfields["L"],
+              :collection => subfields["1"], :call_number => subfields["2"],
+              :subfields => subfields, :availability_status_code => subfields["S"])
+            end
+        end
+      end
+    end
+  end
+end

data/lib/exlibris/primo/pnx/links.rb

@@ -0,0 +1,54 @@
+module Exlibris
+  module Primo
+    module Pnx
+      # 
+      # Handle links in links tags.
+      # 
+      module Links
+        #
+        # Parse linktorsrc tags to find full text links
+        #
+        def fulltexts
+          @fulltexts ||= 
+            links("linktorsrc").collect { |link_attributes| 
+              Exlibris::Primo::Fulltext.new link_attributes }
+        end
+        
+        #
+        # Parse addlink tags to find related links
+        #
+        def related_links
+          @fulltexts ||= 
+            links("addlink").collect { |link_attributes| 
+              Exlibris::Primo::RelatedLink.new link_attributes }
+        end
+        
+        #
+        # Parse linktotoc tags to find table of contents links
+        #
+        def tables_of_contents
+          @tables_of_contents ||= 
+            links("linktotoc").collect { |link_attributes| 
+              Exlibris::Primo::TableOfContents.new link_attributes }
+        end
+
+        #
+        # Parse links tags
+        #
+        def links(link)
+          xml.root.xpath("links/#{link}").collect do |link|
+            subfields = parse_subfields link.inner_text
+            # Get original id for dealing w/ dedup merger records
+            original_id = (subfields["O"]) ? subfields["O"] : recordid
+            # We're not interested if we don't have a URL
+            next if subfields["U"].nil?
+            { :institution => subfields["I"],
+              :record_id => recordid, :original_id => original_id,
+              :url => subfields["U"], :display => subfields["D"] }
+          end
+        end
+        private :links
+      end
+    end
+  end
+end

data/lib/exlibris/primo/pnx/openurl.rb

@@ -0,0 +1,24 @@
+module Exlibris
+  module Primo
+    module Pnx
+      # 
+      # Handle OpenURL elements
+      # 
+      module Openurl
+        #
+        # Parse addata to provide an OpenURL query string
+        #
+        def openurl
+          @openurl ||= ""
+          if @openurl.blank?
+            xml.root.xpath("addata/*").each do |addata|
+              @openurl << "rft.#{addata.name}=#{addata.inner_text}&" unless (addata.inner_text.nil? or addata.inner_text.strip.empty?)
+            end
+            @openurl << "rft.primo=#{@record_id}"
+          end
+          @openurl
+        end
+      end
+    end
+  end
+end

data/lib/exlibris/primo/pnx/subfields.rb

@@ -0,0 +1,18 @@
+module Exlibris
+  module Primo
+    module Pnx
+      # 
+      # Handle PNX subfields
+      # 
+      module Subfields
+        #
+        # Return a Hash of subfields as keys with their corresponding values
+        #
+        def parse_subfields s
+          Hash[s.scan(/\${2}([^\$])([^\$]+)/)]
+        end
+        protected :parse_subfields
+      end
+    end
+  end
+end

data/lib/exlibris/primo/record.rb

@@ -1,116 +1,30 @@
 module Exlibris
   module Primo
-    # == Overview
-    # Exlibris::Primo::Record is an abstract representation of a Primo record.
-    # An instance of Exlibris::Primo::Record can be created by passing
-    # in a hash with setup parameters.
-    # Valid parameters include:
-    #   :base_url, :resolver_base_url, :vid, :institution, :record_id, :record
-    # A URL to the native record (dlDisplay.do) and an OpenUrl are generated by default. 
-    # If no resolver_base_url is provided, an OpenUrl querystring will be returned.
-    # A raw_xml attribute is generated either by the record XML passed in or by fetching it from the record_id.
-    # By default the raw_xml is not included in the hash representation, but can be overridden to.
     #
-    # == Tips on Extending
-    # When extending the class, a few basics guidelines should be observed.
-    # 1.  A Exlibris::Primo::Record is initialized from a Hash of parameters.
-    #     These params are used to create instance variables of the record attributes.
+    # Primo record
+    # Includes PNX elements such as
+    # holdings, links, openurl, frbr status
+    # dedupmgr status.
     #
-    # 2.  The following methods are available for overriding:
-    #     to_h -    if a sub class creates more instance variables, these should be added to the hash
-    #     raw  -    cleans up characters and spaces in raw record and wraps in <record /> tag, implementations may differ
-    #
-    # == Examples of usage
-    #   Record.new({ :base_url => @base_url, :vid => @vid, :record => doc.at("//record") })
     class Record
-      # Leverage ActiveSupport's Hash#from_xml method to transform PNX to JSON.
-      require 'active_support/core_ext'
-      require 'json'      
-
-      SEAR_NS = {'sear' => 'http://www.exlibrisgroup.com/xsd/jaguar/search'}
-      attr_reader :record_id, :type, :title, :url, :openurl, :creator, :raw_xml
-      
-      def initialize(parameters={})
-          # Get base url of Primo application, required
-          base_url = parameters[:base_url]
-          raise_required_setup_parameter_error :base_url if base_url.nil?
-          # Get base url of link resolver, if blank openurl generates just querystring
-          resolver_base_url = parameters[:resolver_base_url]
-          # Get vid from parameters, required
-          vid = parameters.fetch(:vid, "DEFAULT")
-          raise_required_setup_parameter_error :vid if vid.nil?
-          # Get institution from parameters, required
-          institution = parameters.fetch(:institution, "PRIMO")
-          raise_required_setup_parameter_error :institution if institution.nil?
-          # Get record: either fetch record from Web Service based on DocId or use passed in record xml, required
-          record = (parameters[:record].nil?) ? 
-              (parameters[:record_id].nil?) ? 
-                  nil : record_from_id(parameters.delete(:record_id), base_url, {:institution => institution, :vid => vid}) : parameters.delete(:record)
-          raise_required_setup_parameter_error "record or record_id" if record.nil?
-          # Set instance variables for record
-          @record_id = record.at("control/recordid",record.namespaces).inner_text unless record.at("control/recordid",record.namespaces).nil?
-          @type = record.at("display/type",record.namespaces).inner_text unless record.at("display/type",record.namespaces).nil?
-          @title = record.at("display/title",record.namespaces).inner_text unless record.at("display/title",record.namespaces).nil?
-          @url = construct_url(base_url, @record_id, institution, vid)
-          @openurl = construct_openurl(resolver_base_url, record, @record_id)
-          @creator = record.at("display/creator",record.namespaces).inner_text unless record.at("display/creator",record.namespaces).nil?
-          @raw_xml = raw(record)
-      end
+      include Config::Attributes
+      include Namespaces
+      include WriteAttributes
+      include XmlUtil
+      include Exlibris::Primo::Pnx::DedupMgr
+      include Exlibris::Primo::Pnx::Elements
+      include Exlibris::Primo::Pnx::Frbr
+      include Exlibris::Primo::Pnx::Holdings
+      include Exlibris::Primo::Pnx::Links
+      include Exlibris::Primo::Pnx::Openurl
+      include Exlibris::Primo::Pnx::Subfields
 
-      # Return a hash representation of the primary record attributes
-      def to_h
-          return {
-              "format" => @type.capitalize, 
-              "title" => @title, 
-              "author" => @creator,
-              "url" => @url,
-              "openurl" => @openurl
-          }
-      end
-      
-      # Return a JSON representation of the PNX record
-      def to_json
-        # Leverage ActiveSupport's Hash#from_xml method to transform PNX to JSON.
-        Hash.from_xml(raw_xml).to_json
-      end
-      
-      # Method for cleaning up raw xml from record
-      def raw(record)
-        record.to_xml(:indent => 0, :encoding => 'UTF-8')
-      end
-
-      private
-      # Method for consturcting openurl from record
-      def construct_openurl(resolver_base_url, record, record_id)
-          raise_required_setup_parameter_error :record if record.nil?
-          raise_required_setup_parameter_error :record_id if record_id.nil?
-          openurl = (resolver_base_url.nil?) ? "?" : "#{resolver_base_url}?"
-          record.search("addata/*",record.namespaces).each do |addata|
-            openurl << "rft.#{addata.name}=#{addata.inner_text}&" unless (addata.inner_text.nil? or addata.inner_text.strip.empty?)
-          end
-          openurl << "rft.primo=#{record_id}"
-          return openurl
-      end
-    
-      # Method for constructing deep link url from record
-      def construct_url(base_url, record_id, institution, vid)
-          raise_required_setup_parameter_error :base_url if base_url.nil?
-          raise_required_setup_parameter_error :record_id if record_id.nil?
-          raise_required_setup_parameter_error :institution if institution.nil?
-          raise_required_setup_parameter_error :vid if vid.nil?
-          url = "#{base_url}/primo_library/libweb/action/dlDisplay.do?dym=false&onCampus=false&docId=#{record_id}&institution=#{institution}&vid=#{vid}"
-          return url
-      end
-
-      # Fetch record from Primo Web Service
-      def record_from_id(record_id, base_url, options={})
-          doc = Exlibris::Primo::WebService::GetRecord.new(record_id, base_url, options).response.at("//sear:DOC", SEAR_NS)
-          return doc.at("//xmlns:record",doc.namespaces)
-      end
+      add_duplicated_control_attributes :sourcerecordids, :sourceids,
+          :originalsourceids, :sourceformats, :sourcesystems, :ilsapiids
 
-      # Raise error wrapper
-      def raise_required_setup_parameter_error(parameter)
-          raise ArgumentError.new("Error in #{self.class}. Missing required setup parameter: #{parameter}.")
+      def initialize *args
+        @raw_xml = args.last.delete(:raw_xml)
+        super
       end
     end
   end