cul_hydra 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9669d16a11214de3beece7b70f8f270c9c3e6f74
+  data.tar.gz: b029e107109a3d13720dc03a026b2a855af76a25
+SHA512:
+  metadata.gz: 8abbcd3eca758e1057983a6bea70b1bbe076c33151044743fd05725f699d4eabe202370bced90839571b86150823227037cf6d884489c2ea741788dc0d402553
+  data.tar.gz: 49be88f1af4b2612432942a8a6e706dea75d1d05218e1e3623ce440b1e52462aaf641bfab541f74448e9a16b1598a2b2c751a93c98c0bf22dc28e8036669517c

data/app/controllers/concerns/cul/hydra/application_id_behavior.rb

@@ -0,0 +1,43 @@
+module Cul::Hydra::ApplicationIdBehavior
+  extend ActiveSupport::Concern
+  included do
+    include Blacklight::SolrHelper
+  end
+
+  def find_for_params(path,solr_params)
+    res = blacklight_solr.send_and_receive(path, {key=>solr_params.to_hash, method:blacklight_config.http_method})
+    Blacklight::SolrResponse.new(res, solr_params, solr_document_model: blacklight_config.solr_document_model)
+  end
+
+  def get_solr_response_for_app_id(id=nil, extra_controller_params={})
+    id ||= params[:id]
+    id = id.clone
+    id.sub!(/apt\:\/columbia/,'apt://columbia') # TOTAL HACK
+    id.gsub!(':','\:')
+    id.gsub!('/','\/')
+    p = blacklight_config.default_document_solr_params.merge(extra_controller_params)
+    p[:fq] = "identifier_ssim:#{(id)}"
+    p[:fl] ||= '*'
+    #p[:qt] ||= blacklight_config.document_solr_request_handler
+    solr_response = find(blacklight_config.document_solr_path, p)
+    raise Blacklight::Exceptions::InvalidSolrID.new(id) if solr_response.docs.empty?
+    document = SolrDocument.new(solr_response.docs.first, solr_response)
+    @response, @document = [solr_response, document]
+  end
+
+  def get_solr_response_for_dc_id(id=nil, extra_controller_params={})
+    id ||= params[:id]
+    id = id.clone
+    p = blacklight_config.default_document_solr_params.merge(extra_controller_params)
+    id.sub!(/apt\:\/columbia/,'apt://columbia') # TOTAL HACK
+    id.gsub!(':','\:')
+    id.gsub!('/','\/')
+    p[:fq] = "dc_identifier_ssim:#{(id)}"
+    p[:fl] ||= '*'
+    #p[:qt] ||= blacklight_config.document_solr_request_handler
+    solr_response = find(blacklight_config.document_solr_path, p)
+    raise Blacklight::Exceptions::InvalidSolrID.new(id) if solr_response.docs.empty?
+    document = SolrDocument.new(solr_response.docs.first, solr_response)
+    @response, @document = [solr_response, document]
+  end
+end

data/app/controllers/concerns/cul/hydra/controller.rb

@@ -0,0 +1,22 @@
+module Cul::Hydra::Controller
+
+  def asset_path_from_config(asset)
+    Rails.configuration.assets.paths.each do |dir|
+      result = "#{dir}/#{asset}"
+      return result if File.exists?(result)
+    end
+    return nil
+  end
+
+  def asset_url(source)
+    URI.join(root_url, ActionController::Base.helpers.asset_path(source))
+  end
+
+  def http_client
+    unless @http_client
+      @http_client ||= HTTPClient.new
+    end
+    @http_client
+  end
+
+end

data/app/controllers/concerns/cul/hydra/resolver.rb

