cul_scv_hydra 0.22.6 → 0.22.7

data/app/models/concerns/cul/hydra/models/common.rb

@@ -0,0 +1,220 @@
+require 'active-fedora'
+require 'uri'
+module Cul::Hydra::Models::Common
+  extend ActiveSupport::Concern
+
+  included do
+    extend ActiveModel::Callbacks
+    define_model_callbacks :create
+    has_metadata :name => "DC", :type=>Cul::Hydra::Datastreams::DCMetadata, :versionable => true
+    has_metadata :name => "descMetadata", :type=>Cul::Hydra::Datastreams::ModsDocument, :versionable => true
+    has_metadata :name => "rightsMetadata", :type=>::Hydra::Datastream::RightsMetadata, :versionable => true
+    has_many :publishers, :property => :publisher, :class_name=>'ActiveFedora::Base'
+  end
+
+  module ClassMethods
+    def pid_namespace
+      'ldpd'
+    end
+
+  end
+
+  # A Fedora object label can only contain a string value of up to 255 characters.  If we try to
+  # set a longer value, it causes errors upon object save.  Truncate labels to 255 characters.
+  # Note: this method maps to a method_missing hanlder that converts input into a String, so
+  # we use the super method first, and then post-process the output of that super method call.
+  def label=(new_label)
+    super(new_label)
+    super(self.label[0,255])
+  end
+
+  def rdf_type
+    relationships[:rdf_type]
+  end
+
+  def initialize(attrs = nil)
+    attrs = {} if attrs.nil?
+    attrs[:namespace] = self.class.pid_namespace unless attrs[:namespace]
+    super
+  end
+
+  def cmodel_pid(klass)
+    klass.pid_namespace + ":" + klass.name.split("::")[-1]
+  end
+
+  def datastreams_in_fedora
+    mds = {}
+    self.datastreams_xml['datastream'].each do |ds|
+      dsid = ds["dsid"]
+      ds.merge!({:pid => self.pid, :dsID => dsid, :dsLabel => ds["label"]})
+      if dsid == "RELS-EXT"
+        mds.merge!({dsid => ActiveFedora::RelsExtDatastream.new(ds)})
+      else
+        if self.class.ds_specs.has_key? dsid
+          mds.merge!({dsid => self.class.ds_specs[dsid][0].new(ds)})
+        else
+          mds.merge!({dsid => ActiveFedora::Datastream.new(ds)})
+        end
+      end
+      mds[dsid].new_object = false
+    end
+    mds
+  end
+
+  def route_as
+    "default"
+  end
+
+  def has_desc?
+    has_desc = false
+    begin
+      has_desc = self.datastreams.include? "descMetadata"
+      has_desc = has_desc and self.inner_object.datastreams["descMetadata"].content.length > 0
+      has_desc = has_desc and self.datastreams["descMetadata"].term_values(:identifier).length > 0
+    rescue
+      has_desc = false
+    end
+    has_desc
+  end
+
+  # set the index type label and any RI-based fields
+  def set_size_labels(solr_doc={})
+    solr_doc["index_type_label_ssi"] = [self.index_type_label]
+  end
+
+  def to_solr(solr_doc = Hash.new, opts={})
+    solr_doc = super(solr_doc, opts)
+
+    if has_desc?
+      solr_doc["descriptor_ssi"] = ["mods"]
+    else
+      solr_doc["descriptor_ssi"] = ["dublin core"]
+    end
+    # if no mods, pull some values from DC
+    if (solr_doc["title_display_ssm"].nil? or solr_doc["title_display_ssm"].length == 0)
+      if self.datastreams["DC"].term_values(:dc_title).first
+        solr_doc["title_display_ssm"] = self.datastreams["DC"].term_values(:dc_title)
+      else
+        solr_doc["title_display_ssm"] = self.datastreams["DC"].term_values(:dc_identifier).reject {|dcid| dcid.eql? self.id}
+      end
+      solr_doc["title_si"] = self.datastreams["DC"].term_values(:dc_title).first
+      if self.datastreams["DC"].term_values(:dc_relation).first
+        self.datastreams["DC"].term_values(:dc_relation).each {|val|
+          if val =~ /clio:/
+            solr_doc["clio_ssim"] ||= []
+            solr_doc["clio_ssim"] << val.split(':')[-1]
+          end
+        }
+      end
+    end
+    if (solr_doc["identifier_ssim"].nil? or solr_doc["identifier_ssim"].length == 0)
+        solr_doc["identifier_ssim"] = self.datastreams["DC"].term_values(:dc_identifier).reject {|dcid| dcid.eql? self.id}
+    end
+    if (solr_doc["title_display_ssm"].length > 1)
+      solr_doc["title_display_ssm"].uniq!
+    end
+
+    if solr_doc["contributor_ssim"].present?
+      if solr_doc["contributor_ssim"].is_a?(Array)
+        solr_doc["contributor_first_si"] = solr_doc["contributor_ssim"].first
+      else
+        solr_doc["contributor_first_si"] = solr_doc["contributor_ssim"]
+      end
+    end
+
+
+    solr_doc["format_ssi"] = [self.route_as]
+
+    set_size_labels(solr_doc)
+
+    solr_doc.each_pair {|key, value|
+      if value.is_a? Array
+        value.each {|v| v.strip! unless v.nil? }
+      elsif value.is_a? String
+        value.strip!
+      end
+    }
+    solr_doc[:structured_bsi] = 'false' unless solr_doc.has_key? :structured_bsi
+
+    solr_doc
+  end
+
+  def update_datastream_attributes(params={}, opts={})
+    logger.debug "Common.update_datastream_attributes"
+    result = params.dup
+    params.each_pair do |dsid, ds_params|
+      if datastreams.include?(dsid)
+        verify_params = ds_params.dup
+        changed = false
+        verify_params.each { |pointer, values|
+          changed ||= value_changed?(datastreams[dsid],pointer,values)
+        }
+        if changed
+          logger.debug "Common.update_datastream_attributes calling update_indexed_attributes"
+          result[dsid] = datastreams[dsid].update_indexed_attributes(ds_params)
+        else
+          result[dsid] = no_update(ds_params)
+        end
+        logger.debug "change detected? #{changed} digital_object? #{datastreams[dsid].changed?}"
+      else
+        result.delete(dsid)
+      end
+    end
+    return result
+  end
+
+  def thumbnail_info
+    {:asset=>("cul_scv_hydra/crystal/kmultiple.png"),:mime_type=>"image/png"}
+  end
+
+  private
+  def value_changed?(ds,pointer,values)
+    if values.is_a? Hash
+      values = values.dup
+    else
+      values = {"0"=>values}
+    end
+    logger.debug "submitted values for #{pointer.inspect} : #{values.inspect}"
+    return true if values["-1"]
+    changed = false
+    old_values = ds.get_values(pointer)
+    indexed_values = {}
+    old_values.each_index {|ix| indexed_values[ix.to_s] = old_values[ix] }
+    indexed_values.each {|k,v|
+      new_val = values.delete(k)
+      logger.debug "old: #{v} new: #{new_val} changed? #{!(v.eql? new_val)}"
+      changed ||= !(v.eql? new_val)
+    }
+    logger.debug "remaining values! #{values.inspect}" if values.length > 0
+    changed || (values.length > 0)
+  end
+
+  def no_update(ds_params)
+    response = {}
+    ds_params.each{|pointer, values|
+      returned = []
+      if values.is_a? Hash
+        keys = values.keys.sort {|x,y| x.to_i <=> y.to_i}
+        keys.each {|key| returned << values[key]}
+      else
+        returned << values
+      end
+      response[OM::XML::Terminology.term_hierarchical_name(pointer)] = returned
+    }
+  end
+
+  def legacy_content_path(ds, ds_root=ActiveFedora.config.credentials[:datastreams_root])
+    unless ds.controlGroup == 'M'
+      return ds.dsLocation
+    end
+    cd = ds.dsCreateDate
+    tz = ActiveFedora.config.credentials[:time_zone]
+    tzi = ActiveSupport::TimeZone.find_tzinfo(tz)
+    ld = tzi.utc_to_local(cd)
+    month = (ld.month < 10) ? "0#{ld.month}" : ld.month.to_s
+    day = (ld.day < 10) ? "0#{ld.day}" : ld.day.to_s
+    hour = (ld.hour < 10) ? "0#{ld.hour}" : ld.hour.to_s
+    min = (ld.min < 10) ? "0#{ld.min}" : ld.min.to_s
+    return File.join(ds_root,"#{ld.year}/#{month}#{day}/#{hour}/#{min}", ds.dsLocation.sub(':','_'))
+  end
+end

