ddr-models 1.2.0

data/lib/ddr/models/solr_document.rb

@@ -0,0 +1,193 @@
+require 'json'
+
+module Ddr
+  module Models
+    module SolrDocument
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method :pid, :id
+      end
+
+      def to_partial_path
+        'document'
+      end
+
+      def safe_id
+        id.sub(/:/, "-")
+      end
+
+      def active_fedora_model
+        get(Ddr::IndexFields::ACTIVE_FEDORA_MODEL)
+      end
+
+      def internal_uri
+        get(Ddr::IndexFields::INTERNAL_URI)
+      end
+    
+      def object_profile
+        @object_profile ||= get_json(Ddr::IndexFields::OBJECT_PROFILE)
+      end
+
+      def object_state
+        object_profile["objState"]
+      end
+
+      def object_create_date
+        parse_date(object_profile["objCreateDate"])
+      end
+
+      def object_modified_date
+        parse_date(object_profile["objLastModDate"])
+      end
+
+      def last_fixity_check_on
+        get_date(Ddr::IndexFields::LAST_FIXITY_CHECK_ON)
+      end
+
+      def last_fixity_check_outcome
+        get(Ddr::IndexFields::LAST_FIXITY_CHECK_OUTCOME)
+      end
+
+      def last_virus_check_on
+        get_date(Ddr::IndexFields::LAST_VIRUS_CHECK_ON)
+      end
+
+      def last_virus_check_outcome
+        get(Ddr::IndexFields::LAST_VIRUS_CHECK_OUTCOME)
+      end
+
+      def datastreams
+        object_profile["datastreams"]
+      end
+
+      def has_datastream?(dsID)
+        datastreams[dsID].present?
+      end
+
+      def has_admin_policy?
+        admin_policy_uri.present?
+      end
+
+      def admin_policy_uri
+        get(Ddr::IndexFields::IS_GOVERNED_BY)
+      end
+
+      def admin_policy_pid
+        uri = admin_policy_uri
+        uri &&= ActiveFedora::Base.pid_from_uri(uri)
+      end
+
+      def has_children?
+        ActiveFedora::SolrService.class_from_solr_document(self).reflect_on_association(:children).present?
+      end
+
+      def label
+        object_profile["objLabel"]
+      end
+
+      def title
+        get(Ddr::IndexFields::TITLE)
+      end
+      alias_method :title_display, :title # duck-type Ddr::Models::Base
+
+      def principal_has_role?(principal, role)
+        (Array(get("role_assignments__#{role}_ssim")) & Array(principal)).any?
+      end
+
+      def identifier
+        # We want the multivalued version here
+        get(ActiveFedora::SolrService.solr_name(:identifier, :stored_searchable, type: :text))
+      end
+
+      def source
+        get(ActiveFedora::SolrService.solr_name(:source, :stored_searchable, type: :text))
+      end
+    
+      def has_thumbnail?
+        has_datastream?(Ddr::Datastreams::THUMBNAIL)
+      end
+
+      def has_content?
+        has_datastream?(Ddr::Datastreams::CONTENT)
+      end
+
+      def content_ds
+        datastreams[Ddr::Datastreams::CONTENT]
+      end
+
+      def content_mime_type
+        content_ds["dsMIME"] rescue nil
+      end
+      # For duck-typing with Ddr::Models::HasContent
+      alias_method :content_type, :content_mime_type
+
+      def content_size
+        get(Ddr::IndexFields::CONTENT_SIZE)
+      end
+
+      def content_size_human
+        get(Ddr::IndexFields::CONTENT_SIZE_HUMAN)
+      end
+    
+      def content_checksum
+        content_ds["dsChecksum"] rescue nil
+      end
+    
+      def targets
+        @targets ||= ActiveFedora::SolrService.query(targets_query)
+      end
+
+      def targets_count
+        @targets_count ||= ActiveFedora::SolrService.count(targets_query)
+      end
+    
+      def has_target?
+        targets_count > 0
+      end
+    
+      def has_default_rights?
+        has_datastream?(Ddr::Datastreams::DEFAULT_RIGHTS)
+      end
+    
+      def parsed_content_metadata
+        JSON.parse(self[Ddr::IndexFields::CONTENT_METADATA_PARSED].first)
+      end
+
+      def association(name)
+        get_pid(ActiveFedora::SolrService.solr_name(name, :symbol))
+      end
+
+      def controller_name
+        active_fedora_model.tableize
+      end
+
+      private
+
+      def targets_query
+        "#{Ddr::IndexFields::IS_EXTERNAL_TARGET_FOR}:#{internal_uri_for_query}"
+      end
+
+      def internal_uri_for_query
+        ActiveFedora::SolrService.escape_uri_for_query(internal_uri)
+      end
+
+      def get_date(field)
+        parse_date(get(field))
+      end
+
+      def get_json(field)
+        JSON.parse(self[field].first)
+      end
+
+      def parse_date(date)
+        Time.parse(date).localtime if date
+      end
+
+      def get_pid(field)
+        ActiveFedora::Base.pid_from_uri(get(field)) rescue nil
+      end
+
+    end
+  end
+end

