dor-services 6.0.5 → 6.1.0

data/lib/dor/models/concerns/governable.rb

@@ -5,29 +5,15 @@ module Dor
     extend ActiveSupport::Concern
 
     included do
-      belongs_to :admin_policy_object, :property => :is_governed_by, :class_name => 'Dor::AdminPolicyObject'
-      has_and_belongs_to_many :collections, :property => :is_member_of_collection, :class_name => 'Dor::Collection'
-      has_and_belongs_to_many :sets, :property => :is_member_of, :class_name => 'Dor::Collection'
+      belongs_to :admin_policy_object, property: :is_governed_by, class_name: 'Dor::AdminPolicyObject'
+      has_and_belongs_to_many :collections, property: :is_member_of_collection, class_name: 'Dor::Collection'
+      has_and_belongs_to_many :sets, property: :is_member_of, class_name: 'Dor::Collection'
     end
 
     def initiate_apo_workflow(name)
-      create_workflow(name, !self.new_record?)
-    end
-
-    # Returns the default lane_id from the item's APO.  Will return 'default' if the item does not have
-    #   and APO, or if the APO does not have a default_lane
-    # @return [String] the lane id
-    def default_workflow_lane
-      return 'default' if admin_policy_object.nil? # TODO: log warning?
-
-      admin_md = admin_policy_object.datastreams['administrativeMetadata']
-      return 'default' unless admin_md.respond_to?(:default_workflow_lane) # Some APOs don't have this datastream
-
-      lane = admin_md.default_workflow_lane
-      return 'default' if lane.blank?
-
-      lane
+      CreateWorkflowService.create_workflow(self, name: name, create_ds: !new_record?)
     end
+    deprecation_deprecate initiate_apo_workflow: 'Use Dor::CreateWorkflowService.create_workflow instead'
 
     def reset_to_apo_default
       rightsMetadata.content = admin_policy_object.rightsMetadata.ng_xml
@@ -39,7 +25,7 @@ module Dor
     end
 
     def unshelve_and_unpublish
-      if self.respond_to? :contentMetadata
+      if respond_to? :contentMetadata
         content_ds = datastreams['contentMetadata']
         unless content_ds.nil?
           content_ds.ng_xml.xpath('/contentMetadata/resource//file').each_with_index do |file_node, index|
@@ -82,7 +68,7 @@ module Dor
     end
 
     def rights
-      return nil unless self.respond_to? :rightsMetadata
+      return nil unless respond_to? :rightsMetadata
       return nil if rightsMetadata.nil?
 
       xml = rightsMetadata.ng_xml
@@ -99,72 +85,17 @@ module Dor
       end
     end
 
-    def groups_which_manage_item
-      ['dor-administrator', 'sdr-administrator', 'dor-apo-manager', 'dor-apo-depositor']
-    end
-
-    def groups_which_manage_desc_metadata
-      ['dor-administrator', 'sdr-administrator', 'dor-apo-manager', 'dor-apo-depositor', 'dor-apo-metadata']
-    end
-
-    def groups_which_manage_system_metadata
-      ['dor-administrator', 'sdr-administrator', 'dor-apo-manager', 'dor-apo-depositor']
-    end
+    delegate :can_manage_item?, :can_manage_desc_metadata?, :can_manage_system_metadata?,
+             :can_manage_content?, :can_manage_rights?, :can_manage_embargo?,
+             :can_view_content?, :can_view_metadata?, to: Dor::Ability
 
