dor-services 2.2.4 → 4.4.10

data/lib/dor/models/processable.rb

@@ -0,0 +1,229 @@
+require 'equivalent-xml'
+
+module Dor
+  module Processable
+    extend ActiveSupport::Concern
+    include SolrDocHelper
+    include Upgradable
+
+    included do
+      has_metadata :name => 'workflows', :type => Dor::WorkflowDs, :label => 'Workflows', :control_group => 'E'
+      after_initialize :set_workflows_datastream_location
+    end
+
+    def set_workflows_datastream_location
+      # This is a work-around for some strange logic in ActiveFedora that
+      # don't allow self.workflows.new? to work if we load the object using
+      # .load_instance_from_solr.
+      return if self.respond_to? :inner_object and self.inner_object.is_a? ActiveFedora::SolrDigitalObject
+
+      if self.workflows.new?
+        workflows.mimeType = 'application/xml'
+        workflows.dsLocation = File.join(Dor::Config.workflow.url,"dor/objects/#{self.pid}/workflows")
+      end
+    end
+
+    def empty_datastream?(datastream)
+      if datastream.new?
+        true
+      elsif datastream.class.respond_to?(:xml_template)
+        datastream.content.to_s.empty? or EquivalentXml.equivalent?(datastream.content, datastream.class.xml_template)
+      else
+        datastream.content.to_s.empty?
+      end
+    end
+
+    # Takes the name of a datastream, as a string.
+    # Tries to find a file for the datastream.
+    # Returns the path to it or nil.
+    def find_metadata_file(datastream)
+      druid = DruidTools::Druid.new(pid, Dor::Config.stacks.local_workspace_root)
+      return druid.find_metadata("#{datastream}.xml")
+    end
+
+    # Takes the name of a datastream, as a string (fooMetadata).
+    # Builds that datastream using the content of a file if such a file
+    # exists and is newer than the object's current datastream; otherwise,
+    # builds the datastream by calling build_fooMetadata_datastream.
+    def build_datastream(datastream, force = false, is_required = false)
+      # See if the datastream exists as a file and if the file's
+      # timestamp is newer than the datastream's timestamp.
+      ds       = datastreams[datastream]
+      filename = find_metadata_file(datastream)
+      use_file = filename && (ds.createDate.nil? || File.mtime(filename) >= ds.createDate)
+      # Build datastream.
+      if use_file
+        content = File.read(filename)
+        ds.content = content
+        ds.ng_xml = Nokogiri::XML(content) if ds.respond_to?(:ng_xml)
+        ds.save unless ds.digital_object.new?
+      elsif force or empty_datastream?(ds)
+        meth = "build_#{datastream}_datastream".to_sym
+        if respond_to?(meth)
+          content = self.send(meth, ds)
+          ds.save unless ds.digital_object.new?
+        end
+      end
+      # Check for success.
+      if is_required && empty_datastream?(ds)
+        raise "Required datastream #{datastream} could not be populated!"
+      end
+      return ds
+    end
+
+    def cleanup()
+      CleanupService.cleanup(self)
+    end
+
+    def milestones
+      Dor::WorkflowService.get_milestones('dor',self.pid)
+    end
+    def status(include_time=false)
+      current_version='1'
+      begin
+        current_version = self.versionMetadata.current_version_id
+      rescue
+      end
+      status = 0
+      version = ''
+      #verbage we want to use to describe an item when it has completed a particular step
+      status_hash={
+        0 => 'Unknown Status', #if there are no milestones for the current version, someone likely messed up the versioning process.
+        1 => 'Registered',
+        2 => 'In accessioning',
+        3 => 'In accessioning (described)',
+        4 => 'In accessioning (described, published)',
+        5 => 'In accessioning (described, published, deposited)',
+        6 => 'Accessioned',
+        7 => 'Accessioned (indexed)',
+        8 => 'Accessioned (indexed, ingested)',
+        9 => 'Opened'
+      }
+      #milestones from accesioning and the order they happen in
+      steps={
+        'registered' => 1,
+        'submitted' => 2,
+        'described' => 3,
+        'published' => 4,
+        'deposited' => 5,
+        'accessioned' => 6,
+        'indexed' => 7,
+        'shelved' => 8,
+        'opened' => 1
+      }
+      status_time=nil
+
+      current=false
+      versions=[]
+      result=""
+      current_milestones = []
+      #only get steps that are part of accessioning and part of the current version. That can mean they were archived with the current version number, or they might be active (no version number)
+      milestones.each do |m|
+        if steps.keys.include?(m[:milestone]) and (m[:version].nil? or m[:version] == current_version)
+          current_milestones << m unless m[:milestone] == 'registered' and current_version.to_i > 1
+        end
+      end
+      status = 0
+      status_time = ''
+      #for each milestone in the current version, see if it comes after the current 'last' step, if so, make it the last and record the date/time
+      current_milestones.each do |m|
+        name=m[:milestone]
+        time=m[:at].utc.xmlschema
+        if steps.keys.include? name
+          if steps[name] > status
+            status = steps[name]
+            status_time=time
+          end
+        end
+      end
+      #use the translation table to get the appropriate verbage for the latest step
+      result='v'+current_version.to_s+' '+status_hash[status].to_s
+      result +=" #{format_date(status_time)}" if include_time
+      result
+  end
+
+    def to_solr(solr_doc=Hash.new, *args)
+      super(solr_doc, *args)
+      sortable_milestones = {}
+      current_version='1'
+      begin
+        current_version = self.versionMetadata.current_version_id
+      rescue
+      end
+      current_version_num=current_version.to_i
+
+      if self.respond_to?('versionMetadata')
+        #add an entry with version id, tag and description for each version
+        while current_version_num > 0
+          add_solr_value(solr_doc, 'versions', current_version_num.to_s + ';' + self.versionMetadata.tag_for_version(current_version_num.to_s) + ';' + self.versionMetadata.description_for_version(current_version_num.to_s), :string, [:displayable])
+          current_version_num -= 1
+        end
+      end
+
+      self.milestones.each do |milestone|
+        timestamp = milestone[:at].utc.xmlschema
+        sortable_milestones[milestone[:milestone]] ||= []
+        sortable_milestones[milestone[:milestone]] << timestamp
+        add_solr_value(solr_doc, 'lifecycle', milestone[:milestone], :string, [:searchable, :facetable])
+        unless milestone[:version]
+          milestone[:version]=current_version
+        end
+        add_solr_value(solr_doc, 'lifecycle', "#{milestone[:milestone]}:#{timestamp};#{milestone[:version]}", :string, [:displayable])
+      end
+
+      sortable_milestones.each do |milestone, unordered_dates|
+        dates = unordered_dates.sort
+        #create the published_dt and published_day fields and the like
+        add_solr_value(solr_doc, milestone+'_day', DateTime.parse(dates.last).beginning_of_day.utc.xmlschema.split('T').first, :string, [:searchable, :facetable])
+        add_solr_value(solr_doc, milestone, dates.first, :date, [:searchable, :facetable])
+
+        #fields for OAI havester to sort on
+        add_solr_value(solr_doc, "#{milestone}_earliest_dt", dates.first, :date, [:sortable])
+        add_solr_value(solr_doc, "#{milestone}_latest_dt", dates.last, :date, [:sortable])
+
+        #for future faceting
+        add_solr_value(solr_doc, "#{milestone}_earliest", dates.first, :date, [:searchable, :facetable])
+        add_solr_value(solr_doc, "#{milestone}_latest", dates.last, :date, [ :searchable, :facetable])
+
+      end
+      add_solr_value(solr_doc,"status",status,:string, [:displayable])
+
+      if sortable_milestones['opened']
+        #add a facetable field for the date when the open version was opened
+        opened_date=sortable_milestones['opened'].sort.last
+        add_solr_value(solr_doc, "version_opened", DateTime.parse(opened_date).beginning_of_day.utc.xmlschema.split('T').first, :string, [ :searchable, :facetable])
+      end
+      add_solr_value(solr_doc, "current_version", current_version.to_s, :string, [ :displayable , :facetable])
+      add_solr_value(solr_doc, "last_modified_day", self.modified_date.to_s.split('T').first, :string, [ :facetable ])
+      add_solr_value(solr_doc, "rights", rights, :string, [:facetable]) if self.respond_to? :rights
+      solr_doc
+    end
+
+    # Initilizes workflow for the object in the workflow service
+    #  It will set the priorty of the new workflow to the current_priority if it is > 0
+    # @param [String] name of the workflow to be initialized
+    # @param [String] repo name of the repository to create workflow for
+    # @param [Boolean] create_ds create a 'workflows' datastream in Fedora for the object
+    def initialize_workflow(name, repo='dor', create_ds=true, priority=0)
+      priority = workflows.current_priority if priority == 0
+      opts = { :create_ds => create_ds }
+      opts[:priority] = priority if(priority > 0)
+      Dor::WorkflowService.create_workflow(repo, self.pid, name, Dor::WorkflowObject.initial_workflow(name), opts)
+    end
+    private
+    #handles formating utc date/time to human readable
+    def format_date datetime
+      begin
+        zone = ActiveSupport::TimeZone.new("Pacific Time (US & Canada)")
+        d = datetime.is_a?(Time) ? datetime : DateTime.parse(datetime).in_time_zone(zone)
+        I18n.l(d)
+      rescue
+        d = datetime.is_a?(Time) ? datetime : Time.parse(datetime.to_s)
+        d.strftime('%Y-%m-%d %I:%M%p')
+      end
+    end
+  end
+
+  
+end
+