@@ -0,0 +1,69 @@
+require 'blacklight'
+require 'active-fedora'
+module Cul::Hydra::Resolver
+  extend ActiveSupport::Concern
+
+  included do 
+    # Whenever an action raises SolrHelper::InvalidSolrID, this block gets executed.
+    # Hint: the SolrHelper #get_solr_response_for_doc_id method raises this error,
+    # which is used in the #show action here.
+    self.rescue_from Blacklight::Exceptions::InvalidSolrID, :with => :invalid_solr_id_error
+    # When RSolr::RequestError is raised, the rsolr_request_error method is executed.
+    # The index action will more than likely throw this one.
+    # Example, when the standard query parser is used, and a user submits a "bad" query.
+    self.rescue_from RSolr::Error::Http, :with => :rsolr_request_error
+  end
+
+  def get_solr_response_for_app_id(id=nil, extra_controller_params={})
+    id ||= params[:id]
+    solr_params = blacklight_config.default_document_solr_params.merge!(extra_controller_params)
+    solr_params[:fq] = "identifier_ssim:#{(id)}"
+    solr_response = find((blacklight_config.document_solr_request_handler || blacklight_config.qt), solr_params)
+    raise Blacklight::Exceptions::InvalidSolrID.new if solr_response.docs.empty?
+    document = SolrDocument.new(solr_response.docs.first, solr_response)
+    @response, @document = [solr_response, document]
+  end
+
+  def get
+    get_solr_response_for_app_id
+    action = params.delete(:action)
+    action.sub!(/s$/,'')
+    method_name = action + '_url'
+    url = send method_name.to_sym, @document[:id]
+    redirect_to url
+  end
+
+  # when solr (RSolr) throws an error (RSolr::RequestError), this method is executed.
+  def rsolr_request_error(exception)
+    if Rails.env == "development"
+      raise exception # Rails own code will catch and give usual Rails error page with stack trace
+    else
+      flash_notice = I18n.t('blacklight.search.errors.request_error')
+      # Set the notice flag if the flash[:notice] is already set to the error that we are setting.
+      # This is intended to stop the redirect loop error
+      notice = flash[:notice] if flash[:notice] == flash_notice
+      logger.error exception
+      unless notice
+        flash[:notice] = flash_notice
+        redirect_to root_path, :status => 500
+      else
+        render :file => "#{Rails.root}/public/500.html", :status => 500
+      end
+    end
+  end
+  
+  # when a request for /resolve/:action/BAD_SOLR_ID is made, this method is executed...
+  def invalid_solr_id_error
+    id = params.delete(:id)
+    flash[:notice] = I18n.t('blacklight.search.errors.invalid_solr_id') + " (#{id})"
+  	redirect_to(root_path)
+  end
+
+  def blacklight_solr
+    @solr ||=  RSolr.connect(blacklight_solr_config)
+  end
+
+  def blacklight_solr_config
+    Blacklight.solr_config
+  end
+end

data/app/controllers/concerns/cul/hydra/thumbnails.rb