-    def groups_which_manage_content
-      ['dor-administrator', 'sdr-administrator', 'dor-apo-manager', 'dor-apo-depositor']
-    end
-
-    def groups_which_manage_rights
-      ['dor-administrator', 'sdr-administrator', 'dor-apo-manager', 'dor-apo-depositor']
-    end
-
-    def groups_which_manage_embargo
-      ['dor-administrator', 'sdr-administrator', 'dor-apo-manager', 'dor-apo-depositor']
-    end
-
-    def groups_which_view_content
-      ['dor-administrator', 'sdr-administrator', 'dor-apo-manager', 'dor-apo-depositor', 'dor-viewer', 'sdr-viewer']
-    end
-
-    def groups_which_view_metadata
-      ['dor-administrator', 'sdr-administrator', 'dor-apo-manager', 'dor-apo-depositor', 'dor-viewer', 'sdr-viewer']
-    end
-
-    def intersect(arr1, arr2)
-      (arr1 & arr2).length > 0
-    end
-
-    def can_manage_item?(roles)
-      intersect roles, groups_which_manage_item
-    end
-
-    def can_manage_desc_metadata?(roles)
-      intersect roles, groups_which_manage_desc_metadata
-    end
-
-    def can_manage_system_metadata?(roles)
-      intersect roles, groups_which_manage_system_metadata
-    end
-
-    def can_manage_content?(roles)
-      intersect roles, groups_which_manage_content
-    end
-
-    def can_manage_rights?(roles)
-      intersect roles, groups_which_manage_rights
-    end
-
-    def can_manage_embargo?(roles)
-      intersect roles, groups_which_manage_embargo
-    end
-
-    def can_view_content?(roles)
-      intersect roles, groups_which_view_content
-    end
-
-    def can_view_metadata?(roles)
-      intersect roles, groups_which_view_metadata
-    end
+    deprecation_deprecate can_manage_item?: 'Use Dor::Ability.can_manage_item? instead'
+    deprecation_deprecate can_manage_desc_metadata?: 'Use Dor::Ability.can_manage_desc_metadata? instead'
+    deprecation_deprecate can_manage_system_metadata?: 'Use Dor::Ability.can_manage_system_metadata? instead'
+    deprecation_deprecate can_manage_content?: 'Use Dor::Ability.can_manage_content? instead'
+    deprecation_deprecate can_manage_rights?: 'Use Dor::Ability.can_manage_rights? instead'
+    deprecation_deprecate can_manage_embargo?: 'Use Dor::Ability.can_manage_embargo? instead'
+    deprecation_deprecate can_view_content?: 'Use Dor::Ability.can_view_content? instead'
+    deprecation_deprecate can_view_metadata?: 'Use Dor::Ability.can_view_metadata? instead'
   end
 end

data/lib/dor/models/concerns/identifiable.rb

@@ -9,8 +9,8 @@ module Dor
     PREVIOUS_CATKEY_TYPE_ID = 'previous_catkey'
 
     included do
-      has_metadata :name => 'DC', :type => SimpleDublinCoreDs, :label => 'Dublin Core Record for self object'
-      has_metadata :name => 'identityMetadata', :type => Dor::IdentityMetadataDS, :label => 'Identity Metadata'
+      has_metadata name: 'DC', type: SimpleDublinCoreDs, label: 'Dublin Core Record for self object'
+      has_metadata name: 'identityMetadata', type: Dor::IdentityMetadataDS, label: 'Identity Metadata'
     end
 
     module ClassMethods
@@ -52,7 +52,7 @@ module Dor
     def source_id=(source_id)
       identityMetadata.sourceId = source_id
     end
-    alias_method :set_source_id, :source_id=
+    alias set_source_id source_id=
     deprecate set_source_id: 'Use source_id= instead'
 
     # Convenience method to get the current catkey
@@ -65,9 +65,8 @@ module Dor
     # @param  [String] catkey the new source identifier
     # @return [String] same value, as per Ruby assignment convention
     def catkey=(val)
-      if val != catkey && !catkey.blank? # if there was already a catkey in the record, store that in the "previous" spot (assuming there is no change)
-        identityMetadata.add_otherId("#{PREVIOUS_CATKEY_TYPE_ID}:#{catkey}")
-      end
+      # if there was already a catkey in the record, store that in the "previous" spot (assuming there is no change)
+      identityMetadata.add_otherId("#{PREVIOUS_CATKEY_TYPE_ID}:#{catkey}") if val != catkey && !catkey.blank?
 
       if val.blank? # if we are setting the catkey to blank, remove the node from XML
         remove_other_Id(CATKEY_TYPE_ID)