data/lib/dor/models/publishable.rb

@@ -0,0 +1,74 @@
+require 'dor/datastreams/content_metadata_ds'
+
+module Dor
+  module Publishable
+    extend ActiveSupport::Concern
+    include Identifiable
+    include Governable
+    include Describable
+    include Itemizable
+
+    included do
+      has_metadata :name => "rightsMetadata", :type => ActiveFedora::OmDatastream, :label => 'Rights Metadata'
+    end
+
+    def build_rightsMetadata_datastream(ds)
+      content_ds = self.admin_policy_object.first.datastreams['defaultObjectRights']
+      ds.dsLabel = 'Rights Metadata'
+      ds.ng_xml = content_ds.ng_xml.clone
+      ds.content = ds.ng_xml.to_xml
+    end
+
+    def public_relationships
+      include_elements = ['fedora:isMemberOf','fedora:isMemberOfCollection']
+      rels_doc = Nokogiri::XML(self.datastreams['RELS-EXT'].content)
+      rels_doc.xpath('/rdf:RDF/rdf:Description/*', { 'rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' }).each do |rel|
+        unless include_elements.include?([rel.namespace.prefix,rel.name].join(':'))
+          rel.next_sibling.remove if rel.next_sibling.content.strip.empty?
+          rel.remove
+        end
+      end
+      rels_doc
+    end
+
+    def public_xml
+      pub = Nokogiri::XML("<publicObject/>").root
+      pub['id'] = pid
+      pub['published'] = Time.now.xmlschema
+      pub.add_child(self.datastreams['identityMetadata'].ng_xml.root.clone)
+      pub.add_child(self.datastreams['contentMetadata'].public_xml.root.clone)
+      pub.add_child(self.datastreams['rightsMetadata'].ng_xml.root.clone)
+      rels = public_relationships.root
+      pub.add_child(rels.clone) unless rels.nil? # TODO: Should never be nil in practice; working around an ActiveFedora quirk for testing
+      pub.add_child(self.generate_dublin_core.root.clone)
+      Nokogiri::XML(pub.to_xml) { |x| x.noblanks }.to_xml { |config| config.no_declaration }
+    end
+
+    # Copies this object's public_xml to the Purl document cache if it is world discoverable
+    #  otherwise, it prunes the object's metadata from the document cache
+    def publish_metadata
+      rights = datastreams['rightsMetadata'].ng_xml.clone.remove_namespaces!
+      if(rights.at_xpath("//rightsMetadata/access[@type='discover']/machine/world"))
+        dc_xml = self.generate_dublin_core.to_xml {|config| config.no_declaration}
+        DigitalStacksService.transfer_to_document_store(pid, dc_xml, 'dc')
+        DigitalStacksService.transfer_to_document_store(pid, self.datastreams['identityMetadata'].to_xml, 'identityMetadata')
+        DigitalStacksService.transfer_to_document_store(pid, self.datastreams['contentMetadata'].to_xml, 'contentMetadata')
+        DigitalStacksService.transfer_to_document_store(pid, self.datastreams['rightsMetadata'].to_xml, 'rightsMetadata')
+        DigitalStacksService.transfer_to_document_store(pid, public_xml, 'public')
+        if self.metadata_format == 'mods'
+          DigitalStacksService.transfer_to_document_store(pid, self.add_collection_reference, 'mods')
+        end
+      else
+        # Clear out the document cache for this item
+        DigitalStacksService.prune_purl_dir pid
+      end
+    end
+    #call the dor services app to have it publish the metadata
+    def publish_metadata_remotely
+      dor_services = RestClient::Resource.new(Config.dor_services.url+"/objects/#{pid}/publish")
+      dor_services.post ''
+      dor_services.url
+    end
+  end
+
+end

