ddr-core 0.2.1

data/lib/ddr/index/response.rb

@@ -0,0 +1,30 @@
+require "delegate"
+
+module Ddr::Index
+  #
+  # Wraps an index query response
+  #
+  class Response < SimpleDelegator
+
+    def docs
+      response["docs"]
+    end
+
+    def num_found
+      response["numFound"].to_i
+    end
+
+    def facet_counts
+      self["facet_counts"] || {}
+    end
+
+    def facet_fields
+      facet_counts["facet_fields"] || {}
+    end
+
+    def response
+      self["response"]
+    end
+
+  end
+end

data/lib/ddr/index/sort_order.rb

@@ -0,0 +1,28 @@
+require "virtus"
+
+module Ddr::Index
+  class SortOrder
+    include Virtus.value_object
+
+    ASC = "asc"
+    DESC = "desc"
+
+    values do
+      attribute :field, FieldAttribute
+      attribute :order, String
+    end
+
+    def to_s
+      [ field, order ].join(" ")
+    end
+
+    def self.asc(field)
+      new(field: field, order: ASC)
+    end
+
+    def self.desc(field)
+      new(field: field, order: DESC)
+    end
+
+  end
+end

data/lib/ddr/index/unique_key_field.rb

@@ -0,0 +1,12 @@
+require 'singleton'
+
+module Ddr::Index
+  class UniqueKeyField < Field
+    include Singleton
+
+  def initialize
+      super Ddr::SOLR_DOCUMENT_ID
+  end
+
+  end
+end

data/lib/ddr/managers.rb

@@ -0,0 +1,9 @@
+module Ddr
+  module Managers
+    extend ActiveSupport::Autoload
+
+    autoload :Manager
+    autoload :TechnicalMetadataManager
+
+  end
+end

data/lib/ddr/managers/manager.rb

@@ -0,0 +1,13 @@
+module Ddr
+  module Managers
+    # @abstract
+    class Manager
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+    end
+  end
+end

data/lib/ddr/managers/technical_metadata_manager.rb

@@ -0,0 +1,141 @@
+module Ddr
+  module Managers
+    class TechnicalMetadataManager < Manager
+
+      FITS_TIMESTAMP_FORMAT = "%D %l:%M %p" # Ex. 7/3/15 8:29 PM
+
+      delegate :content, to: :object
+
+      delegate :color_space,
+               :created,
+               :creating_application,
+               :extent,
+               :format_label,
+               :format_version,
+               :icc_profile_name,
+               :icc_profile_version,
+               :image_height,
+               :image_width,
+               :media_type,
+               :modified,
+               :pronom_identifier,
+               :valid,
+               :well_formed,
+               to: :fits
+
+      alias_method :last_modified, :modified
+
+      def fits
+        if object.fits_file.present?
+          Ddr::Fits.new(Nokogiri::XML(object.fits_file.file))
+        else
+          Ddr::Fits.new(Ddr::Fits.xml_template)
+        end
+      end
+
+      def fits?
+        !fits_version.nil?
+      end
+
+      def fits_version
+        fits.version.first
+      end
+
+      def fits_datetime
+        if fits_timestamp = fits.timestamp.first
+          # no_zone = DateTime.strptime(fits_timestamp, FITS_TIMESTAMP_FORMAT)
+          # no_zone.change(offset: no_zone.to_time.zone)
+          Time.zone.strptime(fits_timestamp, FITS_TIMESTAMP_FORMAT)
+        end
+      end
+
+      def file_size
+        extent.map(&:to_i)
+      end
+
+      def file_human_size
+        file_size.map do |fs|
+          "%s (%s bytes)" % [ ActiveSupport::NumberHelper.number_to_human_size(fs),
+                              ActiveSupport::NumberHelper.number_to_delimited(fs) ]
+        end
+      end
+
+      def md5
+        fits.md5.first
+      end
+
+      # Ddr::File currently implements the 'digest' attribute as a set (array) of
+      # Ddr::Digest objects.  This method (and the 'checksum_value' method that
+      # follows) assumes there is only one checksum associated with a file (as was
+      # the case in ddr-models).  The current implementation simply picks the first
+      # checksum, unless/until we decide on a different approach.
+      def checksum_digest
+        content&.digest&.first&.type
+      end
+
+      def checksum_value
+        content&.digest&.first&.value
+      end
+
+      def invalid?
+        valid.any? { |v| v == "false" }
+      end
+
+      def valid?
+        !invalid?
+      end
+
+      def ill_formed?
+        well_formed.any? { |v| v == "false" }
+      end
+
+      def well_formed?
+        !ill_formed?
+      end
+
+      def creation_time
+        created.map { |datestr| coerce_to_time(datestr) }.compact
+      end
+
+      def modification_time
+        modified.map { |datestr| coerce_to_time(datestr) }.compact
+      end
+
+      ### DDRevo #######################################################
+      # Holding off on this until we address indexing more generally,
+      # perhaps in the context of the ddr-admin staff app.
+      ### DDRevo #######################################################
+      # def index_fields
+      #   { Ddr::Index::Fields::TECHMD_FITS_VERSION      => fits_version,
+      #     Ddr::Index::Fields::TECHMD_FITS_DATETIME     => Ddr::Utils.solr_date(fits_datetime),
+      #     Ddr::Index::Fields::TECHMD_CREATION_TIME     => Ddr::Utils.solr_dates(creation_time),
+      #     Ddr::Index::Fields::TECHMD_MODIFICATION_TIME => Ddr::Utils.solr_dates(modification_time),
+      #     Ddr::Index::Fields::TECHMD_COLOR_SPACE       => color_space,
+      #     Ddr::Index::Fields::TECHMD_CREATING_APPLICATION => creating_application,
+      #     Ddr::Index::Fields::TECHMD_FILE_SIZE         => file_size,
+      #     Ddr::Index::Fields::TECHMD_FORMAT_LABEL      => format_label,
+      #     Ddr::Index::Fields::TECHMD_FORMAT_VERSION    => format_version,
+      #     Ddr::Index::Fields::TECHMD_ICC_PROFILE_NAME  => icc_profile_name,
+      #     Ddr::Index::Fields::TECHMD_ICC_PROFILE_VERSION => icc_profile_version,
+      #     Ddr::Index::Fields::TECHMD_IMAGE_HEIGHT      => image_height,
+      #     Ddr::Index::Fields::TECHMD_IMAGE_WIDTH       => image_width,
+      #     Ddr::Index::Fields::TECHMD_MD5               => md5,
+      #     Ddr::Index::Fields::TECHMD_MEDIA_TYPE        => media_type,
+      #     Ddr::Index::Fields::TECHMD_PRONOM_IDENTIFIER => pronom_identifier,
+      #     Ddr::Index::Fields::TECHMD_VALID             => valid,
+      #     Ddr::Index::Fields::TECHMD_WELL_FORMED       => well_formed,
+      #   }
+      # end
+
+      private
+
+      def coerce_to_time(datestr)
+        datestr.sub! /\A(\d+):(\d+):(\d+)/, '\1-\2-\3'
+        DateTime.parse(datestr).to_time
+      rescue ArgumentError
+        nil
+      end
+
+    end
+  end
+end