data/lib/ddr/models/version.rb

@@ -0,0 +1,5 @@
+module Ddr
+  module Models
+    VERSION = "1.2.0"
+  end
+end

data/lib/ddr/notifications.rb

@@ -0,0 +1,15 @@
+module Ddr
+  module Notifications
+    
+    FIXITY_CHECK = "fixity_check.events.ddr"
+    VIRUS_CHECK = "virus_check.events.ddr"
+    CREATION = "creation.events.ddr"
+    UPDATE = "update.events.ddr"
+
+    def self.notify_event(type, args={})
+      name = "#{type}.events.ddr"
+      ActiveSupport::Notifications.instrument(name, args)
+    end
+
+  end
+end

data/lib/ddr/services.rb

@@ -0,0 +1,8 @@
+module Ddr
+  module Services
+    extend ActiveSupport::Autoload
+    
+    autoload :IdService
+    
+  end
+end

data/lib/ddr/services/id_service.rb

@@ -0,0 +1,48 @@
+require 'noid'
+
+module Ddr
+  module Services
+    module IdService
+
+      def self.noid_template
+        Ddr::Models.noid_template
+      end
+
+      @minter = ::Noid::Minter.new(template: noid_template)
+      @semaphore = Mutex.new
+      
+      def self.valid? noid
+        @minter.valid? noid
+      end
+
+      def self.mint
+        @semaphore.synchronize do
+          while true
+            minted = Ddr::Models::MintedId.new(minted_id: self.next_id)
+            return minted.minted_id if minted.save
+          end
+        end
+      end
+
+      protected
+
+      def self.next_id
+        noid = ''
+        File.open(Ddr::Models.minter_statefile, File::RDWR|File::CREAT, 0644) do |f|
+          f.flock(File::LOCK_EX)
+          yaml = YAML::load(f.read)
+          yaml = {template: noid_template} unless yaml
+          minter = ::Noid::Minter.new(yaml)
+          noid = minter.mint
+          f.rewind
+          yaml = YAML::dump(minter.dump)
+          f.write yaml
+          f.flush
+          f.truncate(f.pos)
+        end
+        noid
+      end
+
+    end
+  end
+end

data/lib/ddr/utils.rb