data/app/models/concerns/cul/hydra/models/image_resource.rb

@@ -0,0 +1,78 @@
+module Cul::Hydra::Models::ImageResource
+  IMAGE_EXT = {"image/bmp" => 'bmp', "image/gif" => 'gif', "image/jpeg" => 'jpg', "image/png" => 'png', "image/tiff" => 'tif', "image/x-windows-bmp" => 'bmp', 'image/jp2' => 'jp2'}
+  WIDTH = RDF::URI(ActiveFedora::Predicates.find_graph_predicate(:image_width))
+  LENGTH = RDF::URI(ActiveFedora::Predicates.find_graph_predicate(:image_length))
+  WIDTH_PREDICATE = ActiveFedora::Predicates.short_predicate("http://www.w3.org/2003/12/exif/ns#imageWidth").to_s
+  LENGTH_PREDICATE = ActiveFedora::Predicates.short_predicate("http://www.w3.org/2003/12/exif/ns#imageLength").to_s
+  EXTENT_PREDICATE = ActiveFedora::Predicates.short_predicate("http://purl.org/dc/terms/extent").to_s
+  FORMAT_OF_PREDICATE = ActiveFedora::Predicates.short_predicate("http://purl.org/dc/terms/isFormatOf").to_s
+  FORMAT_URI = RDF::URI("http://purl.org/dc/terms/format")
+
+  DJATOKA_THUMBNAIL_PARMS = {
+    "url_ver" => "Z39.88-2004",
+    "svc_id" => "info:lanl-repo/svc/getRegion",
+    "svc_val_fmt" => "info:ofi/fmt:kev:mtx:jpeg2000",
+    "svc.format" => "image/jpeg",
+    "svc.level" => "",
+    "svc.rotate" => "0",
+    "svc.scale" => "200",
+    "svc.clayers" => ""
+  }
+
+  DJATOKA_BASE_URL = "http://iris.cul.columbia.edu:8888/resolve"
+
+  def long
+    @long_side ||= max(width(), length())
+  end
+
+  def width
+    @width ||= begin
+      ds = datastreams["content"]
+      width = 0
+      unless ds.nil? or rels_int.relationships(ds,:exif_image_width).blank?
+        width = rels_int.relationships(ds,:exif_image_width).first.object.to_s.to_i
+      end
+      width = relationships(:image_width).first.to_s.to_i if width == 0
+      width
+    end
+  end
+
+  def length
+    @length ||= begin
+      ds = datastreams["content"]
+      length = 0
+      unless ds.nil? or rels_int.relationships(ds,:exif_image_length).blank?
+        length = rels_int.relationships(ds,:exif_image_length).first.object.to_s.to_i
+      end
+      length = relationships(:image_length).first.to_s.to_i if length == 0
+      length
+    end
+  end
+
+  def zooming?
+    zoom = rels_int.relationships(datastreams['content'],:foaf_zooming).first
+    return zoom.object.to_s if zoom
+    datastreams.each do |k,v|
+      if v.mimeType =~ /image\/jp2$/i
+        zoom = "info:fedora/#{k.dsid}"
+      end
+    end
+    return zoom
+  end
+
+  def thumbnail_info
+    thumb = rels_int.relationships(datastreams['content'],:foaf_thumbnail).first
+    if thumb
+      t_dsid = thumb.object.to_s.split('/')[-1]
+      t_url = "#{ActiveFedora.fedora_config.credentials[:url]}/objects/#{pid}/datastreams/#{t_dsid}/content"
+      return {:url=>t_url,:mime=>datastreams[t_dsid].mimeType}
+    elsif (zoom = self.zooming?)
+      t_dsid = zoom.split('/')[-1]
+      t_parms = DJATOKA_THUMBNAIL_PARMS.merge({"rft_id" => datastreams[t_dsid].dsLocation})
+      url = "#{DJATOKA_BASE_URL}?#{options.map { |key, value|  "#{CGI::escape(key.to_s)}=#{CGI::escape(value.to_s)}"}.join("&")  }"
+      {:url => url, :mime => t_parms["svc.format"]}
+    else
+      return {:asset=>"cul_scv_hydra/crystal/file.png",:mime=>'image/png'}
+    end
+  end
+end

