cul_scv_hydra 0.3.0

data/lib/cul_scv_hydra/active_fedora.rb

@@ -0,0 +1,18 @@
+require "active-fedora"
+require "cul_scv_hydra/om"
+require 'uri'
+require 'rdf'
+module Cul
+  module Scv
+  module Hydra
+  module ActiveFedora
+    AGGREGATOR_TYPE = (URI.parse("http://purl.oclc.org/NET/CUL/Aggregator"))
+    RESOURCE_TYPE = (URI.parse("http://purl.oclc.org/NET/CUL/Resource"))
+    MEMBER_QUERY = <<-SPARQL
+      SELECT ?pid WHERE { ?pid <http://purl.oclc.org/NET/CUL/memberOf> <info:fedora/%PID%> }
+    SPARQL
+  end
+end
+end
+end
+require 'cul_scv_hydra/active_fedora/model.rb'

data/lib/cul_scv_hydra/active_fedora/model.rb

@@ -0,0 +1,8 @@
+module Cul::Scv::Hydra::ActiveFedora
+module Model
+end
+end
+require 'cul_scv_hydra/active_fedora/model/aggregator'
+require 'cul_scv_hydra/active_fedora/model/common'
+require 'cul_scv_hydra/active_fedora/model/dcdocument'
+require 'cul_scv_hydra/active_fedora/model/resource'

data/lib/cul_scv_hydra/active_fedora/model/aggregator.rb

@@ -0,0 +1,45 @@
+module Cul::Scv::Hydra::ActiveFedora::Model
+module Aggregator
+  extend ActiveSupport::Concern
+
+  included do
+    has_relationship "parts", :cul_member_of, :inbound => true
+    after_create :aggregator!
+  end
+  module InstanceMethods
+    def aggregator!
+      add_relationship(:rdf_type, Cul::Scv::Hydra::ActiveFedora::AGGREGATOR_TYPE.to_s)
+      @metadata_is_dirty = true
+      update
+    end
+
+    def add_member(member, container=self)
+      if container.respond_to?:internal_uri
+        container = container.internal_uri
+      end
+      if container =~ /\A[\w\-]+:[\w\-]+\Z/
+        container = "info:fedora/#{container}"
+      end
+      member.add_relationship(:cul_member_of, container)
+      member.datastreams["RELS-EXT"].dirty = true
+      member.save
+    end
+
+    def remove_member(member, container=self)
+      if container.respond_to?:internal_uri
+        container = container.internal_uri
+      end
+      if container =~ /\A[\w\-]+:[\w\-]+\Z/
+        container = "info:fedora/#{container}"
+      end
+      rel = ActiveFedora::Relationship.new()
+      rel.subject_pid= :self
+      rel.object = container
+      rel.predicate = :cul_member_of
+      member.remove_relationship(rel)
+      member.datastreams["RELS-EXT"].dirty = true
+      member.save
+    end
+  end
+end
+end

data/lib/cul_scv_hydra/active_fedora/model/common.rb

@@ -0,0 +1,221 @@
+require "active-fedora"
+require 'uri'
+module Cul::Scv::Hydra::ActiveFedora::Model
+  module Common
+    extend ActiveSupport::Concern
+    
+    included do
+      define_model_callbacks :create
+
+      has_relationship "containers", :cul_member_of
+      has_relationship "rdf_type", :rdf_type
+      has_metadata :name => "DC", :type=>Cul::Scv::Hydra::Om::DCMetadata, :versionable => true
+      has_metadata :name => "descMetadata", :type=>Cul::Scv::Hydra::Om::ModsDocument, :versionable => true
+      has_metadata :name => "rightsMetadata", :type=>::Hydra::RightsMetadata, :versionable => true
+    end
+    
+    module ClassMethods
+      def pid_namespace
+        "ldpd"
+      end
+    end  
+    
+    module InstanceMethods
+      def initialize(attrs = nil)
+        attrs = {} if attrs.nil?
+        attrs[:namespace] = self.class.pid_namespace unless attrs[:namespace]
+        super
+      end
+    
+      def create
+        run_callbacks :create do
+          super
+        end
+      end
+
+      def resources(opts={})
+        if self.respond_to? :parts # aggregator
+          opts = {:rows=>25,:response_format=>:solr}.merge(opts)
+          self.parts(opts)
+          #opts = {:rows=>25,:response_format=>:solr}.merge(opts)
+          #query = self.class.inbound_relationship_query(self.pid, "parts")
+          #solr_result = ::ActiveFedora::SolrService.instance.conn.query(query, :rows=>opts[:rows])
+          #if opts[:response_format] == :solr
+          #  return solr_result
+          #else
+          #  if opts[:response_format] == :id_array
+          #    id_array = []
+          #    solr_result.hits.each do |hit|
+          #      id_array << hit[SOLR_DOCUMENT_ID]
+          #    end
+          #    return id_array
+          #  elsif opts[:response_format] == :load_from_solr || self.load_from_solr
+          #    return ::ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+          #  else
+          #    return ::ActiveFedora::SolrService.reify_solr_results(solr_result)
+          #  end
+          #end
+       else
+          logger.warn "parts not defined; was this an Aggregator?"
+          []
+        end
+      end
+
+      def members(opts={})
+        resources(opts)
+      end
+    
+      def members_ids(opts={})
+        opts = opts.merge({:response_format=>:id_array})
+        resources(opts)
+      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
+    end
+  
+    def route_as
+      "default"
+    end
+  
+    def index_type_label
+      riquery = Cul::Scv::Hydra::ActiveFedora::MEMBER_QUERY.gsub(/%PID%/, self.pid)
+      begin
+        docs = ::ActiveFedora::RubydoraConnection.instance.connection.find_by_sparql riquery
+      rescue
+        docs = self.parts
+      end
+      if docs.length == 0
+        label = "EMPTY"
+      elsif docs.length == 1
+        label = "SINGLE PART"
+      else
+        label = "MULTIPART"
+      end
+      label
+    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 = self.datastreams["descMetadata"].term_values(:identifier).length > 0
+      rescue
+        has_desc = false
+      end
+      has_desc
+    end
+  
+    def to_solr(solr_doc = Hash.new, opts={})
+      super
+      if has_desc?
+        solr_doc["descriptor_s"] = ["mods"]
+      else
+        solr_doc["descriptor_s"] = ["dublin core"]
+      end
+      # if no mods, pull some values from DC
+      if not (solr_doc["title_display"] and solr_doc["title_display"].length > 0)
+        if self.dc.term_values(:title).first
+          solr_doc["title_display"] = [self.dc.term_values(:title).first]
+        else
+          solr_doc["title_display"] = [self.dc.term_values(:identifier).first]
+        end
+        if self.dc.term_values(:relation).first
+          self.dc.term_values(:relation).each {|val|
+            if val =~ /clio:/
+              solr_doc["clio_s"] ||= []
+              solr_doc["clio_s"] << val.split(':')[-1]
+            end
+          }
+        end
+      end
+      solr_doc["format"] = [self.route_as]
+      solr_doc["index_type_label_s"] = [self.index_type_label]
+      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
+          current_indexed_attributes = {}
+          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
+  
+    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)
+        puts "old: #{v} new: #{new_val} changed? #{!(v.eql? new_val)}"
+        logger.debug "old: #{v} new: #{new_val} changed? #{!(v.eql? new_val)}"
+        changed ||= !(v.eql? new_val)
+      }
+      puts "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
+  end
+end