@@ -0,0 +1,153 @@
+require 'openssl'
+
+module Ddr::Utils
+
+  DEFAULT_MIME_TYPE = "application/octet-stream"
+
+  def self.digest content, algorithm
+    raise TypeError, "Algorithm must be a string: #{algorithm.inspect}" unless algorithm.is_a?(String)
+    digest_class = OpenSSL::Digest.const_get(algorithm.sub("-", "").to_sym)
+    digest_class.new(content).to_s
+  rescue NameError => e
+    raise ArgumentError, "Invalid algorithm: #{algorithm}"
+  end
+
+  # Return a mime type for the file, using the file_name if necessary
+  # file can be a File object or file path (String)
+  # Return default mime type if unable to determine otherwise
+  def self.mime_type_for(file, file_name=nil)
+    return file.content_type if file.respond_to?(:content_type) # E.g., Rails uploaded file
+    path = file_name || file_path(file) rescue nil
+    mime_types = MIME::Types.of(path) rescue []                 # MIME::Types.of blows up on nil
+    mime_types.empty? ? DEFAULT_MIME_TYPE : mime_types.first.content_type
+  end
+
+  def self.file_or_path? file
+    file_path(file)
+  rescue ArgumentError
+    false
+  end
+  
+  def self.file_path? file
+    # length is a sanity check
+    file.is_a?(String) && (file.length < 1024) && File.exists?(file)
+  end
+
+  def self.file_path file
+    if file.respond_to?(:path) 
+      File.absolute_path(file.path)
+    elsif file_path?(file)
+      file
+    else
+      raise ArgumentError, "File argument is neither a File nor a path to an existing file."
+    end
+  end
+
+  def self.file_name_for file
+    return file.original_filename if file.respond_to?(:original_filename) && file.original_filename.present?
+    File.basename(file_path(file)) rescue nil
+  end
+
+  def self.file_uri?(uri)
+    return false unless uri
+    URI.parse(uri).scheme == "file"
+  end
+
+  # Return file path for URI string 
+  # Should reverse .path_to_uri
+  # "file:/path/to/file" => "/path/to/file"
+  def self.path_from_uri(uri)
+    URI.unescape(URI.parse(uri).path)
+  end
+
+  # Return URI string for file path
+  # Should reverse .path_from_uri
+  # "/path/to/file" => "file:/path/to/file"
+  def self.path_to_uri(path)
+    uri = URI.parse(URI.escape(path))
+    uri.scheme = "file"
+    uri.to_s
+  end
+
+  def self.ds_as_of_date_time(ds)
+    ds.create_date_string
+  end
+  
+  # Find an object with a given identifier and return its PID.
+  # Returns the PID if a single object is found.
+  # Returns nil if no object is found.
+  # Raises Ddr::Error if more than one object is found.
+  # Options can be provided to limit the scope of matching objects
+  #   model: Will only consider objects of that model
+  #   collection: Will only consider objects that either are that collection or which are
+  #      direct children of that collection (i.e., effectively searches a collection and its
+  #      items for an object with the given identifier)
+  def self.pid_for_identifier(identifier, opts={})
+    model = opts.fetch(:model, nil)
+    collection = opts.fetch(:collection, nil)
+    objs = []
+    ActiveFedora::Base.find_each( { Ddr::IndexFields::IDENTIFIER => identifier }, { :cast => true } ) { |o| objs << o }
+    pids = []
+    objs.each { |obj| pids << obj.pid }
+    if model.present?
+      objs.each { |obj| pids.delete(obj.pid) unless obj.is_a?(model.constantize) }
+    end
+    if collection.present?
+      objs.each do |obj|
+        pids.delete(obj.pid) unless obj == collection || obj.parent == collection
+      end
+    end
+    case pids.size
+    when 0
+      nil
+    when 1
+      pids.first
+    else
+      raise Ddr::Error, I18n.t('ddr.errors.multiple_object_matches', :criteria => "identifier #{identifier}")
+    end
+  end
+
+  # Returns the reflection object for a given model name and relationship name
+  # E.g., relationship_object_reflection("Item", "parent") returns the reflection object for
+  # an Item's parent relationship.  This reflection object can then be used to obtain the
+  # class of the relationship object using the reflection_object_class(reflection) method below.
+  def self.relationship_object_reflection(model, relationship_name)
+    reflection = nil
+    if model
+      begin
+        reflections = model.constantize.reflections
+      rescue NameError
+        # nothing to do here except that we can't return the appropriate reflection
+      else
+        reflections.each do |reflect|
+          if reflect[0].eql?(relationship_name.to_sym)
+            reflection = reflect
+          end
+        end
+      end
+    end
+    return reflection
+  end
+
+  # Returns the class associated with the :class_name attribute in the options of a reflection
+  # E.g., reflection_object_class(relationship_object_reflection("Item", "parent")) returns the
+  # Collection class.
+  def self.reflection_object_class(reflection)
+    reflection_object_model = nil
+    klass = nil
+    if reflection[1].options[:class_name]
+      reflection_object_model = reflection[1].options[:class_name]
+    else
+      reflection_object_model = ActiveSupport::Inflector.camelize(reflection[0])
+    end
+    if reflection_object_model
+      begin
+        klass = reflection_object_model.constantize
+      rescue NameError
+        # nothing to do here except that we can't return the reflection object class
+      end
+    end
+    return klass
+  end
+  
+end

data/lib/ddr/workflow.rb

@@ -0,0 +1,8 @@
+module Ddr
+  module Workflow
+    extend ActiveSupport::Autoload
+    
+    autoload :WorkflowState
+    
+  end
+end

data/lib/ddr/workflow/workflow_state.rb

@@ -0,0 +1,39 @@
+module Ddr
+  module Workflow
+    class WorkflowState < ActiveRecord::Base
+
+      PUBLISHED = "published"
+      
+      def self.workflow_state_for_object(obj)
+        workflow_state_for_pid(obj.pid)
+      end
+
+      def self.workflow_state_for_pid(pid)
+        for_pid(pid).present? ? for_pid(pid).first.workflow_state : nil
+      end
+
+      def self.set_for_object(obj, state)
+        set_for_pid(obj.pid, state)
+      end
+
+      def self.set_for_pid(pid, state)
+        if for_pid(pid).present?
+          for_pid(pid).first.update(workflow_state: state)
+        else
+          create(pid: pid, workflow_state: state)
+        end
+      end
+
+      private
+
+      def self.for_object(obj)
+        for_pid(obj.pid)
+      end
+
+      def self.for_pid(pid)
+        where(pid: pid)
+      end
+      
+    end
+  end
+end