ddr-models 1.2.0

data/lib/ddr/configurable.rb

@@ -0,0 +1,34 @@
+module Ddr
+  module Configurable
+    extend ActiveSupport::Concern
+
+    included do
+      # Base directory of external file store
+      mattr_accessor :external_file_store      
+
+      # Regexp for building external file subpath from hex digest
+      mattr_accessor :external_file_subpath_regexp
+      
+      # Pattern (template) for constructing noids
+      mattr_accessor :noid_template
+
+      # Noid minter state file location
+      mattr_accessor :minter_statefile
+    end
+
+    module ClassMethods
+      def configure
+        yield self
+      end
+
+      def external_file_subpath_pattern= (pattern)
+        unless /^-{1,2}(\/-{1,2}){0,3}$/ =~ pattern
+          raise "Invalid external file subpath pattern: #{pattern}"
+        end
+        re = pattern.split("/").map { |x| "(\\h{#{x.length}})" }.join("")
+        self.external_file_subpath_regexp = Regexp.new("^#{re}")
+      end
+    end
+
+  end
+end

data/lib/ddr/datastreams.rb

@@ -0,0 +1,32 @@
+require 'active_fedora'
+
+module Ddr
+  module Datastreams
+    extend ActiveSupport::Autoload
+
+    CONTENT = "content"
+    CONTENT_METADATA = "contentMetadata"
+    DC = "DC"
+    DEFAULT_RIGHTS = "defaultRights"
+    DESC_METADATA = "descMetadata"
+    PROPERTIES = "properties"
+    RELS_EXT = "RELS-EXT"
+    RIGHTS_METADATA = "rightsMetadata"
+    THUMBNAIL = "thumbnail"
+
+    CHECKSUM_TYPE_MD5 = "MD5"
+    CHECKSUM_TYPE_SHA1 = "SHA-1"
+    CHECKSUM_TYPE_SHA256 = "SHA-256"
+    CHECKSUM_TYPE_SHA384 = "SHA-384"
+    CHECKSUM_TYPE_SHA512 = "SHA-512"
+
+    CHECKSUM_TYPES = [ CHECKSUM_TYPE_MD5, CHECKSUM_TYPE_SHA1, CHECKSUM_TYPE_SHA256, CHECKSUM_TYPE_SHA384, CHECKSUM_TYPE_SHA512 ]
+
+    autoload :ContentMetadataDatastream
+    autoload :DescriptiveMetadataDatastream
+    autoload :PropertiesDatastream
+    autoload :DatastreamBehavior
+    autoload :RoleAssignmentsDatastream
+
+  end
+end

data/lib/ddr/datastreams/content_metadata_datastream.rb

