ddr-models 2.0.1 → 2.1.0.rc1

data/lib/ddr/models/has_children.rb

@@ -3,7 +3,7 @@ module Ddr
     module HasChildren
 
       def first_child
-        ActiveFedora::Base.where(association_query(:children)).order("#{Ddr::IndexFields::LOCAL_ID} ASC").first
+        ActiveFedora::Base.where(association_query(:children)).order("#{Ddr::Index::Fields::LOCAL_ID} ASC").first
       end
 
     end

data/lib/ddr/models/has_content.rb

@@ -29,12 +29,21 @@ module Ddr
           label: "Text extracted from the content file",
           control_group: "M"
 
+        has_metadata \
+          name: Ddr::Datastreams::FITS,
+          type: Ddr::Datastreams::FitsDatastream,
+          versionable: true,
+          label: "FITS Output for content file",
+          control_group: "M"
+
         has_attributes :original_filename, datastream: "adminMetadata", multiple: false
 
         include FileManagement
 
         around_save :update_derivatives, if: :content_changed?
 
+        around_save :characterize_file, if: [ :content_changed?, "Ddr::Models.characterize_files?" ]
+
         after_add_file do
           if file_to_add.original_name && file_to_add.dsid == "content"
             self.original_filename = file_to_add.original_name
@@ -59,6 +68,10 @@ module Ddr
         @derivatives ||= Ddr::Managers::DerivativesManager.new(self)
       end
 
+      def techmd
+        @techmd ||= Ddr::Managers::TechnicalMetadataManager.new(self)
+      end
+
       def content_size
         content.external? ? content.file_size : content.dsSize
       end
@@ -122,6 +135,11 @@ module Ddr
         derivatives.update_derivatives(:later)
       end
 
+      def characterize_file
+        yield
+        Resque.enqueue(Ddr::Jobs::FitsFileCharacterization, pid)
+      end
+
       def default_content_type
         "application/octet-stream"
       end

data/lib/ddr/models/has_struct_metadata.rb

@@ -26,11 +26,15 @@ module Ddr
         structure
       end
 
+      def multires_image_file_paths(type='default')
+        ::SolrDocument.find(pid).multires_image_file_paths(type)
+      end
+
       private
 
       def find_children
         query = association_query(:children)
-        sort = "#{Ddr::IndexFields::LOCAL_ID} ASC, #{Ddr::IndexFields::OBJECT_CREATE_DATE} ASC"
+        sort = "#{Ddr::Index::Fields::LOCAL_ID} ASC, #{Ddr::Index::Fields::OBJECT_CREATE_DATE} ASC"
         ActiveFedora::SolrService.query(query, sort: sort, rows: 999999)
       end
 

data/lib/ddr/models/indexing.rb

@@ -2,7 +2,7 @@ module Ddr
   module Models
     module Indexing
 
-      include Ddr::IndexFields
+      include Ddr::Index::Fields
 
       def to_solr(solr_doc=Hash.new, opts={})
         solr_doc = super(solr_doc, opts)
@@ -11,22 +11,34 @@ module Ddr
 
       def index_fields
         fields = {
-          TITLE                 => title_display,
-          INTERNAL_URI          => internal_uri,
-          IDENTIFIER_ALL        => all_identifiers,
-          WORKFLOW_STATE        => workflow_state,
-          LOCAL_ID              => local_id,
+          ACCESS_ROLE           => roles.to_json,
           ADMIN_SET             => admin_set,
+          BOX_NUMBER_FACET      => desc_metadata_values('box_number'),
+          CREATOR_FACET         => creator,
+          DATE_FACET            => date,
+          DATE_SORT             => date_sort,
+          DEPOSITOR             => depositor,
           DISPLAY_FORMAT        => display_format,
+          DOI                   => adminMetadata.doi,
+          IDENTIFIER_ALL        => all_identifiers,
+          INTERNAL_URI          => internal_uri,
+          LICENSE               => license,
+          LICENSE_DESCRIPTION   => rightsMetadata.license.description.first,
+          LICENSE_TITLE         => rightsMetadata.license.title.first,
+          LICENSE_URL           => rightsMetadata.license.url.first,
+          LOCAL_ID              => local_id,
           PERMANENT_ID          => permanent_id,
           PERMANENT_URL         => permanent_url,
-          ACCESS_ROLE           => roles.to_json,
-          RESOURCE_ROLE         => roles.in_resource_scope.agents,
           POLICY_ROLE           => roles.in_policy_scope.agents,
-          CREATOR_FACET         => creator,
-          DATE_FACET            => date,
-          DATE_SORT             => date_sort,
-          RESEARCH_HELP_CONTACT => research_help_contact
+          PUBLISHER_FACET       => publisher,
+          RESEARCH_HELP_CONTACT => research_help_contact,
+          RESOURCE_ROLE         => roles.in_resource_scope.agents,
+          SERIES_FACET          => desc_metadata_values('series'),
+          SPATIAL_FACET         => desc_metadata_values('spatial'),
+          TITLE                 => title_display,
+          TYPE_FACET            => type,
+          WORKFLOW_STATE        => workflow_state,
+          YEAR_FACET            => year_facet,
         }
         if respond_to? :fixity_checks
           last_fixity_check = fixity_checks.last
