ddr-models 2.6.2 → 2.7.0.rc1

data/lib/ddr/models/permanent_id.rb

@@ -35,13 +35,15 @@ module Ddr::Models
       event = ActiveSupport::Notifications::Event.new(*args)
       repo_id, identifier_id, reason = event.payload.values_at(:pid, :permanent_id, :reason)
       case event.name
-      when /workflow/
-        update!(repo_id) if auto_update?
-      when /^deaccession/
+      when Base::UPDATE
+        if auto_update? && event.payload[:attributes_changed].include?("workflow_state")
+          update!(repo_id)
+        end
+      when Base::DEACCESSION
         if auto_update? && identifier_id
           deaccession!(repo_id, identifier_id, reason)
         end
-      when /^destroy/
+      when Base::DELETE
         if auto_update? && identifier_id
           delete!(repo_id, identifier_id, reason)
         end
@@ -104,21 +106,23 @@ module Ddr::Models
     end
 
     def assign!(id = nil)
-      ActiveSupport::Notifications.instrument("assign.permanent_id", pid: repo_object.id) do |payload|
-        assign(id)
-        software = [ "ddr-models #{Ddr::Models::VERSION}", Ezid::Client.version ].join("; ")
-        detail = <<-EOS
-Permanent ID:  #{repo_object.permanent_id}
-Permanent URL: #{repo_object.permanent_url}
-
-EZID Metadata:
-#{identifier.metadata}
-      EOS
-        payload.merge!(summary: "Permanent ID assignment",
-                       detail: detail,
-                       software: software,
-                       permanent_id: identifier.id)
+      if assigned?
+        raise AlreadyAssigned,
+              "Repository object \"#{repo_object.id}\" has already been assigned permanent id \"#{repo_object.permanent_id}\"."
       end
+      @identifier = case id
+                    when identifier_class
+                      id
+                    when String
+                      find_identifier(id)
+                    when nil
+                      mint_identifier
+                    end
+      repo_object.reload
+      repo_object.permanent_id = identifier.id
+      repo_object.permanent_url = PERMANENT_URL_BASE + identifier.id
+      repo_object.save!
+      set_metadata!
     end
 
     def assigned?
@@ -126,10 +130,11 @@ EZID Metadata:
     end
 
     def update!
-      ActiveSupport::Notifications.instrument("update.permanent_id", pid: repo_object.id) do |payload|
-        update
-        payload.merge!(permanent_id: identifier.id)
+      if !assigned?
+        raise IdentifierNotAssigned,
+              "Cannot update identifier for repository object \"#{repo_object.id}\"; not assigned."
       end
+      set_status!
     end
 
     def deaccession!(reason = nil)
@@ -220,34 +225,6 @@ EZID Metadata:
       identifier_class.mint(*args)
     end
 
-    def update
-      if !assigned?
-        raise IdentifierNotAssigned,
-              "Cannot update identifier for repository object \"#{repo_object.id}\"; not assigned."
-      end
-      set_status!
-    end
-
-    def assign(id = nil)
-      if assigned?
-        raise AlreadyAssigned,
-              "Repository object \"#{repo_object.id}\" has already been assigned permanent id \"#{repo_object.permanent_id}\"."
-      end
-      @identifier = case id
-                    when identifier_class
-                      id
-                    when String
-                      find_identifier(id)
-                    when nil
-                      mint_identifier
-                    end
-      repo_object.reload
-      repo_object.permanent_id = identifier.id
-      repo_object.permanent_url = PERMANENT_URL_BASE + identifier.id
-      repo_object.save!
-      set_metadata!
-    end
-
     def delete_or_make_unavailable(reason)
       if repo_id && identifier_repo_id && ( identifier_repo_id != repo_id )
         raise Error, "Identifier \"#{identifier_id}\" is assigned to a different repository object \"#{repo_id}\"."

data/lib/ddr/models/solr_document.rb

@@ -184,14 +184,10 @@ module Ddr::Models
       @roles ||= Ddr::Auth::Roles::DetachedRoleSet.from_json(access_role)
     end
 
-    def struct_maps
-      JSON.parse(fetch(Ddr::Index::Fields::STRUCT_MAPS))
+    def structure
+      JSON.parse(fetch(Ddr::Index::Fields::STRUCTURE))
     rescue
-      {}
-    end
-
-    def struct_map(type='default')
-      struct_maps.present? ? struct_maps.fetch(type) : nil
+      nil
     end
 
     def effective_permissions(agents)
@@ -217,8 +213,12 @@ module Ddr::Models
       end
     end
 
-    def multires_image_file_paths(type='default')
-      struct_map_docs(type).map { |doc| doc.multires_image_file_path }.compact
+    def multires_image_file_paths
+      if structure
+        structure_docs.map { |doc| doc.multires_image_file_path }.compact
+      else
+        []
+      end
     end
 
     # DRY HasAdminMetadata
@@ -260,18 +260,20 @@ module Ddr::Models
       end
     end
 
-    def struct_map_docs(type='default')
-      struct_map_pids(type).map { |pid| self.class.find(pid) }.compact
+    def structure_docs
+      structure_repo_ids.map { |repo_id| self.class.find(repo_id) }.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
-      []
+    # For simplicity, initial implementation returns repo ID's only from top-level
+    # (i.e., not nested) contents.  This is done since we have not clarified what
+    # an _ordered_ list of repo ID's should look like if structure contains nested
+    # contents.
+    def structure_repo_ids
+      default_struct_map['contents'].map { |content| content['contents'].map { |content| content['repo_id'] } }.flatten
+    end
+
+    def default_struct_map
+      structure['default'] || structure.values.first
     end
 
   end