@@ -0,0 +1,147 @@
+module Ddr
+  module Datastreams
+    class ContentMetadataDatastream < ActiveFedora::Datastream
+    
+      def parse
+        parsed = []
+        cm = Nokogiri::XML(self.content)
+        fileSec_nodes = cm.xpath("//xmlns:fileSec")
+        structMap_nodes = cm.xpath("//xmlns:structMap").sort{ |x,y| sort_nodes(x, y) }
+        structMap_nodes.each do |structMap_node|
+          structMap_hash = {}
+          div_nodes = structMap_node.xpath("xmlns:div").sort{ |x,y| sort_nodes(x,y) }
+          div_array = []
+          div_nodes.each do |div_node|
+            div_array << parse_div(fileSec_nodes, div_node)
+          end
+          structMap_hash["div"] = div_array
+          parsed << structMap_hash
+        end
+        return parsed
+      end
+      
+      def to_solr(solr_doc=Hash.new)
+        solr_doc = super(solr_doc)
+        if self.content
+          solr_doc.merge!({Ddr::IndexFields::CONTENT_METADATA_PARSED => parse.to_json})
+        end
+        solr_doc
+      end    
+      
+      def first_pid
+        find_first_pid(parse.first)
+      end
+      
+      private
+      
+      def find_first_pid(structure)
+        case
+        when structure.has_key?("div")
+          find_first_pid(structure["div"].first)
+        when structure.has_key?("pids")
+          structure["pids"].first["pid"]
+        end
+      end
+      
+      def walk_structure_to_pid(structure)
+        if structure.has_key("div")
+          walk_structure_div(structure["div"])
+        else 
+        end
+        
+      end
+      
+      def parse_div(fileSec_nodes, div_node)
+        div_hash = {}
+        div_hash["label"] = div_node["LABEL"] unless div_node["LABEL"].nil?
+        div_hash["orderlabel"] = div_node["ORDERLABEL"] unless div_node["ORDERLABEL"].nil?
+        div_hash["type"] = div_node["TYPE"] unless div_node["TYPE"].nil?
+        div_subnodes = div_node.xpath("xmlns:div").sort{ |x,y| sort_nodes(x, y) }
+        if div_subnodes.empty?
+          fptr_nodes = div_node.xpath("xmlns:fptr")
+          fptr_array = []
+          fptr_nodes.each do |fptr_node|
+            fptr_hash = {}
+            if !fptr_node["FILEID"].nil?
+              pid = get_pid(fileSec_nodes, fptr_node["FILEID"])
+              file_use = get_use(fileSec_nodes, fptr_node["FILEID"])
+              fptr_hash["pid"] = pid unless pid.nil?
+              fptr_hash["use"] = file_use unless file_use.nil?
+            end
+            fptr_array << fptr_hash
+          end
+          div_hash["pids"] = fptr_array
+        else
+          div_array = []
+          div_subnodes.each do |div_subnode|
+            div_array << parse_div(fileSec_nodes, div_subnode)
+          end
+          div_hash["div"] = div_array
+        end
+        return div_hash
+      end
+      
+      def get_use(fileSec_nodes, file_id)
+        file_nodes = fileSec_nodes.xpath("//xmlns:file[@ID='#{file_id}']")
+        file_node =
+          case file_nodes.size
+          when 1
+            file_nodes.first
+          when 0
+            raise "Matching file node not found"
+          else
+            raise "Multiple matching file nodes found"
+          end
+        return find_use(file_node)
+      end
+      
+      def find_use(node)
+        file_use = nil
+        if node["USE"].nil?
+          file_use = find_use(node.parent) unless node.name.eql?("fileGrp")
+        else
+          file_use = node["USE"]
+        end
+        return file_use
+      end
+      
+      def get_pid(fileSec_nodes, file_id)
+        file_nodes = fileSec_nodes.xpath("//xmlns:file[@ID='#{file_id}']")
+        file_node =
+          case file_nodes.size
+          when 1
+            file_nodes.first
+          when 0
+            raise "Matching file node not found"
+          else
+            raise "Multiple matching file nodes found"
+          end
+        fLocat_nodes = file_node.xpath("xmlns:FLocat")
+        fLocat_node =
+          case fLocat_nodes.size
+          when 1
+            fLocat_nodes.first
+          when 0
+            raise "FLocat node not found"
+          else
+            raise "Multiple FLocat nodes found"
+          end
+        href = fLocat_node["xlink:href"]
+        pid = href.split('/')[0]
+      end
+      
+      def sort_nodes(node_1, node_2)
+        if node_1["ORDER"].nil? && node_2["ORDER"].nil?
+          return 0
+        elsif node_1["ORDER"].nil?
+          return 1
+        elsif node_2["ORDER"].nil?
+          return -1
+        else
+          return node_1["ORDER"].to_i <=> node_2["ORDER"].to_i
+        end
+      end
+
+    end    
+  end
+end

data/lib/ddr/datastreams/datastream_behavior.rb

@@ -0,0 +1,95 @@
+module Ddr
+  module Datastreams
+    module DatastreamBehavior
+
+      DEFAULT_FILE_EXTENSION = "bin"
+
+      STRFTIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%LZ"
+
+      def validate_checksum! checksum, checksum_type=nil
+        raise Ddr::Models::Error, "Checksum cannot be validated on new datastream." if new?
+        raise Ddr::Models::Error, "Checksum cannot be validated on unpersisted content." if content_changed?
+        raise Ddr::Models::ChecksumInvalid, "The repository internal checksum validation failed." unless dsChecksumValid
+        algorithm = checksum_type || self.checksumType
+        ds_checksum = if algorithm == self.checksumType
+                        self.checksum
+                      else 
+                        content_digest(algorithm)
+                      end
+        if checksum == ds_checksum
+          "The checksum [#{algorithm}]#{checksum} is valid for datastream #{version_info}."
+        else
+          raise Ddr::Models::ChecksumInvalid, "The checksum [#{algorithm}]#{checksum} is not valid for datastream #{version_info}."
+        end
+      end
+
+      def version_uri
+        # E.g., info:fedora/duke:1/content/content.0
+        ["info:fedora", pid, dsid, dsVersionID].join("/") unless new?
+      end
+
+      def version_info
+        # E.g., info:fedora/duke:1/content/content.0 [2013-09-26T20:00:03.357Z]
+        "#{version_uri} [#{Ddr::Utils.ds_as_of_date_time(self)}]" unless new?
+      end
+    
+      def create_date_string
+        dsCreateDate.strftime(STRFTIME_FORMAT) if dsCreateDate
+      end
+
+      def content_digest algorithm
+        Ddr::Utils.digest(self.content, algorithm)
+      end
+
+      # Returns a list of the external file paths for all versions of the datastream.
+      def file_paths
+        raise "The `file_paths' method is valid only for external datastreams." unless external?
+        return Array(file_path) if new?
+        versions.map(&:file_path).compact
+      end
+
+      # Returns the external file path for the datastream.
+      # Returns nil if dsLocation is not a file URI.
+      def file_path
+        raise "The `file_path' method is valid only for external datastreams." unless external?
+        Ddr::Utils.path_from_uri(dsLocation) if Ddr::Utils.file_uri?(dsLocation)
+      end
+
+      # Returns the file name of the external file for the datastream.
+      # See #external_datastream_file_path(ds)
+      def file_name
+        raise "The `file_name' method is valid only for external datastreams." unless external?
+        File.basename(file_path) rescue nil
+      end
+
+      # Returns the size of the external file for the datastream.
+      def file_size
+        raise "The `file_size' method is valid only for external datastreams." unless external?
+        File.size(file_path) rescue nil
+      end
+
+      # Return default file extension for datastream based on MIME type
+      def default_file_extension
+        mimetypes = MIME::Types[mimeType]
+        return mimetypes.first.extensions.first unless mimetypes.empty?
+        case mimeType
+        when 'application/n-triples'
+          'txt'
+        else
+          DEFAULT_FILE_EXTENSION
+        end
+      end
+
+      # Return default file name prefix based on object PID
+      def default_file_prefix
+        [pid.sub(/:/, '_'), dsid].join("_")
+      end
+
+      # Return default file name
+      def default_file_name
+        [default_file_prefix, default_file_extension].join(".")
+      end
+
+    end
+  end
+end

