bplmodels 0.0.91 → 0.0.93

data/app/models/bplmodels/page_metadata.rb

@@ -0,0 +1,56 @@
+module Bplmodels
+  class PageMetadata < ActiveFedora::OmDatastream
+    include OM::XML::Document
+
+    OAI_NS = 'http://www.bpl.org/repository/xml/ns/page'
+    OAI_SCHEMA = 'http://www.bpl.org/repository/xml/xsd/page.xsd'
+    OAI_PARAMS = {
+        "version"            => "0.0.1",
+        "xmlns:xlink"        => "http://www.w3.org/1999/xlink",
+        "xmlns:xsi"          => "http://www.w3.org/2001/XMLSchema-instance",
+        "xmlns"              => OAI_NS,
+        "xsi:schemaLocation" => "#{OAI_NS} #{OAI_SCHEMA}",
+    }
+
+    set_terminology do |t|
+      t.root :path => 'pageData', :xmlns => OAI_NS
+
+      t.page(:path=>"page") {
+        t.page_type(:path=>'pageType')
+        t.hand_side(:path=>'handSide')
+        t.page_number(:path=>'pageNumber') {
+          t.sequence(:path=>{:attribute=>"sequence"})
+        }
+        t.has_djvu(:path=>'hasDJVU')
+        t.has_ocrMaster(:path=>'hasOCRMaster')
+
+
+      }
+
+    end
+
+    def self.xml_template
+=begin
+      builder = Nokogiri::XML::Builder.new(:encoding => "UTF-8") do |xml|
+        xml.book(OAI_PARAMS) {
+          xml.parent.namespace = xml.parent.namespace_definitions.find{|ns|ns.prefix=="book"}
+
+        }
+      end
+      return builder.doc
+=end
+      Nokogiri::XML::Builder.new do |xml|
+        xml.pageData(OAI_PARAMS) {
+
+        }
+      end.doc
+
+    end
+
+    #Required for Active Fedora 9
+    def prefix(path=nil)
+      return ''
+    end
+
+  end
+end

data/app/models/bplmodels/transcription_file.rb

@@ -0,0 +1,14 @@
+module Bplmodels
+  class TranscriptionFile < Bplmodels::File
+
+    # Use a callback method to declare which derivatives you want
+    makes_derivatives :generate_derivatives
+
+    def fedora_name
+      'transciption_file'
+    end
+
+
+
+  end
+end

data/app/models/bplmodels/volume.rb

@@ -0,0 +1,37 @@
+module Bplmodels
+  class Volume < Bplmodels::ComplexObjectBase
+    #has_file_datastream :name => 'productionMaster', :type => ActiveFedora::Datastream
+
+    has_and_belongs_to_many :collection, :class_name => 'Bplmodels::Book', :property => :is_volume_of
+
+
+    #A collection can have another collection as a member, or an image
+    def insert_member(fedora_object)
+      if (fedora_object.instance_of?(Bplmodels::ImageFile))
+
+        #add to the members ds
+        members.insert_member(:member_id=>fedora_object.pid, :member_title=>fedora_object.titleSet_display, :member_type=>fedora_object.fedora_name)
+
+        #add to the rels-ext ds
+        fedora_object.object << self
+        self.image_files << fedora_object
+
+      end
+
+      fedora_object.save!
+      self.save!
+
+    end
+
+    def fedora_name
+      'volume'
+    end
+
+    def to_solr(doc = {} )
+      doc = super(doc)
+      doc['active_fedora_model_ssi'] = self.class.name
+      doc
+    end
+
+  end
+end

data/app/models/bplmodels/workflow_metadata.rb

@@ -49,6 +49,11 @@ module Bplmodels
         t.reason(:path=>'reason')
       }
 
+      t.volume_match_md5s(:path=>'volumeMatchMD5s') {
+        t.marc(:path=>'marc')
+        t.iaMeta(:path=>'iaMeta')
+      }
+
     end
 
     def self.xml_template
@@ -65,6 +70,7 @@ module Bplmodels
     end
 
 
+
     def insert_file_path(value=nil)
       ingest_filepath_index = self.item_source.ingest_filepath.count
 

data/lib/active_fedora/rdf/indexing_service.rb