@@ -87,9 +86,7 @@ module Dor
     end
 
     def add_other_Id(type, val)
-      if identityMetadata.otherId(type).length > 0
-        raise 'There is an existing entry for ' + type + ', consider using update_other_Id().'
-      end
+      raise 'There is an existing entry for ' + type + ', consider using update_other_Id().' if identityMetadata.otherId(type).length > 0
 
       identityMetadata.add_otherId(type + ':' + val)
     end
@@ -110,79 +107,22 @@ module Dor
                       .any?
     end
 
-    # turns a tag string into an array with one element per tag part.
-    # split on ":", disregard leading and trailing whitespace on tokens.
-    def split_tag_to_arr(tag_str)
-      tag_str.split(':').map { |str| str.strip }
-    end
-
-    # turn a tag array back into a tag string with a standard format
-    def normalize_tag_arr(tag_arr)
-      tag_arr.join(' : ')
-    end
-
-    # take a tag string and return a normalized tag string
-    def normalize_tag(tag_str)
-      normalize_tag_arr(split_tag_to_arr(tag_str))
-    end
-
-    # take a proposed tag string and a list of the existing tags for the object being edited.  if
-    # the proposed tag is valid, return it in normalized form.  if not, raise an exception with an
-    # explanatory message.
-    def validate_and_normalize_tag(tag_str, existing_tag_list)
-      tag_arr = validate_tag_format(tag_str)
-
-      # note that the comparison for duplicate tags is case-insensitive, but we don't change case as part of the normalized version
-      # we return, because we want to preserve the user's intended case.
-      normalized_tag = normalize_tag_arr(tag_arr)
-      dupe_existing_tag = existing_tag_list.detect { |existing_tag| normalize_tag(existing_tag).casecmp(normalized_tag) == 0 }
-      if dupe_existing_tag
-        raise "An existing tag (#{dupe_existing_tag}) is the same, consider using update_tag?"
-      end
-
-      normalized_tag
-    end
-
-    # Ensure that an administrative tag meets the proper mininum format
-    # @param tag_str [String] the tag
-    # @return [Array] the tag split into an array via ':'
-    def validate_tag_format(tag_str)
-      tag_arr = split_tag_to_arr(tag_str)
-      if tag_arr.length < 2
-        raise ArgumentError, "Invalid tag structure: tag '#{tag_str}' must have at least 2 elements"
-      end
-      if tag_arr.detect { |str| str.empty? }
-        raise ArgumentError, "Invalid tag structure: tag '#{tag_str}' contains empty elements"
-      end
-
-      tag_arr
-    end
-
     # Add an administrative tag to an item, you will need to seperately save the item to write it to fedora
     # @param tag [string] The tag you wish to add
     def add_tag(tag)
-      identity_metadata_ds = identityMetadata
-      normalized_tag = validate_and_normalize_tag(tag, identity_metadata_ds.tags)
-      identity_metadata_ds.add_value(:tag, normalized_tag)
+      TagService.add(self, tag)
     end
+    deprecation_deprecate add_tag: 'Call TagService.add instead'
 
     def remove_tag(tag)
-      normtag = normalize_tag(tag)
-      identityMetadata.ng_xml.search('//tag')
-                      .select { |node| normalize_tag(node.content) == normtag }
-                      .each { identityMetadata.ng_xml_will_change! }
-                      .each(&:remove)
-                      .any?
+      TagService.remove(self, tag)
     end
+    deprecation_deprecate remove_tag: 'Call TagService.remove instead'
 
     def update_tag(old_tag, new_tag)