data/lib/ddr/structure.rb

@@ -0,0 +1,188 @@
+module Ddr
+  #
+  # Wraps a Nokogiri (XML) 'mets' Document
+  #
+  class Structure < SimpleDelegator
+
+    # Indicates whether the structure is externally provided or maintained by the repository itself (i.e., is the
+    # default structure for the object).
+    EXTERNALLY_PROVIDED = 'provided'.freeze
+    REPOSITORY_MAINTAINED = 'repository'.freeze
+
+    TYPE_DEFAULT = 'default'.freeze
+
+    # Based on the PCDM Extension 'Use' ontology -- https://github.com/duraspace/pcdm/blob/master/pcdm-ext/use.rdf
+    USE_EXTRACTED_TEXT = 'ExtractedText'.freeze
+    USE_INTERMEDIATE_FILE = 'IntermediateFile'.freeze
+    USE_ORIGINAL_FILE = 'OriginalFile'.freeze
+    USE_PRESERVATION_MASTER_FILE = 'PreservationMasterFile'.freeze
+    USE_SERVICE_FILE = 'ServiceFile'.freeze
+    USE_THUMBNAIL_IMAGE = 'ThumbnailImage'.freeze
+    USE_TRANSCRIPT = 'Transcript'.freeze
+
+    def filesec
+      @filesec ||= Ddr::Structures::FileSec.new(fileSec_node)
+    end
+
+    def files
+      @files ||= collect_files
+    end
+
+    def uses
+      @uses ||= collect_uses
+    end
+
+    def structmap(type=nil)
+      sm = type ? structMap_node(type) : structMap_nodes.first
+      @structmap ||= Ddr::Structures::StructMap.new(sm)
+    end
+
+    def structmaps
+      @structmaps ||= structMap_nodes.map { |sm| Ddr::Structures::StructMap.new(sm) }
+    end
+
+    def metshdr
+      @metshdr ||=  Ddr::Structures::MetsHdr.new(metsHdr_node)
+    end
+
+    def creator
+      @creator ||= metshdr.empty? ? nil
+                                  : Ddr::Structures::MetsHdr.new(metsHdr_node).agents.first.name
+    end
+
+    def repository_maintained?
+      creator == Ddr::Structures::Agent::NAME_REPOSITORY_DEFAULT
+    end
+
+    def dereferenced_structure
+      deref_struct = {}
+      structmaps.each do |sm|
+        deref_struct[sm.type] = sm.dereferenced_hash
+      end
+      deref_struct
+    end
+
+    def as_xml_document
+      __getobj__
+    end
+
+    def add_metshdr(id:nil, createdate:nil, lastmoddate:nil, recordstatus:nil)
+      metshdr = Ddr::Structures::MetsHdr.build(id: id, createdate: createdate, lastmoddate: lastmoddate,
+                                                       recordstatus: recordstatus, document: as_xml_document)
+      root.add_child(metshdr)
+      metshdr
+    end
+
+    def add_agent(parent:, id:nil, role:, otherrole:nil, type:nil, othertype:nil, name:nil)
+      agent = Ddr::Structures::Agent.build(id: id, role: role, otherrole: otherrole, type: type,
+                                                   othertype: othertype, name: name, document: as_xml_document)
+      parent.add_child(agent)
+      agent
+    end
+
+    def add_filesec(id:nil)
+      filesec = Ddr::Structures::FileSec.build(id: id, document: as_xml_document)
+      root.add_child(filesec)
+      filesec
+    end
+
+    def add_filegrp(parent:, id:nil, use:nil)
+      filegrp = Ddr::Structures::FileGrp.build(id: id, use: use, document: as_xml_document)
+      parent.add_child(filegrp)
+      filegrp
+    end
+
+    def add_file(parent:, id:SecureRandom.uuid, use:nil)
+      file = Ddr::Structures::File.build(id: id, use: use, document: as_xml_document)
+      parent.add_child(file)
+      file
+    end
+
+    def add_flocat(parent:, id:nil, loctype:'ARK', otherloctype: nil, use:nil, href:)
+      flocat = Ddr::Structures::FLocat.build(id: id, loctype: loctype, otherloctype: otherloctype, use: use,
+                                                     href: href, document: as_xml_document)
+      parent.add_child(flocat)
+      flocat
+    end
+
+    def add_structmap(id:nil, label:nil, type:)
+      structmap = Ddr::Structures::StructMap.build(id: id, label: label, type: type, document: as_xml_document)
+      root.add_child(structmap)
+      structmap
+    end
+
+    def add_div(parent:, id:nil, label:nil, order:nil, orderlabel: nil, type:nil)
+      div = Ddr::Structures::Div.build(id: id, label: label, order:order, orderlabel: orderlabel, type: type,
+                                               document: as_xml_document)
+      parent.add_child(div)
+      div
+    end
+
+    def add_fptr(parent:, id: nil, fileid:)
+      fptr = Ddr::Structures::Fptr.build(id: id, fileid: fileid, document: as_xml_document)
+      parent.add_child(fptr)
+      fptr
+    end
+
+    def add_mptr(parent:, id: nil, loctype:'ARK', otherloctype: nil, href:)
+      mptr = Ddr::Structures::Mptr.build(id: id, loctype: loctype, otherloctype: otherloctype, href: href,
+                                                 document: as_xml_document)
+      parent.add_child(mptr)
+      mptr
+    end
+
+    private
+
+    def fileSec_node
+      xpath("//xmlns:fileSec").first
+    end
+
+    def structMap_nodes
+      xpath("//xmlns:structMap")
+    end
+
+    def structMap_node(type)
+      xpath("//xmlns:structMap[@TYPE='#{type}']").first
+    end
+
+    def metsHdr_node
+      xpath("//xmlns:metsHdr")
+    end
+
+    def file_nodes
+      xpath("//xmlns:file")
+    end
+
+    def flocat_nodes
+      xpath("//xmlns:FLocat")
+    end
+
+    def collect_files
+      files = {}
+      file_nodes.each do |file_node|
+        file = Ddr::Structures::File.new(file_node)
+        files[file.id] = file
+      end
+      files
+    end
+
+    def collect_uses
+      uses = {}
+      flocat_nodes.each do |flocat_node|
+        flocat = Ddr::Structures::FLocat.new(flocat_node)
+        uses[flocat.effective_use] ||= []
+        uses[flocat.effective_use] << flocat
+      end
+      uses
+    end
+
+    def self.xml_template
+      Nokogiri::XML(
+          '<mets xmlns="http://www.loc.gov/METS/" xmlns:xlink="http://www.w3.org/1999/xlink" />'
+          ) do |config|
+              config.noblanks
+            end
+    end
+
+  end
+end

data/lib/ddr/structures/agent.rb

@@ -0,0 +1,49 @@
+module Ddr::Structures
+  #
+  # Wraps a Nokogiri (XML) 'agent' node
+  #
+  class Agent < SimpleDelegator
+
+    ROLE_CREATOR = 'CREATOR'.freeze
+
+    NAME_REPOSITORY_DEFAULT = 'REPOSITORY DEFAULT'.freeze
+
+    def id
+      self['ID']
+    end
+
+    def role
+      self['ROLE']
+    end
+
+    def otherrole
+      self['OTHERROLE']
+    end
+
+    def type
+      self['TYPE']
+    end
+
+    def othertype
+      self['OTHERTYPE']
+    end
+
+    def name
+      xpath('xmlns:name').first.content
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('agent', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node['ROLE'] = args[:role] if args[:role]
+      node['OTHERROLE'] = args[:otherrole] if args[:otherrole]
+      node['TYPE'] = args[:type] if args[:type]
+      node['OTHERTYPE'] = args[:othertype] if args[:othertype]
+      name_node = Nokogiri::XML::Node.new('name', args[:document])
+      name_node.content = args[:name]
+      node.add_child(name_node)
+      node
+    end
+
+  end
+end