@@ -0,0 +1,88 @@
+module ActiveFedora::RDF
+  # Responsible for generating the solr document (via #generate_solr_document) of the
+  # given object.
+  #
+  # @see ActiveFedora::Indexing
+  # @see ActiveFedora::IndexingService
+  class IndexingService
+    include Solrizer::Common
+    attr_reader :object
+
+    # @param obj [#resource, #rdf_subject] the object to build an solr document for. Its class must respond to 'properties'
+    def initialize(obj)
+      @object = obj
+    end
+
+    # Creates a solr document hash for the rdf assertions of the {#object}
+    # @yield [Hash] yields the solr document
+    # @return [Hash] the solr document
+    def generate_solr_document(prefix_method = nil)
+      solr_doc = add_assertions(prefix_method)
+      yield(solr_doc) if block_given?
+      solr_doc
+    end
+
+    protected
+
+    def add_assertions(prefix_method, solr_doc = {})
+      fields.each do |field_key, field_info|
+        solr_field_key = solr_document_field_name(field_key, prefix_method)
+        field_info.values.each do |val|
+          append_to_solr_doc(solr_doc, solr_field_key, field_info, val)
+        end
+      end
+      solr_doc
+    end
+
+    # Override this in order to allow one field to be expanded into more than one:
+    #   example:
+    #     def append_to_solr_doc(solr_doc, field_key, field_info, val)
+    #       Solrizer.set_field(solr_doc, 'lcsh_subject_uri', val.to_uri, :symbol)
+    #       Solrizer.set_field(solr_doc, 'lcsh_subject_label', val.to_label, :searchable)
+    #     end
+    def append_to_solr_doc(solr_doc, solr_field_key, field_info, val)
+      self.class.create_and_insert_terms(solr_field_key,
+                                         solr_document_field_value(val),
+                                         field_info.behaviors, solr_doc)
+    end
+
+    def solr_document_field_name(field_key, prefix_method)
+      if prefix_method
+        prefix_method.call(field_key)
+      else
+        field_key.to_s
+      end
+    end
+
+    def solr_document_field_value(val)
+      case val
+        when ::RDF::URI
+          val.to_s
+        when ActiveTriples::Resource
+          val.node? ? val.rdf_label : val.rdf_subject.to_s
+        else
+          val
+      end
+    end
+
+    def resource
+      object.resource
+    end
+
+    def index_config
+      object.class.index_config
+    end
+
+    # returns the field map instance
+    def fields
+      field_map_class.new do |field_map|
+        index_config.each { |name, index_field_config| field_map.insert(name, index_field_config, object) }
+      end
+    end
+
+    # Override this method to use your own FieldMap class for custom indexing of objects and properties
+    def field_map_class
+      ActiveFedora::RDF::FieldMap
+    end
+  end
+end

data/lib/active_fedora/rdf/term.rb