-      normtag = normalize_tag(old_tag)
-      identityMetadata.ng_xml.search('//tag')
-                      .select { |node| normalize_tag(node.content) == normtag }
-                      .each { identityMetadata.ng_xml_will_change! }
-                      .each { |node| node.content = normalize_tag(new_tag) }
-                      .any?
+      TagService.update(self, old_tag, new_tag)
     end
+    deprecation_deprecate update_tag: 'Call TagService.update instead'
 
     # a regex that can be used to identify the last part of a druid (e.g. oo000oo0001)
     # @return [Regex] a regular expression to identify the ID part of the druid
@@ -210,12 +150,12 @@ module Dor
       object_class = Dor.registered_classes[object_type]
 
       if object_class
-        self.instance_of?(object_class) ? self : self.adapt_to(object_class)
+        instance_of?(object_class) ? self : adapt_to(object_class)
       else
         if ActiveFedora::VERSION < '8'
           result = super
           if result.class == Dor::Abstract
-            self.adapt_to(Dor::Item)
+            adapt_to(Dor::Item)
           else
             result
           end
@@ -223,7 +163,7 @@ module Dor
           begin
             super
           rescue ActiveFedora::ModelNotAsserted
-            self.adapt_to(Dor::Item)
+            adapt_to(Dor::Item)
           end
         end
       end

data/lib/dor/models/concerns/itemizable.rb

@@ -6,23 +6,24 @@ require 'uri'
 module Dor
   module Itemizable
     extend ActiveSupport::Concern
+    extend Deprecation
+    self.deprecation_horizon = 'dor-services version 7.0.0'
 
     included do
-      has_metadata :name => 'contentMetadata', :type => Dor::ContentMetadataDS, :label => 'Content Metadata', :control_group => 'M'
+      has_metadata name: 'contentMetadata', type: Dor::ContentMetadataDS, label: 'Content Metadata', control_group: 'M'
     end
 
     DIFF_FILENAME = 'cm_inv_diff'
 
     # Deletes all cm_inv_diff files in the workspace for the Item
     def clear_diff_cache
-      if Dor::Config.stacks.local_workspace_root.nil?
-        raise ArgumentError, 'Missing Dor::Config.stacks.local_workspace_root'
-      end
+      raise ArgumentError, 'Missing Dor::Config.stacks.local_workspace_root' if Dor::Config.stacks.local_workspace_root.nil?
 
       druid = DruidTools::Druid.new(pid, Dor::Config.stacks.local_workspace_root)
       diff_pattern = File.join(druid.temp_dir, DIFF_FILENAME + '.*')
       FileUtils.rm_f Dir.glob(diff_pattern)
     end
+    deprecation_deprecate clear_diff_cache: 'No longer used by any DLSS code and will be removed without replacement'
 
     # Retrieves file difference manifest for contentMetadata from SDR
     #
@@ -30,15 +31,12 @@ module Dor
     # @param [String] version
     # @return [Moab::FileInventoryDifference] XML contents of cm_inv_diff manifest
     def get_content_diff(subset = :all, version = nil)
-      if Dor::Config.stacks.local_workspace_root.nil?
-        raise Dor::ParameterError, 'Missing Dor::Config.stacks.local_workspace_root'
-      end
+      raise Dor::ParameterError, 'Missing Dor::Config.stacks.local_workspace_root' if Dor::Config.stacks.local_workspace_root.nil?
 
-      if !respond_to?(:contentMetadata) || contentMetadata.nil?
-        raise Dor::Exception, 'Missing contentMetadata datastream'
-      end
+      raise Dor::Exception, 'Missing contentMetadata datastream' if !respond_to?(:contentMetadata) || contentMetadata.nil?
 
-      Sdr::Client.get_content_diff(pid, contentMetadata.content, subset, version)
+      Sdr::Client.get_content_diff(pid, contentMetadata.content, subset.to_s, version)
     end
+    deprecation_deprecate get_content_diff: 'Use Sdr::Client.get_content_diff instead'
   end
 end

data/lib/dor/models/concerns/preservable.rb