data/lib/cul_scv_hydra/active_fedora/model/dcdocument.rb

@@ -0,0 +1,43 @@
+require "active-fedora"
+require "cul_scv_hydra/active_fedora"
+require "hydra"
+module Cul::Scv::Hydra::ActiveFedora::Model
+class DcDocument < ::ActiveFedora::Base
+  include ::ActiveFedora::Relationships
+  include ::Hydra::ModelMethods
+  include Cul::Scv::Hydra::ActiveFedora::Model::Common
+  alias :file_objects :resources
+
+  # relationships #
+  has_relationship "containers", :cul_member_of
+  has_relationship "parts", :cul_member_of, :inbound => true
+
+  def self.load_instance_from_solr(pid,solr_doc=nil)
+    if solr_doc.nil?
+      result = find_by_solr(pid)
+      raise "Object #{pid} not found in solr" if result.nil?
+      solr_doc = result.hits.first
+      #double check pid and id in record match
+      raise "Object #{pid} not found in Solr" unless !result.nil? && !solr_doc.nil? && pid == solr_doc[SOLR_DOCUMENT_ID]
+    else
+      raise "Solr document record id and pid do not match" unless pid == solr_doc[SOLR_DOCUMENT_ID]
+    end
+     
+    create_date = solr_doc[::ActiveFedora::SolrService.solr_name(:system_create, :date)].nil? ? solr_doc[::ActiveFedora::SolrService.solr_name(:system_create, :date).to_s] : solr_doc[::ActiveFedora::SolrService.solr_name(:system_create, :date)]
+    modified_date = solr_doc[::ActiveFedora::SolrService.solr_name(:system_create, :date)].nil? ? solr_doc[::ActiveFedora::SolrService.solr_name(:system_modified, :date).to_s] : solr_doc[::ActiveFedora::SolrService.solr_name(:system_modified, :date)]
+    obj = DcDocument.new({:pid=>solr_doc[SOLR_DOCUMENT_ID],:create_date=>create_date,:modified_date=>modified_date})
+    obj.new_object = false
+      #set by default to load any dependent relationship objects from solr as well
+    obj.load_from_solr = true
+      #need to call rels_ext once so it exists when iterating over datastreams
+    obj.rels_ext
+    obj.datastreams.each_value do |ds|
+      if ds.respond_to?(:from_solr)
+        ds.from_solr(solr_doc) if ds.kind_of?(::ActiveFedora::MetadataDatastream) || ds.kind_of?(::ActiveFedora::NokogiriDatastream) || ( ds.kind_of?(::ActiveFedora::RelsExtDatastream))
+      end
+    end
+    obj
+  end
+  
+end
+end