@@ -0,0 +1,189 @@
+
+module ActiveFedora::Rdf
+  class Term
+    attr_accessor :parent, :value_arguments, :node_cache
+    delegate *(Array.public_instance_methods - [:__send__, :__id__, :class, :object_id] + [:as_json]), :to => :result
+    def initialize(parent, value_arguments)
+      self.parent = parent
+      self.value_arguments = value_arguments
+    end
+
+    def clear
+      set(nil)
+    end
+
+    def result
+      result = parent.query(:subject => rdf_subject, :predicate => predicate)
+                   .map{|x| convert_object(x.object)}
+                   .reject(&:nil?)
+      return result if !property_config || property_config[:multivalue]
+      result.first
+    end
+
+    def set(values)
+      values = [values].compact unless values.kind_of?(Array)
+      empty_property
+      values.each do |val|
+        set_value(val)
+      end
+      parent.persist! if parent.class.repository == :parent && parent.send(:repository)
+    end
+
+    def empty_property
+      parent.query([rdf_subject, predicate, nil]).each_statement do |statement|
+        if !uri_class(statement.object) || uri_class(statement.object) == class_for_property
+          parent.delete(statement)
+        end
+      end
+    end
+
+    def build(attributes={})
+      new_subject = attributes.key?('id') ? attributes.delete('id') : RDF::Node.new
+      node = make_node(new_subject)
+      node.attributes = attributes
+      if parent.kind_of? List::ListResource
+        parent.list << node
+        return node
+      elsif node.kind_of? RDF::List
+        self.push node.rdf_subject
+        return node
+      end
+      self.push node
+      node
+    end
+
+    def first_or_create(attributes={})
+      result.first || build(attributes)
+    end
+
+    def delete(*values)
+      values.each do |value|
+        parent.delete([rdf_subject, predicate, value])
+      end
+    end
+
+    def << (values)
+      values = Array.wrap(result) | Array.wrap(values)
+      self.set(values)
+    end
+
+    alias_method :push, :<<
+
+    def property_config
+      return type_property if (property == RDF.type || property.to_s == "type") && !parent.send(:properties)[property]
+      parent.send(:properties)[property]
+    end
+
+    def type_property
+      {:multivalue => true, :predicate => RDF.type}
+    end
+
+    def reset!
+    end
+
+    def property
+      value_arguments.last
+    end
+
+    def rdf_subject
+      raise ArgumentError("wrong number of arguments (#{value_arguments.length} for 1-2)") if value_arguments.length < 1 || value_arguments.length > 2
+      if value_arguments.length > 1
+        value_arguments.first
+      else
+        parent.rdf_subject
+      end
+    end
+
+    protected
+
+    def node_cache
+      @node_cache ||= {}
+    end
+
+    def set_value(val)
+      object = val
+      val = val.resource if val.respond_to?(:resource)
+      val = value_to_node(val)
+      if val.kind_of? Resource
+        node_cache[val.rdf_subject] = nil
+        add_child_node(val, object)
+        return
+      end
+      val = val.to_uri if val.respond_to? :to_uri
+      raise 'value must be an RDF URI, Node, Literal, or a valid datatype. See RDF::Literal' unless
+          val.kind_of? RDF::Value or val.kind_of? RDF::Literal
+      parent.insert [rdf_subject, predicate, val]
+    end
+
+    def value_to_node(val)
+      valid_datatype?(val) ? RDF::Literal(val) : val
+    end
+
+    def add_child_node(resource,object=nil)
+      parent.insert [rdf_subject, predicate, resource.rdf_subject]
+      resource.parent = parent unless resource.frozen?
+      self.node_cache[resource.rdf_subject] = (object ? object : resource)
+      resource.persist! if resource.class.repository == :parent
+    end
+
+    def predicate
+      return property_config[:predicate] unless property.kind_of? RDF::URI
+      property
+    end
+
+    def valid_datatype?(val)
+      val.is_a? String or val.is_a? Date or val.is_a? Time or val.is_a? Numeric or val.is_a? Symbol or val == !!val
+    end
+
+    # Converts an object to the appropriate class.
+    def convert_object(value)
+      value = value.object if value.kind_of? RDF::Literal
+      value = make_node(value) if value.kind_of? RDF::Resource
+      value
+    end
+
+    ##
+    # Build a child resource or return it from this object's cache
+    #
+    # Builds the resource from the class_name specified for the
+    # property.
+    def make_node(value)
+      klass = class_for_value(value)
+      value = RDF::Node.new if value.nil?
+      node = node_cache[value] if node_cache[value]
+      node ||= klass.from_uri(value,parent)
+      return nil if property_config[:class_name] && class_for_value(value) != class_for_property
+      self.node_cache[value] ||= node
+      node
+    end
+
+    def final_parent
+      @final_parent ||= begin
+        parent = self.parent
+        while parent != parent.parent && parent.parent
+          parent = parent.parent
+        end
+        return parent.datastream if parent.respond_to?(:datastream) && parent.datastream
+        parent
+      end
+    end
+
+    def class_for_value(v)
+      uri_class(v) || class_for_property
+    end
+
+    def uri_class(v)
+      v = RDF::URI.new(v) if v.kind_of? String
+      type_uri = parent.query([v, RDF.type, nil]).to_a.first.try(:object)
+      ActiveFedora::Rdf::Resource.type_registry[type_uri]
+    end
+
+    def class_for_property
+      klass = property_config[:class_name]
+      klass ||= ActiveFedora::Rdf::Resource
+      klass = ActiveFedora.class_from_string(klass, final_parent.class) if klass.kind_of? String
+      klass
+    end
+
+  end
+end