@@ -0,0 +1,62 @@
+require 'httpclient'
+module Cul::Hydra::Thumbnails
+  # some thumbnail urls
+  NO_THUMB = "cul_hydra/crystal/file.png"
+  BROKEN_THUMB = "cul_hydra/crystal/file_broken.png"
+  COLLECTION_THUMB = "cul_hydra/crystal/kmultiple.png"
+  AUDIO_THUMB = "cul_hydra/crystal/sound.png"
+  # some rel predicates
+  FORMAT = "http://purl.org/dc/elements/1.1/format"
+  MEMBER_OF = "http://purl.oclc.org/NET/CUL/memberOf"
+  HAS_MODEL = "info:fedora/fedora-system:def/model#hasModel"
+  IMAGE_WIDTH = "http://purl.oclc.org/NET/CUL/RESOURCE/STILLIMAGE/BASIC/imageWidth"
+  IMAGE_LENGTH = "http://purl.oclc.org/NET/CUL/RESOURCE/STILLIMAGE/BASIC/imageLength"
+
+  def show
+    pid = params[:id].split(/@/)[0]
+    get_by_pid(pid)
+  end
+
+  def get_by_pid(pid)
+    r_obj = ActiveFedora::Base.find(pid, :cast=>true)
+    
+    if r_obj.respond_to? :thumbnail_info
+      url = r_obj.thumbnail_info
+    else
+      url = {:asset=>(COLLECTION_THUMB),:mime=>'image/png'}
+    end
+    if url[:asset]
+      #url = {:url=>asset_url(COLLECTION_THUMB),:mime=>'image/png'}
+      #redirect_to asset_url(url[:asset]).to_s, status: 302
+      #return
+    end
+    Rails.logger.debug "thumbnail #{url[:url] || url[:asset]} #{url[:mime]}"
+    filename = pid + '.' + url[:mime].split('/')[1].downcase
+    h_cd = "filename=""#{CGI.escapeHTML(filename)}"""
+    headers.delete "Cache-Control"
+    headers["Content-Disposition"] = h_cd
+    headers["Content-Type"] = url[:mime]
+   
+    if url[:asset]
+      full_path = Rails.application.assets.resolve(url[:asset]).to_path
+      render :status => 200, :text => File.read(full_path)
+      return
+    elsif url[:url].to_s =~ /^https?:/
+      cl = http_client
+      render :status => 200, :text => cl.get_content(url[:url])
+      return
+    else
+      render :status => 200, :text => File.read(url[:url])
+      return
+    end
+  end
+
+  def jp2_thumbnail(pid)
+    {:url => ActiveFedora.fedora_config.credentials[:url] + '/objects/' + pid + '/methods/ldpd:sdef.Image/getView?max=250', :mime => 'image/jpeg'}
+  end
+
+  def pid_from_uri(uri)
+    return uri.sub(/info:fedora\//,'')
+  end
+  
+end

data/app/helpers/cul/hydra/ore_proxies_helper_behavior.rb

@@ -0,0 +1,119 @@
+module Cul::Hydra::OreProxiesHelperBehavior
+  def hasModel_name
+    @has_model ||= ActiveFedora::SolrService.solr_name('has_model', :symbol)
+  end
+
+  def publisher_name
+    @has_model ||= ActiveFedora::SolrService.solr_name('publisher', :symbol)
+  end
+
+  def facets_for(query, args)
+    raw = args.delete(:raw)
+    args = args.merge(q:query, qt:'standard',facet:true,rows:0)
+    result = ActiveFedora::SolrService.instance.conn.get('select', :params=>args)
+    return result if raw
+    result['facet_counts']['facet_fields']
+  end
+  def facet_to_hash(facet_values)
+    facet_values ||= []
+    hash = {}
+    facet_values.each_with_index {|v,ix| hash[v] = facet_values[ix+1] if (ix % 2 == 0)}
+    hash
+  end
+  def proxies(opts=params, &block)
+    proxy_in = opts[:id]
+    proxy_uri = "info:fedora/#{proxy_in}"
+    proxy_id = opts[:proxy_id]
+    proxy_in_query = "proxyIn_ssi:#{RSolr.escape(proxy_uri)}"
+    f = [proxy_in_query]
+    if proxy_id
+      f << "belongsToContainer_ssi:#{RSolr.escape(proxy_id)}"
+    else
+      f << "-belongsToContainer_ssi:*"
+    end
+    rows = opts[:limit] || '999'
+    proxies = ActiveFedora::SolrService.query("*:*",{fq: f,rows:rows})
+    if proxies.detect {|p| p["type_ssim"] && p["type_ssim"].include?(RDF::NFO[:'#FileDataObject'])}
+      query = "{!join from=proxyFor_ssi to=identifier_ssim}#{f.join(' ')}"
+      files = ActiveFedora::SolrService.query(query,rows:'999')
+      proxies.each do |proxy|
+        file = files.detect {|f| f['identifier_ssim'].include?(proxy['proxyFor_ssi'])}
+        if file
+          rels_int = file.fetch('rels_int_profile_tesim',[]).first
+          props = rels_int ? JSON.load(rels_int) : {}
+          props = props["#{proxy_uri}/content"] || {}
+          props['pid'] = file['id']
+          props['extent'] ||= file['extent_ssim'] if file['extent_ssim']
+          proxy.merge!(props)
+        end
+      end
+    end
+    if proxies.detect {|p| p["type_ssim"] && p["type_ssim"].include?(RDF::NFO[:'#Folder'])}
+      query = "{!join from=id  to=belongsToContainer_ssi}#{f.join(' ')}"
+      folder_counts = facets_for(query,:"facet.field" => "belongsToContainer_ssi",:"facet.limit" => '999')
+      unless ( belongsToContainer = facet_to_hash(folder_counts["belongsToContainer_ssi"])).empty?
+        proxies.each do |proxy|
+          if proxy["type_ssim"].include?(RDF::NFO[:'#Folder'])
+            proxy['extent'] ||= belongsToContainer[proxy['id']]
+          end
+        end
+      end
+    end
+    if block_given?
+      proxies.each &block
+    else
+      proxies
+    end
+  end
+
+  def proxies_file_system(opts=params, &block)
+    content_tag(:ul, nil, class: 'file-system') do
+      proxies(opts, &block)
+    end
+  end
+
+  def download_permitted?(dl_proxy, args={})
+    return permitted_to? :fedora_content, dl_proxy, {:context => :download}
+  end
+
+  def proxy_to_download(node, args={})
+    dl_proxy = Cul::DownloadProxy.new(args)
+    dl_proxy.content_models = node[hasModel_name()]
+    dl_proxy.mime_type = node['format']
+    dl_proxy.publisher = node[publisher_name()]
+    dl_proxy
+  end
+
+  def proxy_extent(node)
+    extent = Array(node['extent']).first || '0'
+    if node["type_ssim"].include? RDF::NFO[:'#FileDataObject']
+      extent = extent.to_i
+      if extent > 0
+        pow = Math.log(extent,1024).floor
+        pow = 3 if pow > 3
+        pow = 0 if pow < 0
+      else
+        pow = 0
+      end
+      unit = ['B','KiB','MiB','GiB'][pow]
+      "#{extent.to_i/(1024**pow)} #{unit}"
+    else
+      "#{extent.to_i} items"
+    end
+  end
+  def breadcrumbs(opts=params, &block)
+    proxy_id = opts[:proxy_id]
+    id = opts[:id]
+    links = []
+    if proxy_id
+      parts = proxy_id.split('/')
+      id = id.sub('info:fedora/','')
+      yield( {id: id, label: 'All Content'})
+      # the first three parts are proxied graph prefixes "info:fedora/PID/DSID/..."
+      3.upto(parts.size - 2).each do |ix|
+        f_id = parts[0..ix].join('/')
+        yield( {id: id, proxy_id: URI.escape(f_id), label: parts[ix]})
+      end
+    end
+  end
+end

data/app/helpers/cul/hydra/struct_metadata_helper_behavior.rb

@@ -0,0 +1,89 @@
+module Cul::Hydra::StructMetadataHelperBehavior
+  METS_NS = {'mets' => 'http://www.loc.gov/METS/'}
+  def mime_for_name(filename)
+    ext = File.extname(filename).downcase
+    mt = MIME::Types.type_for(ext)
+    if mt.is_a? Array
+      mt = mt.first
+    end
+    unless mt.nil?
+      return mt.content_type
+    else
+      return nil
+    end
+  end
+
+  def html_class_for_filename(filename)
+    mime = mime_for_name(filename) || 'application/octet-stream'
+    mime.sub(/\//,'_')
+  end
+
+  def struct_metadata_ds(doc)
+    pid = base_id_for(doc)
+    xml = rubydora.datastream_dissemination(:pid=>pid, :dsid=>'structMetadata')
+    Cul::Hydra::Datastreams::StructMetadata.from_xml(xml)
+  end
+  def struct_metadata_file_system_cache_key(doc)
+    File.join(doc['id'],'structMetadata','fs-html',doc['system_modified_dtsi'])
+  end
+  def struct_metadata_file_system(doc)
+    ds = struct_metadata_ds(doc)
+    doc = Nokogiri::XML(ds.content)
+    node = doc.xpath('mets:structMap',METS_NS).first
+    content_tag(:ul, nil, class: 'file-system') do
+      children_content = node.xpath('mets:div',METS_NS).reduce('') do |content, child|
+        content << struct_metadata_node(child)
+      end
+      children_content.html_safe
+    end
+  end
+  def struct_metadata_node(node)
+    children = node.xpath('mets:div',METS_NS)
+    if children.length == 0
+      # file
+      content_tag(:li,nil, class: ['fs-file',html_class_for_filename(node['LABEL'])]) do
+        content_tag(:a, node['LABEL'], href: '#', 'data-id'=>node['CONTENTIDS'])
+      end
+    else
+      # folder
+      content_tag(:li, nil, class: 'fs-directory') do
+        content_tag(:a, node['LABEL'], href: '#') +
+        content_tag(:ul, nil, class: 'fs-children') do
+          children_content = children.reduce('') do |content, child|
+            content << struct_metadata_node(child)
+          end
+          children_content.html_safe
+        end
+      end
+    end
+  end
+  def struct_metadata(doc)
+    members = get_members(doc)
+
+    node_map = {}
+    ds = struct_metadata_ds(doc)
+    ds.divs_with_attribute(true,'CONTENTIDS').each do |node|
+      node_map[node['CONTENTIDS']] = node
+    end
+    
+    map = {}
+    Rails.logger.warn("No members for doc #{doc[:id]}") unless members.size > 0
+    members.each do |member|
+      ids = ((member[:identifier_ssim] || []) + (member[:dc_identifier_ssim] || []))
+      ids.uniq!
+      ids.delete(member[:id])
+      node_map.each do |cid, node|
+        if ids.include? cid
+          node['pid'] = member[:id]
+          map[member[:id]] = member
+          Rails.logger.info("Mapped child node in structMap: '#{member[:id]}'' -> '#{cid}'")
+          break
+        end
+      end
+      if map[member[:id]].nil?
+        Rails.logger.warn("Unmapped child node in structMap: #{ids.inspect}")
+      end
+    end
+    [ds, map]
+  end
+end