data/lib/ddr/datastreams/descriptive_metadata_datastream.rb

@@ -0,0 +1,84 @@
+module Ddr
+  module Datastreams
+    class DescriptiveMetadataDatastream < ActiveFedora::NtriplesRDFDatastream
+
+      class_attribute :vocabularies
+      self.vocabularies = [RDF::DC, Ddr::Metadata::DukeTerms].freeze
+
+      def self.default_attributes
+        super.merge(:mimeType => 'application/n-triples')
+      end
+
+      def self.indexers
+        # Add term_name => [indexers] mapping to customize indexing
+        {}
+      end
+
+      def self.default_indexers
+        [:stored_searchable]
+      end
+
+      def self.indexers_for(term_name)
+        indexers.fetch(term_name, default_indexers)
+      end
+
+      def self.term_names
+        terms = []
+        vocabularies.each do |vocab|
+          terms |= Ddr::Metadata::Vocabulary.term_names(vocab)
+        end
+        terms.sort
+      end
+
+      # Add terms from the vocabularies as properties
+      vocabularies.each do |vocab|
+        vocab.each do |term|
+          term_name = Ddr::Metadata::Vocabulary.term_name(vocab, term)
+          property term_name, predicate: term do |index|
+            index.as *indexers_for(term_name)
+          end
+        end
+      end
+     
+      # Returns ActiveFedora::Rdf::Term now that this is an RDF datastream
+      def values term
+        term == :format ? self.format : self.send(term)
+      end
+
+      # Update term with values
+      # Note that empty values (nil or "") are rejected from values array
+      def set_values term, values
+        if values.respond_to?(:reject!)
+          values.reject! { |v| v.blank? }
+        else
+          values = nil if values.blank?
+        end
+        begin
+          self.send("#{term}=", values)
+        rescue NoMethodError
+          raise ArgumentError, "No such term: #{term}"
+        end
+      end
+
+      # Add value to term
+      # Note that empty value (nil or "") is not added
+      def add_value term, value
+        begin
+          unless value.blank?
+            values = values(term).to_a << value
+            set_values term, values
+          end
+        rescue NoMethodError
+          raise ArgumentError, "No such term: #{term}"
+        end
+      end
+
+      # Override ActiveFedora::Rdf::Indexing#apply_prefix(name) to not
+      # prepend the index field name with a string based on the datastream id.
+      def apply_prefix(name)
+        name
+      end
+
+    end
+  end
+end

data/lib/ddr/datastreams/properties_datastream.rb

@@ -0,0 +1,25 @@
+module Ddr
+  module Datastreams  
+    class PropertiesDatastream < ActiveFedora::OmDatastream
+
+      set_terminology do |t|
+        t.root(:path => "fields")
+        t.original_filename
+        t.permanent_id
+      end
+
+      def prefix
+        # Squash AF 8.0 deprecation warning
+        ""
+      end
+      
+      def self.xml_template
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.fields
+        end
+        builder.doc
+      end
+
+    end
+  end
+end

data/lib/ddr/datastreams/role_assignments_datastream.rb

@@ -0,0 +1,19 @@
+module Ddr
+  module Datastreams
+    class RoleAssignmentsDatastream < ActiveFedora::NtriplesRDFDatastream
+
+      vocabulary = Ddr::Metadata::RolesVocabulary
+
+      vocabulary.each do |term|
+        property Ddr::Metadata::Vocabulary.term_name(vocabulary, term), predicate: term do |index|
+          index.as :symbol
+        end
+      end
+
+      def principal_has_role?(principal, role)
+        (send(role) & Array(principal)).any?
+      end
+
+    end
+  end
+end

data/lib/ddr/events.rb

@@ -0,0 +1,17 @@
+module Ddr
+  module Events
+    extend ActiveSupport::Autoload
+
+    autoload :Event
+    autoload :CreationEvent
+    autoload :FixityCheckEvent
+    autoload :IngestionEvent
+    autoload :UpdateEvent
+    autoload :ValidationEvent
+    autoload :VirusCheckEvent
+    autoload :PreservationEventType
+    autoload :PreservationEventBehavior
+    autoload :ReindexObjectAfterSave
+    
+  end
+end