data/lib/bplmodels/constants.rb

@@ -20,6 +20,7 @@ module Bplmodels
     GENRE_LOOKUP['Books'] = {:id=>'tgm001221', :authority=>'gmgpc'}
     GENRE_LOOKUP['Albums'] = {:id=>'tgm000229', :authority=>'gmgpc'}
     GENRE_LOOKUP['Musical notation'] = {:id=>'tgm006926', :authority=>'lctgm'}
+    GENRE_LOOKUP['Music'] = {:id=>'tgm006906', :authority=>'lctgm'}
 
     COUNTRY_TGN_LOOKUP = {}
     COUNTRY_TGN_LOOKUP['United States'] = {:tgn_id=>7012149, :tgn_country_name=>'United States'}

data/lib/bplmodels/datastream_input_funcs.rb

@@ -1,5 +1,6 @@
 #!/bin/env ruby
 # encoding: utf-8
+require 'htmlentities'
 
 module Bplmodels
   class DatastreamInputFuncs
@@ -795,7 +796,9 @@ module Bplmodels
     end
 
     def self.utf8Encode(value)
-      return HTMLEntities.new.decode(ActionView::Base.full_sanitizer.sanitize(value.to_s.gsub(/\r?\n?\t/, ' ').gsub(/\r?\n/, ' ').gsub(/<br[\s]*\/>/,' '))).strip
+      value = value.force_encoding('UTF-8')
+      value.encode!("UTF-8", 'binary', invalid: :replace, undef: :replace, replace: '') unless value.valid_encoding?
+      return ::HTMLEntities.new.decode(ActionView::Base.full_sanitizer.sanitize(value.to_s.gsub(/\r?\n?\t/, ' ').gsub(/\r?\n/, ' ').gsub(/<br[\s]*\/>/,' '))).strip
     end
 
     def self.split_with_nils(value)

data/lib/bplmodels/finder.rb

@@ -1,11 +1,47 @@
 module Bplmodels
   class Finder
 
+    def self.getCollectionObjects(pid)
+      return_hash = {}
+      return_hash[:images] = []
+      return_hash[:documents] = []
+      return_hash[:audio] = []
+      return_hash[:ereader] = []
+      return_hash[:generic] = []
+
+      preceding_pid_lookup = []
+
+      Bplmodels::File.find_in_batches('is_file_of_ssim'=>"info:fedora/#{pid}") do |group|
+        group.each { |solr_object|
+          if solr_object['has_model_ssim'].include?('info:fedora/afmodel:Bplmodels_AudioFile')
+            return_hash[:audio] << solr_object
+          elsif solr_object['has_model_ssim'].include?('info:fedora/afmodel:Bplmodels_ImageFile')
+            return_hash[:images] << solr_object
+          elsif solr_object['has_model_ssim'].include?('info:fedora/afmodel:Bplmodels_DocumentFile')
+            return_hash[:documents] << solr_object
+          elsif solr_object['has_model_ssim'].include?('info:fedora/afmodel:Bplmodels_EreaderFile')
+            return_hash[:ereader] << solr_object
+          else
+            return_hash[:generic] << solr_object
+          end
+        }
+      end
+
+      return_hash[:images] = sort_files(return_hash[:images])
+      return_hash[:documents] = sort_files(return_hash[:documents])
+      return_hash[:audio] = sort_files(return_hash[:audio])
+      return_hash[:ereader] = sort_files(return_hash[:ereader])
+      return_hash[:generic] = sort_files(return_hash[:generic])
+
+      return return_hash
+    end
+
      def self.getFiles(pid)
        return_hash = {}
        return_hash[:images] = []
        return_hash[:documents] = []
        return_hash[:audio] = []
+       return_hash[:ereader] = []
        return_hash[:generic] = []
 
        preceding_pid_lookup = []
@@ -18,6 +54,8 @@ module Bplmodels
              return_hash[:images] << solr_object
            elsif solr_object['has_model_ssim'].include?('info:fedora/afmodel:Bplmodels_DocumentFile')
              return_hash[:documents] << solr_object