data/lib/dor/models/set.rb

@@ -0,0 +1,12 @@
+module Dor
+  class Set < ::ActiveFedora::Base
+    include Identifiable
+    include Processable
+    include Governable
+    include Describable
+    include Publishable
+
+    has_many :members, :property => :is_member_of_collection, :inbound => true, :class_name => "ActiveFedora::Base"
+    has_object_type 'set'
+  end
+end

data/lib/dor/models/shelvable.rb

@@ -0,0 +1,27 @@
+require 'moab_stanford'
+
+module Dor
+  module Shelvable
+    extend ActiveSupport::Concern
+    include Itemizable
+
+    # Push file changes for shelve-able files into the stacks
+    def shelve
+      inventory_diff_xml = self.get_content_diff(:shelve)
+      inventory_diff = Moab::FileInventoryDifference.parse(inventory_diff_xml)
+      content_group_diff = inventory_diff.group_difference("content")
+      deltas = content_group_diff.file_deltas
+
+      if content_group_diff.rename_require_temp_files(deltas[:renamed])
+        triplets = content_group_diff.rename_tempfile_triplets(deltas[:renamed])
+        DigitalStacksService.rename_in_stacks self.pid, triplets.collect{|old,new,temp| [old,temp]}
+        DigitalStacksService.rename_in_stacks self.pid, triplets.collect{|old,new,temp| [temp,new]}
+      else
+        DigitalStacksService.rename_in_stacks self.pid, deltas[:renamed]
+      end
+      DigitalStacksService.shelve_to_stacks   self.pid, deltas[:modified] + deltas[:added] + deltas[:copyadded].collect{|old,new| new}
+      DigitalStacksService.remove_from_stacks self.pid, deltas[:deleted] + deltas[:copydeleted]
+    end
+
+  end
+end