data/lib/ddr/models/structure.rb

@@ -1,56 +1,183 @@
-module Ddr
-  module Models
-    #
-    # Wraps a Nokogiri (XML) Document
-    #
-    class Structure < SimpleDelegator
-
-      def initialize(xml_doc=nil)
-        super
-      end
+module Ddr::Models
+  #
+  # Wraps a Nokogiri (XML) 'mets' Document
+  #
+  class Structure < SimpleDelegator
 
-      def struct_maps
-        @struct_maps ||= build_struct_maps(structMap_nodes)
-      end
+    TYPE_DEFAULT = 'default'.freeze
 
-      def structMap_node(type='default')
-        xpath("//xmlns:structMap[@TYPE='#{type}']").first
-      end
+    # 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 fptr_nodes(type='default')
-        structMap_node(type).xpath('//xmlns:fptr')
-      end
+    def filesec
+      @filesec ||= Ddr::Models::Structures::FileSec.new(fileSec_node)
+    end
 
-      def as_xml_document
-        __getobj__
-      end
+    def files
+      @files ||= collect_files
+    end
 
-      private
+    def uses
+      @uses ||= collect_uses
+    end
 
-      def structMap_nodes
-        xpath("//xmlns:structMap")
+    def structmap(type=nil)
+      sm = type ? structMap_node(type) : structMap_nodes.first
+      @structmap ||= Ddr::Models::Structures::StructMap.new(sm)
+    end
+
+    def structmaps
+      @structmaps ||= structMap_nodes.map { |sm| Ddr::Models::Structures::StructMap.new(sm) }
+    end
+
+    def metshdr
+      @metshdr ||=  Ddr::Models::Structures::MetsHdr.new(metsHdr_node)
+    end
+
+    def creator
+      @creator ||= metshdr.empty? ? nil
+                                  : Ddr::Models::Structures::MetsHdr.new(metsHdr_node).agents.first.name
+    end
+
+    def repository_maintained?
+      creator == Ddr::Models::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::Models::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::Models::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::Models::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::Models::Structures::FileGrp.build(id: id, use: use, document: as_xml_document)
+      parent.add_child(filegrp)
+      filegrp
+    end
 
-      def build_struct_maps(structMap_nodes)
-        smaps = {}
-        structMap_nodes.each do |structMap_node|
-          type = structMap_node['TYPE'] || 'default'
-          raise StandardError, "Multiple '#{type}' structMaps" if smaps[type].present?
-          smaps[type] = Ddr::Models::StructDiv.new(structMap_node)
-        end
-        smaps
+    def add_file(parent:, id:SecureRandom.uuid, use:nil)
+      file = Ddr::Models::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::Models::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::Models::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::Models::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::Models::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::Models::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::Models::Structures::File.new(file_node)
+        files[file.id] = file
       end
+      files
+    end
 
-      def self.template
-        Nokogiri::XML(
-            '<mets xmlns="http://www.loc.gov/METS/" xmlns:xlink="http://www.w3.org/1999/xlink">
-              <structMap TYPE="default" />
-            </mets>'
-            ) do |config|
-                config.noblanks
-              end
+    def collect_uses
+      uses = {}
+      flocat_nodes.each do |flocat_node|
+        flocat = Ddr::Models::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/models/structures/agent.rb

@@ -0,0 +1,49 @@
+module Ddr::Models::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

data/lib/ddr/models/structures/div.rb

@@ -0,0 +1,64 @@
+module Ddr::Models::Structures
+  #
+  # Wraps a Nokogiri (XML) 'div' node
+  #
+  class Div < SimpleDelegator
+
+    def id
+      self['ID']
+    end
+
+    def label
+      self['LABEL']
+    end
+
+    def order
+      self['ORDER']
+    end
+
+    def orderlabel
+      self['ORDERLABEL']
+    end
+
+    def type
+      self['TYPE']
+    end
+
+    def divs
+      xpath('xmlns:div').map { |node| Div.new(node) }
+    end
+
+    def fptrs
+      xpath('xmlns:fptr').map { |node| Fptr.new(node) }
+    end
+
+    def mptrs
+      xpath('xmlns:mptr').map { |node| Mptr.new(node) }
+    end
+
+    def <=>(other)
+      order.to_i <=> other.order.to_i
+    end
+
+    def dereferenced_hash
+      contents = []
+      contents.concat(divs.map { |div| div.dereferenced_hash }) unless divs.empty?
+      contents.concat(fptrs.map { |fptr| fptr.dereferenced_hash }) unless fptrs.empty?
+      contents.concat(mptrs.map { |mptr| mptr.dereferenced_hash }) unless mptrs.empty?
+      dh = { id: id, label: label, order: order, orderlabel: orderlabel, type: type }.compact
+      dh[:contents] = contents unless contents.empty?
+      dh
+    end
+
+    def self.build(args)
+      node = Nokogiri::XML::Node.new('div', args[:document])
+      node['ID'] = args[:id] if args[:id]
+      node['LABEL'] = args[:label] if args[:label]
+      node['ORDER'] = args[:order] if args[:order]
+      node['ORDERLABEL'] = args[:orderlabel] if args[:orderlabel]
+      node['TYPE'] = args[:type] if args[:type]
+      node
+    end
+
+  end
+end