+           elsif solr_object['has_model_ssim'].include?('info:fedora/afmodel:Bplmodels_EreaderFile')
+             return_hash[:ereader] << solr_object
            else
              return_hash[:generic] << solr_object
            end
@@ -27,6 +65,7 @@ module Bplmodels
        return_hash[:images] = sort_files(return_hash[:images])
        return_hash[:documents] = sort_files(return_hash[:documents])
        return_hash[:audio] = sort_files(return_hash[:audio])
+       return_hash[:ereader] = sort_files(return_hash[:ereader])
        return_hash[:generic] = sort_files(return_hash[:generic])
 
        return return_hash
@@ -97,6 +136,26 @@ module Bplmodels
        return sort_files(return_list)
      end
 
+     def self.getEreaderFiles(pid)
+       return_list = []
+       Bplmodels::EreaderFile.find_in_batches('is_ereader_of_ssim'=>"info:fedora/#{pid}") do |group|
+         group.each { |solr_object|
+           return_list << solr_object
+         }
+       end
+       return sort_files(return_list)
+     end
+
+     def self.getVolumeObjects(pid)
+       return_list = []
+       Bplmodels::Volume.find_in_batches('is_volume_of_ssim'=>"info:fedora/#{pid}") do |group|
+         group.each { |solr_object|
+           return_list << solr_object
+         }
+       end
+       return sort_files(return_list)
+     end
+
      def self.getFirstImageFile(pid)
        Bplmodels::ImageFile.find_in_batches('is_image_of_ssim'=>"info:fedora/#{pid}", 'is_following_image_of_ssim'=>'') do |group|
          group.each { |solr_object|
@@ -124,6 +183,24 @@ module Bplmodels
        return nil
      end
 
+     def self.getFirstEreaderFile(pid)
+       Bplmodels::EreaderFile.find_in_batches('is_ereader_of_ssim'=>"info:fedora/#{pid}", 'is_following_ereader_of_ssim'=>'') do |group|
+         group.each { |solr_object|
+           return solr_object
+         }
+       end
+       return nil
+     end
+
+     def self.getFirstVolumeObject(pid)
+       Bplmodels::Volume.find_in_batches('is_volume_of_ssim'=>"info:fedora/#{pid}", 'is_following_volume_of_ssim'=>'') do |group|
+         group.each { |solr_object|
+           return solr_object
+         }
+       end
+       return nil
+     end
+
      def self.getNextImageFile(pid)
        Bplmodels::ImageFile.find_in_batches('is_following_image_of_ssim'=>"info:fedora/#{pid}") do |group|
          group.each { |solr_object|
@@ -151,6 +228,15 @@ module Bplmodels
        return nil
      end
 
+     def self.getNextEReaderFile(pid)
+       Bplmodels::EreaderFile.find_in_batches('is_following_ereader_of_ssim'=>"info:fedora/#{pid}") do |group|
+         group.each { |solr_object|
+           return solr_object
+         }
+       end
+       return nil
+     end
+
      def self.getPrevImageFile(pid)
        Bplmodels::ImageFile.find_in_batches('is_preceding_image_of_ssim'=>"info:fedora/#{pid}") do |group|
          group.each { |solr_object|
@@ -178,6 +264,15 @@ module Bplmodels
        return nil
      end
 
+     def self.getPrevEreaderFile(pid)
+       Bplmodels::EReaderFile.find_in_batches('is_preceding_ereader_of_ssim'=>"info:fedora/#{pid}") do |group|
+         group.each { |solr_object|
+           return solr_object
+         }
+       end
+       return nil
+     end
+
      def self.getFileParentObject(file_pid)
        Bplmodels::File.find_in_batches('id'=>"#{file_pid}") do |group|
          group.each { |solr_object|
@@ -188,5 +283,14 @@ module Bplmodels
        return nil
      end
 
+
+     def self.getUnprocessedDerivatives(pid)
+       Bplmodels::File.find_in_batches('is_file_of_ssim'=>"info:fedora/#{pid}", 'derivative_processsed_ssi'=>'false') do |group|
+         group.each { |solr_object|
+           return solr_object
+         }
+       end
+       return nil
+     end
   end
 end