@@ -8,6 +8,8 @@ module Dor
       has_metadata name: 'provenanceMetadata', type: ProvenanceMetadataDS, label: 'Provenance Metadata'
     end
 
+    # This is invoked by Robots::DorRepo::Accession::ProvenanceMetadata in common-accessioning
+    # as well as Argo's ItemsController#fix_missing_provenance
     def build_provenanceMetadata_datastream(workflow_id, event_text)
       workflow_provenance = create_workflow_provenance(workflow_id, event_text)
       ds = datastreams['provenanceMetadata']
@@ -20,6 +22,8 @@ module Dor
       SdrIngestService.transfer(self, agreement_id)
     end
 
+    private
+
     # @return [Nokogiri::Document]
     def create_workflow_provenance(workflow_id, event_text)
       builder = Nokogiri::XML::Builder.new do |xml|

data/lib/dor/models/concerns/processable.rb

@@ -5,6 +5,8 @@ require 'equivalent-xml'
 module Dor
   module Processable
     extend ActiveSupport::Concern
+    extend Deprecation
+    self.deprecation_horizon = 'dor-services version 7.0.0'
 
     included do
       has_metadata name: 'workflows',
@@ -14,135 +16,54 @@ module Dor
                    autocreate: true
     end
 
-    # verbiage we want to use to describe an item when it has completed a particular step
-    STATUS_CODE_DISP_TXT = {
-      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'
-    }.freeze
-
-    # milestones from accessioning and the order they happen in
-    STEPS = {
-      'registered' => 1,
-      'submitted' => 2,
-      'described' => 3,
-      'published' => 4,
-      'deposited' => 5,
-      'accessioned' => 6,
-      'indexed' => 7,
-      'shelved' => 8,
-      'opened' => 9
-    }.freeze
-
-    def empty_datastream?(datastream)
-      return true if datastream.new?
-
-      if datastream.class.respond_to?(:xml_template)
-        datastream.content.to_s.empty? || EquivalentXml.equivalent?(datastream.content, datastream.class.xml_template)
-      else
-        datastream.content.to_s.empty?
-      end
-    end
-
-    # Tries to find a file for the datastream.
-    # @param [String] datastream name of a datastream
-    # @return [String, nil] path to datastream or nil
-    def find_metadata_file(datastream)
-      druid = DruidTools::Druid.new(pid, Dor::Config.stacks.local_workspace_root)
-      druid.find_metadata("#{datastream}.xml")
-    end
-
-    # Builds that datastream using the content of a file if such a file
-    # exists and is newer than the object's current datastream; otherwise,
+    # The ContentMetadata and DescMetadata robot are allowed to build the
+    # datastream by reading a file from the /dor/workspace that matches the
+    # datastream name. This allows assembly or pre-assembly to prebuild the
+    # datastreams from templates or using other means
+    # (like the assembly-objectfile gem) and then have those datastreams picked
+    # up and added to the object during accessionWF.
+    #
+    # This method builds that datastream using the content of a file if such a file
+    # exists and is newer than the object's current datastream (see above); otherwise,
     # builds the datastream by calling build_fooMetadata_datastream.
     # @param [String] datastream name of a datastream (e.g. "fooMetadata")
     # @param [Boolean] force overwrite existing datastream
     # @param [Boolean] is_required
-    # @return [SomeDatastream]
+    # @return [ActiveFedora::Datastream]
     def build_datastream(datastream, force = false, is_required = false)
-      # See if datastream exists as a file and if the file's timestamp is newer than 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 || empty_datastream?(ds)
-        meth = "build_#{datastream}_datastream".to_sym
-        if respond_to?(meth)
-          send(meth, ds)
-          ds.save unless ds.digital_object.new?
-        end
-      end
-      # Check for success.
-      raise "Required datastream #{datastream} could not be populated!" if is_required && empty_datastream?(ds)
+      ds = datastreams[datastream]
+      builder = Dor::DatastreamBuilder.new(object: self,
+                                           datastream: ds,
+                                           force: force,
+                                           required: is_required)
+      builder.build
 
       ds
     end