data/lib/cul_scv_hydra/active_fedora/model/resource.rb

@@ -0,0 +1,79 @@
+module Cul::Scv::Hydra::ActiveFedora::Model
+module Resource
+    extend ActiveSupport::Concern
+# constants #
+  IMAGE_MIME_TYPES = [
+    'image/bmp',
+    'image/gif',
+    'image/jpeg',
+    'image/png',
+    'image/tiff'
+  ]
+
+  included do
+    if self.respond_to? :has_relationship
+      has_relationship "image_width", :image_width
+      has_relationship "image_length", :image_length
+      has_relationship "x_sampling", :x_sampling
+      has_relationship "y_sampling", :y_sampling
+      has_relationship "sampling_unit", :sampling_unit
+      has_relationship "extent", :extent
+      
+      after_create :resource!      
+    end
+    if self.respond_to? :has_datastream
+      has_datastream :name => "CONTENT", :type=>::ActiveFedora::Datastream, :versionable => true
+    end
+  end
+  module InstanceMethods
+    def resource!
+      add_relationship(:rdf_type, Cul::Scv::Hydra::ActiveFedora::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_prop_nodes = Cul::Image::Properties.identify(blob).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
+      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
+end
+end

data/lib/cul_scv_hydra/controllers.rb

@@ -0,0 +1,13 @@
+module Cul::Scv::Hydra
+  module Controllers
+  end
+end
+require 'cul_scv_hydra/controllers/aggregates'
+require 'cul_scv_hydra/controllers/catalog'
+require 'cul_scv_hydra/controllers/content_aggregators'
+require 'cul_scv_hydra/controllers/datastreams'
+require 'cul_scv_hydra/controllers/helpers'
+require 'cul_scv_hydra/controllers/resources'
+require 'cul_scv_hydra/controllers/static_image_aggregators'
+require 'cul_scv_hydra/controllers/suggestions'
+require 'cul_scv_hydra/controllers/terms'

data/lib/cul_scv_hydra/controllers/aggregates.rb

@@ -0,0 +1,95 @@
+require 'cul_scv_hydra/controllers/aggregator_controller_helper'
+require 'cul_scv_hydra/controllers/helpers/resources_helper_behavior'
+module Cul::Scv::Hydra::Controllers
+module Aggregates
+  extend ActiveSupport::Concern
+  included do
+    include Hydra::AssetsControllerHelper
+    include Cul::Scv::Hydra::Controllers::AggregatorControllerHelper
+    include Cul::Scv::Hydra::Controllers::Helpers::ResourcesHelperBehavior  
+    include Hydra::RepositoryController  
+    include MediaShelf::ActiveFedoraHelper
+    include Blacklight::SolrHelper
+    before_filter :require_solr, :only=>[:index, :create, :show, :destroy]
+    before_filter :load_resources, :only=>[:index]
+    prepend_before_filter :sanitize_update_params
+  end
+  module InstanceMethods
+    def index
+
+      if params[:layout] == "false"
+        layout = false
+      end
+      container_uri = "info:fedora/#{params[:asset_id]}"
+      escaped_uri = container_uri.gsub(/(:)/, '\\:')
+      extra_controller_params =  {:q=>"cul_member_of_s:#{escaped_uri}"}
+      @response, @document_list = get_search_results( extra_controller_params )
+      
+        # Including this line so permissions tests can be run against the container
+      @container_response, @document = get_solr_response_for_doc_id(params[:asset_id])
+      
+      render :action=>params[:action], :layout=>layout
+    end
+
+    def load_aggregate
+      if params.has_key? :aggregate_id
+        af_base = ActiveFedora::Base.load_instance(params[:aggregate_id])
+      else
+        af_base = ActiveFedora::Base.load_instance(params[:id])
+      end
+      the_model = ActiveFedora::ContentModel.known_models_for( af_base ).first
+      if the_model.nil? or the_model == ActiveFedora::Base
+        the_model = DcDocument
+      end
+
+      @resource = the_model.load_instance(af_base.pid)
+    end
+  
+    # Creates and Saves a Parent - Child relationship in the Child's RELS-EXT
+    # If container_id is provided:
+    # * the File Asset will use RELS-EXT to assert that it's a part of the specified container
+    # * the method will redirect to the container object's edit view after saving
+    def create
+      if params.has_key?(:aggregate_id)
+        @resource = load_aggregate
+        logger.debug @resource.class
+        logger.debug @resource.datastreams["RELS-EXT"].content
+        logger.debug @resource.to_rels_ext(@resource.pid)
+        if !params[:asset_id].nil?
+          associate_resource_with_container(@resource, params[:asset_id])
+          @resource.save
+          flash[:notice] = "Aggregated #{@resource.pid} under #{params[:asset_id]}."
+        else
+          flash[:notice] = "You must specify a container for the aggregate."
+        end
+      else
+        flash[:notice] = "You must specify a resource to aggregate."
+      end
+    
+      if !params[:asset_id].nil?
+        redirect_params = {:controller=>"aggregates", :id=>params[:asset_id], :action=>:index}
+      end
+    
+      redirect_params ||= {:action=>:index}
+    
+      redirect_to redirect_params
+    end
+  
+    # Common destroy method for all AssetsControllers 
+    def destroy
+      @resource = load_aggregate
+      remove_resource_from_container(@resource, params[:asset_id])
+      @resource.save
+
+      flash[:notice] = "Deleted #{params[:id]} from #{params[:asset_id]}."
+      if !params[:asset_id].nil?
+        redirect_params = {:controller=>"aggregates", :id=>params[:asset_id], :action=>:index}
+      end
+    
+      redirect_params ||= {:action=>:index}
+    
+      redirect_to redirect_params
+    end
+  end
+end
+end