dor-services 6.0.5 → 6.1.0

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

@@ -3,9 +3,11 @@
 module Dor
   module Versionable
     extend ActiveSupport::Concern
+    extend Deprecation
+    self.deprecation_horizon = 'dor-services version 7.0.0'
 
     included do
-      has_metadata :name => 'versionMetadata', :type => Dor::VersionMetadataDS, :label => 'Version Metadata', :autocreate => true
+      has_metadata name: 'versionMetadata', type: Dor::VersionMetadataDS, label: 'Version Metadata', autocreate: true
     end
 
     # Increments the version number and initializes versioningWF for the object
@@ -15,36 +17,12 @@ module Dor
     # @option opts [Hash] :vers_md_upd_info If present, used to add to the events datastream and set the desc and significance on the versionMetadata 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::Config.workflow.client.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::Config.workflow.client.get_active_lifecycle('dor', pid, 'submitted')
-
-      sdr_version = Sdr::Client.current_version pid
-
-      vmd_ds = datastreams['versionMetadata']
-      vmd_ds.sync_then_increment_version sdr_version
-      vmd_ds.save unless self.new_record?
-
-      k = :create_workflows_ds
-      if opts.key?(k)
-        # During local development, Hydrus (or another app w/ local Fedora) does not want to initialize workflows datastream.
-        create_workflow('versioningWF', opts[k])
-      else
-        create_workflow('versioningWF')
-      end
-
-      vmd_upd_info = opts[:vers_md_upd_info]
-      return unless vmd_upd_info
-
-      add_event('open', vmd_upd_info[:opening_user_name], "Version #{vmd_ds.current_version_id} opened")
-      vmd_ds.update_current_version({ :description => vmd_upd_info[:description], :significance => vmd_upd_info[:significance].to_sym })
-      save
+      VersionService.open(self, opts)
     end
+    deprecation_deprecate open_new_version: 'Use VersionService.open instead'
 
     def current_version
-      datastreams['versionMetadata'].current_version_id
+      versionMetadata.current_version_id
     end
 
     # Sets versioningWF:submit-version to completed and initiates accessionWF for the object
@@ -57,30 +35,22 @@ module Dor
     # @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::Config.workflow.client.get_active_lifecycle('dor', pid, 'submitted')
-
-      Dor::Config.workflow.client.close_version 'dor', pid, opts.fetch(:start_accession, true) # Default to creating accessionWF when calling close_version
+      VersionService.close(self, opts)
     end
+    deprecation_deprecate close_version: 'Use VersionService.close instead'
 
     # @return [Boolean] true if 'opened' lifecycle is active, false otherwise
     def new_version_open?
-      return true if Dor::Config.workflow.client.get_active_lifecycle('dor', pid, 'opened')
-
-      false
+      VersionService.new(self).open?
     end
+    deprecation_deprecate new_version_open?: 'Use VersionService.open? instead'
 
+    # This is used by Argo and the MergeService
     # @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::Config.workflow.client.get_lifecycle('dor', pid, 'submitted') &&
-         !new_version_open? &&
+         !VersionService.new(self).open? &&
          Dor::Config.workflow.client.get_workflow_status('dor', pid, 'accessionWF', 'sdr-ingest-transfer') != 'hold'
         false
       else
@@ -89,7 +59,14 @@ module Dor
     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
+    def start_version
+      open_new_version
+    end
+    deprecation_deprecate start_version: 'use VersionService.open'
+
+    def submit_version
+      close_version
+    end
+    deprecation_deprecate submit_version: 'use VersionService.close'
   end
 end

data/lib/dor/models/set.rb

@@ -4,7 +4,7 @@ module Dor
   class Set < Dor::Abstract
     include Publishable
 