data/app/models/concerns/cul/hydra/models/linkable_resources.rb

@@ -0,0 +1,108 @@
+module Cul::Hydra::Models::LinkableResources
+  include Cul::Hydra::Fedora::UrlHelperBehavior
+  # so as to avoid including all the url hepers via:
+  ## include Rails.application.routes.url_helpers
+  # we are just going to delegate
+  delegate :fedora_content_path,  :to => 'Rails.application.routes.url_helpers'
+  delegate :cache_path,  :to => 'Rails.application.routes.url_helpers'
+
+  def http_client
+    unless @http_client
+      @http_client ||= HTTPClient.new
+      @http_client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      uname = Cul::Hydra::Fedora.repository.config[:user]
+      pwd = Cul::Hydra::Fedora.repository.config[:password]
+      @http_client.set_auth(nil, uname, pwd)
+    end
+    @http_client
+  end
+
+  def linkable_resources
+    r = self.parts(:response_format => :solr)
+    return [] if r.blank?
+    members = r.collect {|hit|
+      SolrDocument.new(hit)
+    }
+    members.delete_if { |sd| (sd[:has_model_ssim] & ["info:fedora/ldpd:Resource"]).blank? }
+    case self.route_as
+    when "zoomingimage"
+      results = members.collect {|doc| image_resource(doc)}
+      base_id = self.pid
+      url = fedora_ds_url(base_id, 'SOURCE') + '/content'
+      head_req = http_client().head(url)
+      file_size = head_req.header["Content-Length"].first.to_i
+      results << {
+        :dimensions => "Original",
+        :mime_type => "image/jp2",
+        :uri=>base_id, :block=>"SOURCE", :filename=>base_id + "_source.jp2",
+        :content_models=>[]}
+    when "audio"
+      results = members.collect {|doc| audio_resource(doc)}
+    when "image"
+      results = members.collect {|doc| image_resource(doc)}
+    else
+      raise "Unknown format #{self.route_as}"
+    end
+    return results
+  end
+
+  def basic_resource(document)
+    res = {}
+    res[:pid] = document["id"]
+    res[:dsid] = "CONTENT"
+    res[:mime_type] = document["dc_format_ssm"] ? document["dc_format_ssm"].first : "application/octect-stream"
+    res[:content_models] = document["has_model_ssim"]
+    res[:file_size] = document["extent_ssim"].first.to_i
+    res[:size] = (document["extent_ssim"].first.to_i / 1024).to_s + " Kb"
+    res
+  end
+
+  def image_resource(document)
+    res = basic_resource(document)
+    if document["image_width_ssim"]
+      res[:dimensions] = document["image_width_ssim"].first + " x " + document["image_length_ssim"].first
+      res[:width] = document["image_width_ssim"].first
+      res[:height] = document["image_length_ssim"].first
+    else
+      res[:dimensions] = "? x ?"
+      res[:width] = "0"
+      res[:height] = "0"
+    end
+    base_id = document["id"]
+    base_filename = base_id.gsub(/\:/,"")
+    img_filename = base_filename + "." + document["dc_format_ssm"].first.gsub(/^[^\/]+\//,"")
+    res[:filename] = img_filename
+    res[:block] = "CONTENT"
+    res[:mime_type] = document["dc_format_ssm"] ? document["dc_format_ssm"].first : "application/octect-stream"
+    res[:content_models] = document["has_model_ssim"]
+    res[:file_size] = document["extent_ssim"].first.to_i
+    res[:size] = (document["extent_ssim"].first.to_i / 1024).to_s + " Kb"
+    res[:uri] = base_id
+    res
+  end
+
+  def audio_resource(document)
+    res = basic_resource(document)
+    base_id = document["id"]
+    base_filename = base_id.gsub(/\:/,"")
+    if res[:mime_type] =~ /wav/
+      ext = 'wav'
+    elsif res[:mime_type] =~ /mpeg/
+      ext = 'mp3'
+    else
+      ext = 'bin'
+    end
+    filename = base_filename + "." + ext
+    dc_filename = base_filename + "_dc.xml"
+    res[:uri] = base_id
+    res[:block] = "CONTENT"
+    res[:filename] = filename
+    res[:dc_path] = fedora_content_path(:download_method=>"show_pretty", :uri=>base_id, :block=>"DC", :filename=>dc_filename)
+    res[:mime_type] = document["dc_format_ssm"] ? document["dc_format_ssm"].first : "application/octect-stream"
+    res[:content_models] = document["has_model_ssim"]
+    res[:file_size] = document["extent_ssim"].first.to_i
+    res[:size] = (document["extent_ssim"].first.to_i / 1024).to_s + " Kb"
+    res
+  end
+
+end

data/app/models/concerns/cul/hydra/models/resource.rb

@@ -0,0 +1,87 @@
+module Cul::Hydra::Models::Resource
+    extend ActiveSupport::Concern
+# constants #
+  IMAGE_MIME_TYPES = [
+    'image/bmp',
+    'image/gif',
+    'image/jpeg',
+    'image/png',
+    'image/tiff'
+  ]
+
+  included do
+    if self.is_a? ::ActiveFedora::SemanticNode
+      props = {
+        "image_width" => :image_width,
+        "image_length" => :image_length,
+        "x_sampling" => :x_sampling,
+        "y_sampling" => :y_sampling,
+        "sampling_unit" => :sampling_unit,
+        "extent" => :extent,
+      }
+      props.each { |x, y|
+        class_eval %Q{
+          def #{x}
+            return relationships[:#{y.to_s}]
+        }
+      }
+
+      after_create :resource!
+    end
+    if self.respond_to? :has_datastream
+      has_datastream :name => "CONTENT", :type=>::ActiveFedora::Datastream, :versionable => true
+    end
+  end
+
+  def resource!
+    add_relationship(:rdf_type, Cul::Hydra::Models::RESOURCE_TYPE.to_s)
+    @metadata_is_dirty = true
+    update
+  end
+
+  def add_content_blob(blob, opts)
+    file_name = opts[:file_name]
+    mime = opts[:mime_type].nil? ? mime_type(file_name) : opts[:mime_type]
+    add_file_datastream(blob, :label=>file_name, :mimeType=>mime, :dsid => 'CONTENT')
+    set_title_and_label( file_name, :only_if_blank=>true )
+    if IMAGE_MIME_TYPES.include? mime
+      blob.rewind
+      # retrieve Nokogiri of image property RDF
+      image_properties = Cul::Image::Properties.identify(blob)
+      if image_properties
+        image_prop_nodes = image_properties.nodeset
+        relsext = datastreams['RELS-EXT']
+        image_prop_nodes.each { |node|
+          if node["resource"]
+            is_literal = false
+            object = RDF::URI.new(node["resource"])
+          else
+            is_literal = true
+            object = RDF::Literal(node.text)
+          end
+          subject = RDF::URI(internal_uri)
+          predicate = RDF::URI("#{node.namespace.href}#{node.name}")
+          query = RDF::Query.new({ :subject => {predicate => :object}})
+          relationships(predicate).dup.each { |stmt|
+            relationships.delete(stmt)
+          }
+          add_relationship(predicate,object, is_literal)
+          relationships_are_dirty=true
+        }
+        # add mimetype to DC:format values
+        self.datastreams['DC'].update_values({[:format] => mime})
+      end
+    end
+    blob.rewind
+  end
+
+ private
+
+  # Return the mimeType for a given file name
+  # @param [String] file_name The filename to use to get the mimeType
+  # @return [String] mimeType for filename passed in. Default: application/octet-stream if mimeType cannot be determined
+  def mime_type file_name
+    mime_types = MIME::Types.of(file_name)
+    mime_type = mime_types.empty? ? "application/octet-stream" : mime_types.first.content_type
+  end
+end