+    deprecation_deprecate build_datastream: 'Use Dor::DatastreamBuilder instead'
 
     def cleanup
       CleanupService.cleanup(self)
     end
-
-    def milestones
-      @milestones ||= Dor::Config.workflow.client.get_milestones('dor', pid)
-    end
+    deprecation_deprecate cleanup: 'Use CleanupService.cleanup instead'
 
     # @return [Hash{Symbol => Object}] including :current_version, :status_code and :status_time
     def status_info
-      current_version = '1'
-      begin
-        current_version = versionMetadata.current_version_id
-      rescue
-      end
-
-      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]) && (m[:version].nil? || m[:version] == current_version)
-          current_milestones << m unless m[:milestone] == 'registered' && current_version.to_i > 1
-        end
-      end
-
-      status_code = 0
-      status_time = nil
-      # 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|
-        m_name = m[:milestone]
-        m_time = m[:at].utc.xmlschema
-        next unless STEPS.keys.include?(m_name) && (!status_time || m_time > status_time)
-
-        status_code = STEPS[m_name]
-        status_time = m_time
-      end
-
-      { :current_version => current_version, :status_code => status_code, :status_time => status_time }
+      StatusService.status_info(self)
     end
+    deprecation_deprecate status_info: 'Use StatusService.status_info instead'
 
     # @param [Boolean] include_time
     # @return [String] single composed status from status_info
     def status(include_time = false)
-      status_info_hash = status_info
-      current_version = status_info_hash[:current_version]
-      status_code = status_info_hash[:status_code]
-      status_time = status_info_hash[:status_time]
+      StatusService.status(self, include_time)
+    end
+    deprecation_deprecate status: 'Use StatusService.status instead'
 
-      # use the translation table to get the appropriate verbage for the latest step
-      result = "v#{current_version} #{STATUS_CODE_DISP_TXT[status_code]}"
-      result += " #{format_date(status_time)}" if include_time
-      result
+    def milestones
+      StatusService.new(self).milestones
     end
+    deprecation_deprecate status_info: 'Use StatusService#milestones instead'
 
     # 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
@@ -151,33 +72,13 @@ module Dor
     # @param [Boolean] create_ds create a 'workflows' datastream in Fedora for the object
     # @param [Integer] priority the workflow's priority level
     def create_workflow(name, create_ds = true, priority = 0)
-      priority = workflows.current_priority if priority == 0
-      opts = { :create_ds => create_ds, :lane_id => default_workflow_lane }
-      opts[:priority] = priority if priority > 0
-      Dor::Config.workflow.client.create_workflow(Dor::WorkflowObject.initial_repo(name), pid, name, Dor::WorkflowObject.initial_workflow(name), opts)
-      workflows.content(true) # refresh the copy of the workflows datastream
+      CreateWorkflowService.create_workflow(self, name: name, create_ds: create_ds, priority: priority)
     end
+    deprecation_deprecate create_workflow: 'Use CreateWorkflowService.create_workflow'
 
     def initialize_workflow(name, create_ds = true, priority = 0)
       warn 'WARNING: initialize_workflow is deprecated, use create_workflow instead'
       create_workflow(name, create_ds, priority)
     end
-
-    private
-
-    # handles formating utc date/time to human readable
-    # XXX: bad form to hardcode TZ here.  Code smell abounds.
-    def format_date(datetime)
-      d =
-        if datetime.is_a?(Time)
-          datetime
-        else
-          DateTime.parse(datetime).in_time_zone(ActiveSupport::TimeZone.new('Pacific Time (US & Canada)'))
-        end
-      I18n.l(d).strftime('%Y-%m-%d %I:%M%p')
-    rescue
-      d = datetime.is_a?(Time) ? datetime : Time.parse(datetime.to_s)
-      d.strftime('%Y-%m-%d %I:%M%p')
-    end
   end
 end