@@ -36,11 +48,6 @@ module Ddr
           last_virus_check = virus_checks.last
           fields.merge!(last_virus_check.to_solr) if last_virus_check
         end
-        if respond_to? :license
-          fields[LICENSE_DESCRIPTION] = license_description
-          fields[LICENSE_TITLE] = license_title
-          fields[LICENSE_URL] = license_url
-        end
         if has_content?
           fields[CONTENT_CONTROL_GROUP] = content.controlGroup
           fields[CONTENT_SIZE] = content_size
@@ -48,6 +55,7 @@ module Ddr
           fields[MEDIA_TYPE] = content_type
           fields[MEDIA_MAJOR_TYPE] = content_major_type
           fields[MEDIA_SUB_TYPE] = content_sub_type
+          fields.merge! techmd.index_fields
         end
         if has_multires_image?
           fields[MULTIRES_IMAGE_FILE_PATH] = multires_image_file_path
@@ -62,9 +70,9 @@ module Ddr
           fields[COLLECTION_URI] = collection_uri
         end
         if is_a? Collection
-          fields[DEFAULT_LICENSE_DESCRIPTION] = default_license_description
-          fields[DEFAULT_LICENSE_TITLE] = default_license_title
-          fields[DEFAULT_LICENSE_URL] = default_license_url
+          fields[DEFAULT_LICENSE_DESCRIPTION] = defaultRights.license.description.first
+          fields[DEFAULT_LICENSE_TITLE] = defaultRights.license.title.first
+          fields[DEFAULT_LICENSE_URL] = defaultRights.license.url.first
           fields[ADMIN_SET_FACET] = admin_set_facet
           fields[COLLECTION_FACET] = collection_facet
         end
@@ -106,6 +114,10 @@ module Ddr
         date.first
       end
 
+      def year_facet
+        YearFacet.call(self)
+      end
+
     end
   end
 end

data/lib/ddr/models/inherited_license.rb

@@ -0,0 +1,13 @@
+module Ddr::Models
+  class InheritedLicense
+
+    def self.call(obj)
+      if obj.respond_to?(:parent) && obj.parent
+        EffectiveLicense.call obj.parent
+      elsif obj.admin_policy && (obj.admin_policy != obj)
+        EffectiveLicense.call obj.admin_policy
+      end
+    end
+
+  end
+end

data/lib/ddr/models/license.rb

@@ -0,0 +1,38 @@
+require "ostruct"
+require "ddr_aux/client"
+
+module Ddr::Models
+  class License < SimpleDelegator
+
+    class << self
+      def get(url)
+        new DdrAux::Client.find_license(url: url)
+      end
+
+      def all
+        DdrAux::Client.licenses.map { |l| new(l) }
+      end
+
+      def call(obj)
+        if obj.license
+          l = get obj.license
+          l[:licensed] = obj.pid
+          l
+        end
+      end
+    end
+
+    def initialize(args={})
+      super OpenStruct.new(args)
+    end
+
+    def to_json
+      to_h.to_json
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.__getobj__ == __getobj__
+    end
+
+  end
+end

data/lib/ddr/models/solr_document.rb

@@ -1,275 +1,259 @@
 require 'json'
 
-module Ddr
-  module Models
-    module SolrDocument
-      extend ActiveSupport::Concern
+module Ddr::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 admin_set
-        get(Ddr::IndexFields::ADMIN_SET)
-      end
-
-      def local_id
-        get(Ddr::IndexFields::LOCAL_ID)
-      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
+    included do
+      alias_method :pid, :id
+    end
 