-    has_many :members, :property => :is_member_of_collection, :class_name => 'ActiveFedora::Base'
+    has_many :members, property: :is_member_of_collection, class_name: 'ActiveFedora::Base'
     has_object_type 'set'
 
     self.resource_indexer = CompositeIndexer.new(

data/lib/dor/models/workflow_object.rb

@@ -8,7 +8,7 @@ module Dor
     @@repo_cache = {}
 
     has_object_type 'workflow'
-    has_metadata :name => 'workflowDefinition', :type => Dor::WorkflowDefinitionDs, :label => 'Workflow Definition'
+    has_metadata name: 'workflowDefinition', type: Dor::WorkflowDefinitionDs, label: 'Workflow Definition'
 
     self.resource_indexer = CompositeIndexer.new(
       DataIndexer,
@@ -53,7 +53,7 @@ module Dor
       datastreams['workflowDefinition'].initial_workflow
     end
 
-    alias_method :generate_intial_workflow, :generate_initial_workflow
+    alias generate_intial_workflow generate_initial_workflow
 
     # Searches DOR for the workflow definition object.  It then caches the workflow repository and xml
     # @param [String] name the name of the workflow

data/lib/dor/services/ability.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Dor
+  class Ability
+    class << self
+      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
+
+      private
+
+      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
+
+      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
+    end
+  end
+end

data/lib/dor/services/cleanup_reset_service.rb

@@ -19,9 +19,7 @@ module Dor
       last_version = druid_obj.current_version.to_i
 
       # if the current version is still open, avoid this versioned directory
-      if Dor::Config.workflow.client.get_lifecycle('dor', druid, 'accessioned').nil?
-        last_version -= 1
-      end
+      last_version -= 1 if Dor::Config.workflow.client.get_lifecycle('dor', druid, 'accessioned').nil?
       last_version
     end
 

data/lib/dor/services/create_workflow_service.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Dor
+  class CreateWorkflowService
+    # 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
+    #  It will set lane_id from the item's APO default workflow lane
+    # @param [String] name of the workflow to be initialized
+    # @param [Boolean] create_ds create a 'workflows' datastream in Fedora for the object
+    # @param [Integer] priority the workflow's priority level
+    def self.create_workflow(item, name:, create_ds: true, priority: 0)
+      new(item).create_workflow(name: name, create_ds: create_ds, priority: priority)
+    end
+
+    def initialize(item)
+      @item = item
+    end
+
+    def create_workflow(name:, create_ds: true, priority: 0)
+      priority = item.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),
+                                                  item.pid,
+                                                  name,
+                                                  Dor::WorkflowObject.initial_workflow(name),
+                                                  opts)
+      item.workflows.content(true) # refresh the copy of the workflows datastream
+    end
+
+    private
+
+    attr_reader :item
+    delegate :admin_policy_object, to: :item
+
+    # 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.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 lane unless lane.blank?
+
+      'default'
+    end
+  end
+end

data/lib/dor/services/creative_commons_license_service.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Dor
+  class CreativeCommonsLicenseService < Ontology
+    # these hashes map short ("machine") license codes to their corresponding URIs and human readable titles. they
+    # also allow for deprecated entries (via optional :deprecation_warning).  clients that use these maps are advised to
+    # only display undeprecated entries, except where a deprecated entry is already in use by an object.  e.g., an APO
+    # that already specifies "by_sa" for its default license code could continue displaying that in a list of license options
+    # for editing, preferably with the deprecation warning.  but other deprecated entries would be omitted in such a
+    # selectbox.
+    @data = {
+      'by' => { human_readable: 'Attribution 3.0 Unported',
+                uri: 'https://creativecommons.org/licenses/by/3.0/' },
+      'by-sa' => { human_readable: 'Attribution Share Alike 3.0 Unported',
+                   uri: 'https://creativecommons.org/licenses/by-sa/3.0/' },
+      'by_sa' => { human_readable: 'Attribution Share Alike 3.0 Unported',
+                   uri: 'https://creativecommons.org/licenses/by-sa/3.0/',
+                   deprecation_warning: 'license code "by_sa" was a typo in argo, prefer "by-sa"' },
+      'by-nd' => { human_readable: 'Attribution No Derivatives 3.0 Unported',
+                   uri: 'https://creativecommons.org/licenses/by-nd/3.0/' },
+      'by-nc' => { human_readable: 'Attribution Non-Commercial 3.0 Unported',
+                   uri: 'https://creativecommons.org/licenses/by-nc/3.0/' },
+      'by-nc-sa' => { human_readable: 'Attribution Non-Commercial Share Alike 3.0 Unported',
+                      uri: 'https://creativecommons.org/licenses/by-nc-sa/3.0/' },
+      'by-nc-nd' => { human_readable: 'Attribution Non-Commercial, No Derivatives 3.0 Unported',
+                      uri: 'https://creativecommons.org/licenses/by-nc-nd/3.0/' },
+      'pdm' => { human_readable: 'Public Domain Mark 1.0',
+                 uri: 'https://creativecommons.org/publicdomain/mark/1.0/' }
+    }.freeze
+  end
+end