data/lib/dor/models/upgradable.rb

@@ -0,0 +1,74 @@
+module Dor
+  module Upgradable
+
+    # The Upgradable mixin is responsible for making sure all DOR objects, 
+    # concerns, and datastreams know how to upgrade themselves to the latest 
+    # Chimera/DOR content standards.
+    #
+    # To add a new upgrade:
+    # 1) include Dor::Upgradable within whatever model, datastream, or mixin
+    #    you want to make upgradable.
+    # 2) Add a block to the model, datastream, or mixin as follows:
+    # 
+    #    on_upgrade(v) do |obj| 
+    #      # Do whatever needs to be done to obj
+    #    end
+    #
+    #    where v is the first released version of dor-services that will
+    #    include the upgrade.
+    #
+    # The block can either be defined on the model itself, or in a file
+    # in the dor/migrations/[model] directory. See Dor::Identifiable and
+    # dor/migrations/identifiable/* for an example.
+      
+    Callback = Struct.new :module, :version, :description, :block
+
+    mattr_accessor :__upgrade_callbacks
+    @@__upgrade_callbacks = []
+    def self.add_upgrade_callback c, v, d, &b
+      @@__upgrade_callbacks << Callback.new(c, Gem::Version.new(v), d, b)
+    end
+    
+    def self.run_upgrade_callbacks(obj, event_handler)
+      relevant = @@__upgrade_callbacks.select { |c| obj.is_a?(c.module) }.sort_by(&:version)
+      results = relevant.collect do |c| 
+        result = c.block.call(obj)
+        if result and event_handler.respond_to?(:add_event)
+          event_handler.add_event 'remediation', "#{c.module.name} #{c.version}", c.description
+        end
+        if result
+          Dor.logger.info "Applied remediation '#{c.description}' to '#{obj.pid}'"
+        end
+        result
+      end
+      results.any?
+    end
+    
+    def self.included(base)
+      base.instance_eval do
+        def self.on_upgrade version, desc, &block
+          Dor::Upgradable.add_upgrade_callback self, version, desc, &block
+        end
+        
+        Dir[File.join(Dor.root,'dor','migrations',base.name.split(/::/).last.underscore,'*.rb')].each do |migration|
+          require migration
+        end
+      end
+    end
+    
+    def upgrade!
+      results = [Dor::Upgradable.run_upgrade_callbacks(self, self)]
+      if self.respond_to?(:datastreams)
+        self.datastreams.each_pair do |dsid, ds|
+          results << Dor::Upgradable.run_upgrade_callbacks(ds, self) unless ds.new?
+        end
+      end
+
+      if results.any?
+        self.save
+      else
+        false
+      end
+    end
+  end
+end

data/lib/dor/models/versionable.rb