-      def object_state
-        object_profile["objState"]
-      end
+    class NotFound < Error; end
 
-      def object_create_date
-        parse_date(object_profile["objCreateDate"])
+    module ClassMethods
+      def find(pid_or_uri)
+        pid = pid_or_uri.sub(/\Ainfo:fedora\//, "")
+        query = Ddr::Index::QueryBuilder.build { |q| q.id(pid) }
+        if doc = query.docs.first
+          return doc
+        end
+        raise NotFound, "SolrDocument not found for \"#{pid_or_uri}\"."
       end
+    end
 
-      def object_modified_date
-        parse_date(object_profile["objLastModDate"])
-      end
+    def inspect
+      "#<#{self.class.name} id=#{id.inspect}>"
+    end
 
-      def last_fixity_check_on
-        get_date(Ddr::IndexFields::LAST_FIXITY_CHECK_ON)
+    def method_missing(name, *args, &block)
+      if args.empty? && !block
+        begin
+          field = Ddr::Index::Fields.get(name)
+        rescue NameError
+        # pass
+        else
+          # Preserves the default behavior of the deprecated method
+          # Blacklight::Solr::Document#get, which this procedure
+          # effectively replaces.
+          val = self[field]
+          return val.is_a?(Array) ? val.join(", ") : val
+        end
       end
+      super
+    end
 
-      def last_fixity_check_outcome
-        get(Ddr::IndexFields::LAST_FIXITY_CHECK_OUTCOME)
-      end
+    def to_partial_path
+      'document'
+    end
 
-      def last_virus_check_on
-        get_date(Ddr::IndexFields::LAST_VIRUS_CHECK_ON)
-      end
+    def safe_id
+      id.sub(/:/, "-")
+    end
 
-      def last_virus_check_outcome
-        get(Ddr::IndexFields::LAST_VIRUS_CHECK_OUTCOME)
-      end
+    def object_profile
+      @object_profile ||= get_json(Ddr::Index::Fields::OBJECT_PROFILE)
+    end
 
-      def datastreams
-        object_profile["datastreams"]
-      end
+    def object_state
+      object_profile["objState"]
+    end
 
-      def has_datastream?(dsID)
-        datastreams[dsID].present?
-      end
+    def object_create_date
+      parse_date(object_profile["objCreateDate"])
+    end
 
-      def has_admin_policy?
-        admin_policy_uri.present?
-      end
+    def object_modified_date
+      parse_date(object_profile["objLastModDate"])
+    end
 
-      def admin_policy_uri
-        get(Ddr::IndexFields::IS_GOVERNED_BY)
-      end
+    def last_fixity_check_on
+      get_date(Ddr::Index::Fields::LAST_FIXITY_CHECK_ON)
+    end
 
-      def admin_policy_pid
-        uri = admin_policy_uri
-        uri &&= ActiveFedora::Base.pid_from_uri(uri)
-      end
+    def last_virus_check_on
+      get_date(Ddr::Index::Fields::LAST_VIRUS_CHECK_ON)
+    end
 
-      def admin_policy
-        if admin_policy_pid
-          query = ActiveFedora::SolrService.construct_query_for_pids([admin_policy_pid])
-          self.class.new(ActiveFedora::SolrService.query(query).first)
-        end
-      end
+    def datastreams
+      object_profile["datastreams"]
+    end
 
-      def has_children?
-        ActiveFedora::SolrService.class_from_solr_document(self).reflect_on_association(:children).present?
-      end
+    def has_datastream?(dsID)
+      datastreams[dsID].present?
+    end
 
-      def label
-        object_profile["objLabel"]
-      end
+    def has_admin_policy?
+      admin_policy_uri.present?
+    end
 
-      def title
-        get(Ddr::IndexFields::TITLE)
-      end
-      alias_method :title_display, :title # duck-type Ddr::Models::Base
+    def admin_policy_uri
+      is_governed_by
+    end
 
-      def identifier
-        # We want the multivalued version here
-        get(ActiveFedora::SolrService.solr_name(:identifier, :stored_searchable, type: :text))
-      end
+    def admin_policy_pid
+      uri = admin_policy_uri
+      uri &&= ActiveFedora::Base.pid_from_uri(uri)
+    end
 
-      def source
-        get(ActiveFedora::SolrService.solr_name(:source, :stored_searchable, type: :text))
+    def admin_policy
+      if has_admin_policy?
+        self.class.find(admin_policy_uri)
       end
+    end
 
-      def has_thumbnail?
-        has_datastream?(Ddr::Datastreams::THUMBNAIL)
-      end
+    def has_children?
+      ActiveFedora::SolrService.class_from_solr_document(self).reflect_on_association(:children).present?
+    end
 
-      def has_content?
-        has_datastream?(Ddr::Datastreams::CONTENT)
-      end
+    def label
+      object_profile["objLabel"]
+    end
 
-      def content_ds
-        datastreams[Ddr::Datastreams::CONTENT]
-      end
+    def title_display
+      title
+    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 identifier
+      # We want the multivalued version here
+      self[ActiveFedora::SolrService.solr_name(:identifier, :stored_searchable, type: :text)]
+    end
 
-      def content_size
-        get(Ddr::IndexFields::CONTENT_SIZE)
-      end
+    def source
+      self[ActiveFedora::SolrService.solr_name(:source, :stored_searchable, type: :text)]
+    end
 
-      def content_size_human
-        get(Ddr::IndexFields::CONTENT_SIZE_HUMAN)
-      end
+    def has_thumbnail?
+      has_datastream?(Ddr::Datastreams::THUMBNAIL)
+    end
 
-      def content_checksum
-        content_ds["dsChecksum"] rescue nil
-      end
+    def has_content?
+      has_datastream?(Ddr::Datastreams::CONTENT)
+    end
 
-      def targets
-        @targets ||= ActiveFedora::SolrService.query(targets_query)
-      end
+    def content_ds
+      datastreams[Ddr::Datastreams::CONTENT]
+    end
 
-      def targets_count
-        @targets_count ||= ActiveFedora::SolrService.count(targets_query)
-      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 has_target?
-        targets_count > 0
-      end
+    def content_checksum
+      content_ds["dsChecksum"] rescue nil
+    end
 
-      def has_default_rights?
-        has_datastream?(Ddr::Datastreams::DEFAULT_RIGHTS)
-      end
+    def targets
+      @targets ||= ActiveFedora::SolrService.query(targets_query)
+    end
 
-      def association(name)
-        get_pid(ActiveFedora::SolrService.solr_name(name, :symbol))
-      end
+    def targets_count
+      @targets_count ||= ActiveFedora::SolrService.count(targets_query)
+    end
 
-      def controller_name
-        active_fedora_model.tableize
-      end
+    def has_target?
+      targets_count > 0
+    end
 
-      def inherited_license
-        if admin_policy_pid
-          query = ActiveFedora::SolrService.construct_query_for_pids([admin_policy_pid])
-          results = ActiveFedora::SolrService.query(query)
-          doc = results.map { |result| ::SolrDocument.new(result) }.first
-          { title: doc.get(Ddr::IndexFields::DEFAULT_LICENSE_TITLE),
-            description: doc.get(Ddr::IndexFields::DEFAULT_LICENSE_DESCRIPTION),
-            url: doc.get(Ddr::IndexFields::DEFAULT_LICENSE_URL) }
-        end
-      end
+    def association(name)
+      get_pid(ActiveFedora::SolrService.solr_name(name, :symbol))
+    end
 
-      def license
-        if get(Ddr::IndexFields::LICENSE_TITLE) || get(Ddr::IndexFields::LICENSE_DESCRIPTION) || get(Ddr::IndexFields::LICENSE_URL)
-          { title: get(Ddr::IndexFields::LICENSE_TITLE),
-            description: get(Ddr::IndexFields::LICENSE_DESCRIPTION),
-            url: get(Ddr::IndexFields::LICENSE_URL) }
-        end
-      end
+    def controller_name
+      active_fedora_model.tableize
+    end
 
-      def effective_license
-        @effective_license ||= license || inherited_license || {}
-      end
+    def effective_license
+      @effective_license ||= EffectiveLicense.call(self)
+    end
 
-      def permanent_id
-        get(Ddr::IndexFields::PERMANENT_ID)
-      end
+    def roles
+      @roles ||= Ddr::Auth::Roles::DetachedRoleSet.from_json(access_role)
+    end
 
-      def multires_image_file_path
-        get(Ddr::IndexFields::MULTIRES_IMAGE_FILE_PATH)
-      end
+    def struct_maps
+      JSON.parse(fetch(Ddr::Index::Fields::STRUCT_MAPS))
+    rescue
+      {}
+    end
 
-      def roles
-        @roles ||= Ddr::Auth::Roles::DetachedRoleSet.from_json(access_role)
-      end
+    def struct_map(type='default')
+      struct_maps.present? ? struct_maps.fetch(type) : nil
+    end
 
-      def access_role
-         get(Ddr::IndexFields::ACCESS_ROLE)
-      end
+    def effective_permissions(agents)
+      Ddr::Auth::EffectivePermissions.call(self, agents)
+    end
 
-      def display_format
-        get(Ddr::IndexFields::DISPLAY_FORMAT)
-      end
+    def research_help
+      research_help_contact = self[Ddr::Index::Fields::RESEARCH_HELP_CONTACT] || inherited_research_help_contact
+      Ddr::Contacts.get(research_help_contact) if research_help_contact
+    end
 
-      def struct_maps
-        JSON.parse(fetch(Ddr::IndexFields::STRUCT_MAPS))
-      rescue
-        {}
-      end
+    def parent_uri
+      is_part_of || is_member_of_collection
+    end
 
-      def struct_map(type='default')
-        struct_maps.present? ? struct_maps.fetch(type) : nil
-      end
+    def has_parent?
+      parent_uri.present?
+    end
 
-      def effective_permissions(agents)
-        Ddr::Auth::EffectivePermissions.call(self, agents)
+    def parent
+      if has_parent?
+        self.class.find(parent_uri)
       end
+    end
 
-      def display_format
-        get(Ddr::IndexFields::DISPLAY_FORMAT)
-      end
+    def multires_image_file_paths(type='default')
+      struct_map_docs(type).map { |doc| doc.multires_image_file_path }.compact
+    end
 
-      def research_help
-        research_help_contact = self[Ddr::IndexFields::RESEARCH_HELP_CONTACT] || inherited_research_help_contact
-        Ddr::Contacts.get(research_help_contact) if research_help_contact
-      end
+    private
 
-      private
+    def targets_query
+      "#{Ddr::Index::Fields::IS_EXTERNAL_TARGET_FOR}:#{internal_uri_for_query}"
+    end
 
-      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 internal_uri_for_query
-        ActiveFedora::SolrService.escape_uri_for_query(internal_uri)
-      end
+    def get_date(field)
+      parse_date(self[field])
+    end
 
-      def get_date(field)
-        parse_date(get(field))
-      end
+    def get_json(field)
+      JSON.parse Array(self[field]).first
+    end
 
-      def get_json(field)
-        JSON.parse Array(self[field]).first
-      end
+    def parse_date(date)
+      Time.parse(date).localtime if date
+    end
 
-      def parse_date(date)
-        Time.parse(date).localtime if date
-      end
+    def get_pid(field)
+      ActiveFedora::Base.pid_from_uri(self[field]) rescue nil
+    end
 
-      def get_pid(field)
-        ActiveFedora::Base.pid_from_uri(get(field)) rescue nil
+    def inherited_research_help_contact
+      if doc = admin_policy
+        doc.research_help_contact
       end
+    end
 
-      def inherited_research_help_contact
-        if admin_policy_pid
-          query = ActiveFedora::SolrService.construct_query_for_pids([admin_policy_pid])
-          results = ActiveFedora::SolrService.query(query)
-          doc = results.map { |result| ::SolrDocument.new(result) }.first
-          doc[Ddr::IndexFields::RESEARCH_HELP_CONTACT]
-        end
-      end
+    def struct_map_docs(type='default')
+      struct_map_pids(type).map { |pid| self.class.find(pid) }.compact
+    end
 
+    # For simplicity, initial implementation returns PID's only from top-level
+    # (i.e., not nested) div's.  This is done since we have not clarified what
+    # an _ordered_ list of PID's should look like if struct map contains nested
+    # div's.
+    def struct_map_pids(type='default')
+      struct_map(type)['divs'].map { |d| d['fptrs'].present? ? d['fptrs'].first : nil}.compact
+    rescue
+      []
     end
+
   end
 end