data/lib/dor/services/datastream_builder.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Dor
+  # 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 class 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.
+  class DatastreamBuilder
+    # @param [ActiveFedora::Base] object The object that contains the datastream
+    # @param [ActiveFedora::Datastream] datastream The datastream object
+    # @param [Boolean] force Should we overwrite existing datastream?
+    # @param [Boolean] required If set to true, raise an error if we can't build the datastream
+    # @return [ActiveFedora::Datastream]
+    def initialize(object:, datastream:, force: false, required: false)
+      @object = object
+      @datastream = datastream
+      @force = force
+      @required = required
+      @filename = find_metadata_file
+    end
+
+    def build
+      # See if datastream exists as a file and if the file's timestamp is newer than datastream's timestamp.
+      if file_newer_than_datastream?
+        create_from_file(filename)
+      elsif force || empty_datastream?
+        create_default
+      end
+      # Check for success.
+      raise "Required datastream #{datastream_name} could not be populated!" if required && empty_datastream?
+    end
+
+    private
+
+    attr_reader :datastream, :force, :object, :required, :filename
+
+    def datastream_name
+      datastream.dsid
+    end
+
+    def file_newer_than_datastream?
+      filename && (!datastream_date || file_date > datastream_date)
+    end
+
+    def file_date
+      File.mtime(filename)
+    end
+
+    def datastream_date
+      datastream.createDate
+    end
+
+    def create_from_file(filename)
+      content = File.read(filename)
+      datastream.content = content
+      datastream.ng_xml = Nokogiri::XML(content) if datastream.respond_to?(:ng_xml)
+      datastream.save unless datastream.digital_object.new?
+    end
+
+    def create_default
+      meth = "build_#{datastream_name}_datastream".to_sym
+      return unless object.respond_to?(meth)
+
+      object.public_send(meth, datastream)
+      datastream.save unless datastream.digital_object.new?
+    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
+      druid = DruidTools::Druid.new(object.pid, Dor::Config.stacks.local_workspace_root)
+      druid.find_metadata("#{datastream_name}.xml")
+    end
+
+    def empty_datastream?
+      return true if datastream.new?
+
+      return datastream.content.to_s.empty? unless datastream.class.respond_to?(:xml_template)
+
+      datastream.content.to_s.empty? || EquivalentXml.equivalent?(datastream.content, datastream.class.xml_template)
+    end
+  end
+end

data/lib/dor/services/digital_stacks_service.rb

@@ -9,7 +9,7 @@ module Dor
     # @param [Pathname] stacks_object_pathname the stacks location of the digital object
     # @param [Moab::FileGroupDifference] content_diff the content file version differences report
     def self.remove_from_stacks(stacks_object_pathname, content_diff)
-      [:deleted, :copydeleted, :modified].each do |change_type|
+      %i[deleted copydeleted modified].each do |change_type|
         subset = content_diff.subset(change_type) # {Moab::FileGroupDifferenceSubset}
         subset.files.each do |moab_file| # {Moab::FileInstanceDifference}
           moab_signature = moab_file.signatures.first # {Moab::FileSignature}
@@ -82,11 +82,11 @@ module Dor
     def self.shelve_to_stacks(workspace_content_pathname, stacks_object_pathname, content_diff)
       return false if workspace_content_pathname.nil?
 
-      [:added, :copyadded, :modified].each do |change_type|
+      %i[added copyadded modified].each do |change_type|
         subset = content_diff.subset(change_type) # {Moab::FileGroupDifferenceSubset
         subset.files.each do |moab_file| # {Moab::FileInstanceDifference}
           moab_signature = moab_file.signatures.last # {Moab::FileSignature}
-          filename = (change_type == :modified) ? moab_file.basis_path : moab_file.other_path
+          filename = change_type == :modified ? moab_file.basis_path : moab_file.other_path
           workspace_pathname = workspace_content_pathname.join(filename)
           stacks_pathname = stacks_object_pathname.join(filename)
           copy_file(workspace_pathname, stacks_pathname, moab_signature)
@@ -115,29 +115,11 @@ module Dor
       false
     end
 
-    ### depricated ???
-
-    # Create a file inside the content directory under the stacks.local_document_cache_root
-    # @param [String] id The druid identifier for the object
-    # @param [String] content The contents of the file to be created
-    # @param [String] filename The name of the file to be created
-    # @return [void]
-    def self.transfer_to_document_store(id, content, filename)
-      druid = DruidTools::PurlDruid.new id, Config.stacks.local_document_cache_root
-      druid.content_dir # create the druid tree if it doesn't exist yet
-      File.open(File.join(druid.content_dir, filename), 'w') { |f| f.write content }
-    end
-
     # Assumes the digital stacks storage root is mounted to the local file system
     # TODO: since this is delegating to the Druid, this method may not be necessary
     def self.prune_stacks_dir(id)
       stacks_druid_tree = DruidTools::StacksDruid.new(id, Config.stacks.local_stacks_root)
       stacks_druid_tree.prune!
     end
-
-    def self.prune_purl_dir(id)
-      druid = DruidTools::PurlDruid.new(id, Dor::Config.stacks.local_document_cache_root)
-      druid.prune!
-    end
   end
 end