@@ -0,0 +1,94 @@
+module Dor
+  module Versionable
+    extend ActiveSupport::Concern
+    include Processable
+    include Upgradable
+
+    included do
+      has_metadata :name => 'versionMetadata', :type => Dor::VersionMetadataDS, :label => 'Version Metadata', :autocreate => true
+    end
+
+    # Increments the version number and initializes versioningWF for the object
+    # @param [Hash] opts optional params
+    # @option opts [Boolean] :assume_accessioned If true, does not check whether object has been accessioned.
+    # @option opts [Boolean] :create_workflows_ds If false, initialize_workflow() will not initialize the workflows datastream.
+    # @raise [Dor::Exception] if the object hasn't been accessioned, or if a version is already opened
+    def open_new_version(opts = {})
+      # During local development, we need a way to open a new version
+      # even if the object has not been accessioned.
+      raise(Dor::Exception, 'Object net yet accessioned') unless
+        opts[:assume_accessioned] ||
+        Dor::WorkflowService.get_lifecycle('dor', pid, 'accessioned')
+
+      raise Dor::Exception, 'Object already opened for versioning' if(new_version_open?)
+      raise Dor::Exception, 'Object currently being accessioned' if(Dor::WorkflowService.get_active_lifecycle('dor', pid, 'submitted'))
+
+
+      ds = datastreams['versionMetadata']
+      ds.increment_version
+      ds.content = ds.ng_xml.to_s
+      ds.save unless self.new_object?
+
+      k = :create_workflows_ds
+      if opts.has_key?(k)
+        # During local development, Hydrus (or some other app running Fedora locally)
+        # does not want this call to initialize the workflows datastream.
+        initialize_workflow('versioningWF', 'dor', opts[k])
+      else
+        initialize_workflow('versioningWF')
+      end
+    end
+
+    def current_version
+      datastreams['versionMetadata'].current_version_id
+    end
+
+    # Sets versioningWF:submit-version to completed and initiates accessionWF for the object
+    # @param [Hash] opts optional params
+    # @option opts [String] :description describes the version change
+    # @option opts [Symbol] :significance which part of the version tag to increment
+    #  :major, :minor, :admin (see Dor::VersionTag#increment)
+    # @option opts [String] :version_num version number to archive rows with. Otherwise, current version is used
+    # @option opts [Boolean] :start_accesion set to true if you want accessioning to start (default), false otherwise
+    # @raise [Dor::Exception] if the object hasn't been opened for versioning, or if accessionWF has
+    #   already been instantiated or the current version is missing a tag or description
+    def close_version(opts={})
+      unless(opts.empty?)
+        datastreams['versionMetadata'].update_current_version opts
+        datastreams['versionMetadata'].save
+      end
+
+      raise Dor::Exception, 'latest version in versionMetadata requires tag and description before it can be closed' unless(datastreams['versionMetadata'].current_version_closeable?)
+      raise Dor::Exception, 'Trying to close version on an object not opened for versioning' unless(new_version_open?)
+      raise Dor::Exception, 'accessionWF already created for versioned object' if(Dor::WorkflowService.get_active_lifecycle('dor', pid, 'submitted'))
+
+      Dor::WorkflowService.update_workflow_status 'dor', pid, 'versioningWF', 'submit-version', 'completed'
+      # TODO setting start-accession to completed could happen later if we have a universal robot to kick of accessioning across workflows,
+      # or if there's a review step after versioning is closed
+      Dor::WorkflowService.update_workflow_status 'dor', pid, 'versioningWF', 'start-accession', 'completed'
+      Dor::WorkflowService.archive_workflow 'dor', pid, 'versioningWF', opts[:version_num]
+
+      initialize_workflow 'accessionWF' if(opts[:start_accession].nil? || opts[:start_accession])
+    end
+
+    # @return [Boolean] true if 'opened' lifecycle is active, false otherwise
+    def new_version_open?
+      return true if(Dor::WorkflowService.get_active_lifecycle('dor', pid, 'opened'))
+      false
+    end
+
+    # @return [Boolean] true if the object is in a state that allows it to be modified. States that will allow modification are: has not been submitted for accessioning, has an open version or has sdr-ingest set to hold
+    def allows_modification?
+      if Dor::WorkflowService.get_lifecycle('dor', pid, 'submitted' ) and not new_version_open? and not Dor::WorkflowService.get_workflow_status('dor', pid, 'accessionWF', 'sdr-ingest-transfer')=='hold'
+        false
+      else
+        true
+      end
+    end
+
+    # Following chart of processes on this consul page: https://consul.stanford.edu/display/chimera/Versioning+workflows
+    alias_method :start_version,  :open_new_version
+    alias_method :submit_version, :close_version
+
+  end
+end