curation_concerns 1.7.0.beta1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 976d4594c0d89e8f8fc0fb3eb2e3fda2bc0de0e7
-  data.tar.gz: 0bba18a25f0eb32c5998c071544accdd09bcebd0
+  metadata.gz: 5fce83d5072e8e270e130b70cbbcd172c4a67f8b
+  data.tar.gz: 810425e450dc9b3c74b34f8e2e5b5d792caad21c
 SHA512:
-  metadata.gz: 2edb7a435f0b294fa1018bca41904327219d0b75ddc8ed736b20851b5d57bce7142085241e9d73e2d4df6c2784fad14fbe8851ff4f8302040af7e1cd2fb4472b
-  data.tar.gz: 1b31bc0aefd9067b0874e1dd0ab3e383a2a4c5f8b6190a2d977892d17b78edc9acdea5f7a8b3795d087f75cbc23d6ec1b0810da1851ab6bee974c28463bbd5eb
+  metadata.gz: 464f2c154c361745c3fcba8eaac523c4ebee3d7a625163980c5754ac5c9f1f476fd8ccb813d3c7d39f42ab26fe96c5dfc72be5113ee0233f7397e73faaea1191
+  data.tar.gz: f477c89852669354e20fd1243788c7dec5263e12c0636e9869478317b82422bb4ecdcd7138c5ab74cfeb8ccf5d6978ff7cb91bc206cd964dfbaf28b359fbf5c0

data/app/controllers/concerns/curation_concerns/application_controller_behavior.rb

@@ -6,14 +6,8 @@ module CurationConcerns
 
     included do
       helper CurationConcerns::MainAppHelpers
-
-      rescue_from ActiveFedora::ObjectNotFoundError do |exception|
-        not_found_response(exception)
-      end
-
-      rescue_from Blacklight::Exceptions::InvalidSolrID do |exception|
-        not_found_response(exception)
-      end
+      rescue_from ActiveFedora::ObjectNotFoundError, with: :not_found_response
+      rescue_from Blacklight::Exceptions::InvalidSolrID, with: :not_found_response
     end
 
     def render_404

data/app/controllers/concerns/curation_concerns/collections_controller_behavior.rb

@@ -15,16 +15,7 @@ module CurationConcerns
       copy_blacklight_config_from(::CatalogController)
 
       # Catch permission errors
-      rescue_from Hydra::AccessDenied, CanCan::AccessDenied do |exception|
-        if exception.action == :edit
-          redirect_to(url_for(action: 'show'), alert: 'You do not have sufficient privileges to edit this document')
-        elsif current_user && current_user.persisted?
-          redirect_to root_url, alert: exception.message
-        else
-          session['user_return_to'] = request.url
-          redirect_to new_user_session_url, alert: exception.message
-        end
-      end
+      rescue_from Hydra::AccessDenied, CanCan::AccessDenied, with: :deny_collection_access
 
       # actions: audit, index, create, new, edit, show, update, destroy, permissions, citation
       before_action :authenticate_user!, except: [:show, :index]
@@ -51,11 +42,22 @@ module CurationConcerns
       # To build a query to find a list of collections
       self.list_search_builder_class = CurationConcerns::CollectionSearchBuilder
       # The search builder to find the collection
-      self.single_item_search_builder_class = CurationConcerns::WorkSearchBuilder
+      self.single_item_search_builder_class = CurationConcerns::SingleCollectionSearchBuilder
       # The search builder to find the collections' members
       self.member_search_builder_class = CurationConcerns::CollectionMemberSearchBuilder
     end
 
+    def deny_collection_access(exception)
+      if exception.action == :edit
+        redirect_to(url_for(action: 'show'), alert: 'You do not have sufficient privileges to edit this document')
+      elsif current_user && current_user.persisted?
+        redirect_to root_url, alert: exception.message
+      else
+        session['user_return_to'] = request.url
+        redirect_to new_user_session_url, alert: exception.message
+      end
+    end
+
     def index
       # run the solr query to find the collections
       query = list_search_builder.with(params).query
@@ -90,7 +92,6 @@ module CurationConcerns
 
     def after_create_error
       form
-
       respond_to do |format|
         format.html { render action: 'new' }
         format.json { render json: @collection.errors, status: :unprocessable_entity }
@@ -120,7 +121,6 @@ module CurationConcerns
     def after_update_error
       form
       query_collection_members
-
       respond_to do |format|
         format.html { render action: 'edit' }
         format.json { render json: @collection.errors, status: :unprocessable_entity }

data/app/controllers/concerns/curation_concerns/curation_concern_controller.rb

@@ -15,11 +15,13 @@ module CurationConcerns
       self.work_form_service = WorkFormService
       attr_accessor :curation_concern
       helper_method :curation_concern, :contextual_path
+
+      rescue_from WorkflowAuthorizationException, with: :render_unavailable
     end
 
     module ClassMethods
       def curation_concern_type=(curation_concern_type)
-        load_and_authorize_resource class: curation_concern_type, instance_name: :curation_concern, except: [:show, :file_manager]
+        load_and_authorize_resource class: curation_concern_type, instance_name: :curation_concern, except: [:show, :file_manager, :inspect_work]
         self._curation_concern_type = curation_concern_type
       end
 
@@ -105,6 +107,11 @@ module CurationConcerns
       presenter
     end
 
+    def inspect_work
+      raise Hydra::AccessDenied unless current_ability.admin?
+      presenter
+    end
+
     attr_writer :actor
 
     protected
@@ -193,10 +200,40 @@ module CurationConcerns
         search_result_document(params)
       end
 
+      # Only returns unsuppressed documents the user has read access to
       def search_result_document(search_params)
         _, document_list = search_results(search_params)
-        raise CanCan::AccessDenied.new(nil, :show) if document_list.empty?
-        document_list.first
+        return document_list.first unless document_list.empty?
+        document_not_found!
+      end
+
+      def document_not_found!
+        doc = SolrDocument.find(params[:id])
+        raise WorkflowAuthorizationException if doc.suppressed?
+        raise CanCan::AccessDenied.new(nil, :show)
+      end
+
+      def render_unavailable
+        message = I18n.t("curation_concerns.workflow.unauthorized")
+        respond_to do |wants|
+          wants.html do
+            flash[:notice] = message
+            render 'unavailable', status: :unauthorized
+          end
+          wants.json do
+            render plain: message, status: :unauthorized
+          end
+          additional_response_formats(wants)
+          wants.ttl do
+            render plain: message, status: :unauthorized
+          end
+          wants.jsonld do
+            render plain: message, status: :unauthorized
+          end
+          wants.nt do
+            render plain: message, status: :unauthorized
+          end
+        end
       end
   end
 end

data/app/controllers/concerns/curation_concerns/selects_collections.rb

@@ -9,6 +9,8 @@ module CurationConcerns::SelectsCollections
     end
   end
 
+  # @return [Hash{Symbol => Array[Symbol]}] bottom-up map of "what you need" to "what qualifies"
+  # @note i.e., requiring :read access is satisfied by either :read or :edit access
   def access_levels
     { read: [:read, :edit], edit: [:edit] }
   end

data/app/controllers/concerns/curation_concerns/single_use_links_controller_behavior.rb

@@ -8,13 +8,15 @@ module CurationConcerns
       before_action :authenticate_user!
       before_action :authorize_user!
       # Catch permission errors
-      rescue_from Hydra::AccessDenied, CanCan::AccessDenied do |exception|
-        if current_user && current_user.persisted?
-          redirect_to main_app.root_url, alert: "You do not have sufficient privileges to create links to this document"
-        else
-          session["user_return_to"] = request.url
-          redirect_to new_user_session_url, alert: exception.message
-        end
+      rescue_from Hydra::AccessDenied, CanCan::AccessDenied, with: :deny_link_access
+    end
+
+    def deny_link_access(exception)
+      if current_user && current_user.persisted?
+        redirect_to main_app.root_url, alert: "You do not have sufficient privileges to create links to this document"
+      else
+        session["user_return_to"] = request.url
+        redirect_to new_user_session_url, alert: exception.message
       end
     end
 

data/app/models/concerns/curation_concerns/solr_document_behavior.rb

@@ -56,6 +56,10 @@ module CurationConcerns
       hydra_model == ::Collection
     end
 
+    def suppressed?
+      first(Solrizer.solr_name('suppressed', stored_boolean_field))
+    end
+
     # Method to return the ActiveFedora model
     def hydra_model
       first(Solrizer.solr_name('has_model', :symbol)).constantize
@@ -181,5 +185,9 @@ module CurationConcerns
           Rails.logger.info "Unable to parse date: #{field.first.inspect} for #{self['id']}"
         end
       end
+
+      def stored_boolean_field
+        Solrizer::Descriptor.new(:boolean, :stored, :indexed)
+      end
   end
 end

data/app/models/concerns/curation_concerns/suppressible.rb

@@ -0,0 +1,31 @@
+module CurationConcerns
+  # A work should be able to be filtered out of search results if it's inactive
+  module Suppressible
+    extend ActiveSupport::Concern
+
+    included do
+      # This holds the workflow state
+      property :state, predicate: Vocab::FedoraResourceStatus.objState, multiple: false
+    end
+
+    ##
+    # Used to restrict visibility on search results for a work that is inactive. If the state is not set, the
+    # default behavior is to consider the work not to be suppressed.
+    #
+    # Override this method if you have some criteria by which records should not display in the search results.
+    def suppressed?
+      return false if state.nil?
+      # This is a clumsy check only needed under RDF < 2.0 where there
+      # is a bug with `AT::Resource#==`
+      if RDF::VERSION.to_s < '2.0'
+        return state.rdf_subject == Vocab::FedoraResourceStatus.inactive
+      end
+      state == Vocab::FedoraResourceStatus.inactive
+    end
+
+    def to_sipity_entity
+      raise "Can't create an entity until the model has been persisted" unless persisted?
+      @sipity_entity ||= Sipity::Entity.find_by(proxy_for_global_id: to_global_id.to_s)
+    end
+  end
+end

data/app/models/concerns/curation_concerns/work_behavior.rb

@@ -16,7 +16,7 @@ module CurationConcerns::WorkBehavior
   include Hydra::AccessControls::Embargoable
   include GlobalID::Identification
   include CurationConcerns::NestedWorks
-  include CurationConcerns::Publishable
+  include CurationConcerns::Suppressible
 
   included do
     property :owner, predicate: RDF::URI.new('http://opaquenamespace.org/ns/hydra/owner'), multiple: false

data/app/presenters/curation_concerns/inspect_work_presenter.rb

@@ -0,0 +1,52 @@
+module CurationConcerns
+  class InspectWorkPresenter
+    def initialize(solr_document, current_ability)
+      @solr_document = solr_document
+      @current_ability = current_ability
+    end
+    attr_reader :solr_document, :current_ability
+
+    def workflow
+      return { comments: [], roles: [] } unless sipity_entity
+      {
+        entity_id: sipity_entity.id,
+        proxy_for: sipity_entity.proxy_for_global_id,
+        workflow_id: sipity_entity.workflow_id,
+        workflow_name: sipity_entity.workflow_name,
+        state_id: sipity_entity.workflow_state_id,
+        state_name: sipity_entity.workflow_state_name,
+        comments: workflow_comments,
+        roles: sipity_entity_roles
+      }
+    end
+
+    def solr
+      @solr_document.inspect
+    end
+
+    private
+
+      def sipity_entity
+        @sipity_entity ||= PowerConverter.convert(solr_document, to: :sipity_entity)
+      end
+
+      def sipity_entity_roles
+        roles = CurationConcerns::Workflow::PermissionQuery.scope_roles_associated_with_the_given_entity(entity: solr_document)
+        roles.map do |role|
+          { id: role.id, name: role.name, description: role.description, users: sipity_entity_role_users(role) }
+        end
+      end
+
+      def sipity_entity_role_users(role)
+        users = CurationConcerns::Workflow::PermissionQuery.scope_users_for_entity_and_roles(entity: sipity_entity, roles: role)
+        users.map(&:user_key)
+      end
+
+      def workflow_comments
+        return [] unless sipity_entity && sipity_entity.comments.count > 0
+        sipity_entity.comments.map do |comment|
+          { comment: comment.comment, created_at: comment.created_at }
+        end
+      end
+  end
+end

data/app/presenters/curation_concerns/work_show_presenter.rb

@@ -50,6 +50,10 @@ module CurationConcerns
       @workflow ||= WorkflowPresenter.new(solr_document, current_ability)
     end
 
+    def inspect_work
+      @inspect_workflow ||= InspectWorkPresenter.new(solr_document, current_ability)
+    end
+
     # @return FileSetPresenter presenter for the representative FileSets
     def representative_presenter
       return nil if representative_id.blank?

data/app/search_builders/curation_concerns/README.md

@@ -0,0 +1,69 @@
+# Search Builders
+
+Building searches is core to any Blacklight app, and CurationConcerns is no exception.  
+This directory contains our Search Builders, so named because the design followed a builder pattern, meaning
+that when invoked to set values, methods return the object itself, so that invocations can be chained, like:
+
+```ruby
+builder = Blacklight::SearchBuilder.new(processor_chain, scope)
+            .rows(20)
+            .page(3)
+            .with(q: 'Abraham Lincoln')
+```
+
+However, at this level, many if not most of the additional methods do not follow this pattern.  
+Refer to the `Blacklight::SearchBuilder` class if you want to be certain.  That leads to the next topic...
+
+## Ancestry
+
+Most of the SearchBuilders have `::SearchBuilder` as a parent or ancestor.  `::SearchBuilder` does not exist in any repo: it is generated
+by Blacklight and modified by CurationConcerns.  Others descend from `Blacklight::SearchBuilder`, or various other relatives.  
+
+### ::SearchBuilder
+
+The generated parent class `SearchBuilder` descends from `Blacklight::SearchBuilder`.
+As modified by CurationConcerns' installer, it includes additional modules and overrides.  So if your SearchBuilder has `::SearchBuilder` as a parent class, you are getting:
+- [Blacklight::SearchBuilder](https://github.com/projectblacklight/blacklight/blob/master/lib/blacklight/search_builder.rb) grandparent class
+- [Blacklight::Solr::SearchBuilderBehavior](https://github.com/projectblacklight/blacklight/blob/master/lib/blacklight/solr/search_builder_behavior.rb) associated methods
+- [Hydra::AccessControlsEnforcement](https://github.com/projecthydra/hydra-head/blob/master/hydra-access-controls/lib/hydra/access_controls_enforcement.rb) module
+  -  [Blacklight::AccessControls::Enforcement](https://github.com/projectblacklight/blacklight-access_controls/blob/master/lib/blacklight/access_controls/enforcement.rb) ancestor of `Hydra::AccessControlsEnforcement`
+- [CurationConcerns::SearchFilters](https://github.com/projecthydra/curation_concerns/blob/master/app/search_builders/curation_concerns/search_filters.rb)  module that itself includes:
+  - [BlacklightAdvancedSearch::AdvancedSearchBuilder](https://github.com/projectblacklight/blacklight_advanced_search/blob/master/lib/blacklight_advanced_search/advanced_search_builder.rb) more magic for compound Boolean queries
+  - [CurationConcerns::FilterByType](https://github.com/projecthydra/curation_concerns/blob/master/app/search_builders/curation_concerns/filter_by_type.rb) Collection vs. Work filtering, specifically the `filter_models` method
+
+This is not a comprehensive list, but it is sufficient to trace some of the complexity of interaction between various layers.
+
+## Development: AKA Doing Something Useful
+
+Note, the `default_processor_chain` defined by `Blacklight::Solr::SearchBuilderBehavior` provides a way to extend functionality, but also many possible points of override (namely method names).  When you need to do something novel and additional, adding to the chain is completely reasonable.  For example:
+
+```ruby
+module MySearchBuilder
+  extend ActiveSupport::Concern
+
+  included do
+    self.default_processor_chain += [:special_filter]
+  end
+
+  def special_filter(solr_parameters)
+    solr_parameters[:fq] << "{!field f=some_field_ssim}#{...}"
+  end
+end
+```
+
+But to the extent that you are overriding (or undoing) something already done, `CurationConcerns::FileSetSearchBuilder` is a better example:
+
+```ruby
+module CurationConcerns
+  class FileSetSearchBuilder < ::SearchBuilder
+    include CurationConcerns::SingleResult
+
+    # This overrides the models in FilterByType
+    def models
+      [::FileSet]
+    end
+  end
+end
+```
+
+There is no point having the other `filter_models` methods apply `:fq`s that we then try to undo or overwrite.  In general, directly overwriting the whole `default_processor_chain` or solr parameters like `:fq` is less flexible than appending constraints sufficient for your use case.  In particular, you might find that you have overwritten components that implement access controls, thereby making your SearchBuilder less useful and less secure.  When in doubt, examine the actual solr queries produced.

data/app/search_builders/curation_concerns/collection_search_builder.rb

@@ -1,35 +1,53 @@
 module CurationConcerns
+  # Our parent class is the generated SearchBuilder descending from Blacklight::SearchBuilder
+  # It includes Blacklight::Solr::SearchBuilderBehavior, Hydra::AccessControlsEnforcement, CurationConcerns::SearchFilters
+  # @see https://github.com/projectblacklight/blacklight/blob/master/lib/blacklight/search_builder.rb Blacklight::SearchBuilder parent
+  # @see https://github.com/projectblacklight/blacklight/blob/master/lib/blacklight/solr/search_builder_behavior.rb Blacklight::Solr::SearchBuilderBehavior
+  # @see https://github.com/projecthydra/curation_concerns/blob/master/app/search_builders/curation_concerns/README.md SearchBuilders README
+  # @note the default_processor_chain defined by Blacklight::Solr::SearchBuilderBehavior provides many possible points of override
+  #
   class CollectionSearchBuilder < ::SearchBuilder
     include FilterByType
     # Defines which search_params_logic should be used when searching for Collections
-    self.default_processor_chain = [:default_solr_parameters, :add_query_to_solr,
-                                    :add_access_controls_to_solr_params, :filter_models,
-                                    :some_rows, :sort_by_title]
-
-    def some_rows(solr_parameters)
-      solr_parameters[:rows] = '100'
+    def initialize(context)
+      @rows = 100
+      super(context)
     end
 
-    # This overrides FilterByType and ensures we only match on collections.
-    def only_collections?
-      true
+    # @return [String] Solr field name indicating default sort order
+    def sort_field
+      Solrizer.solr_name('title', :sortable)
     end
 
-    # Sort results by title if no query was supplied.
-    # This overrides the default 'relevance' sort.
-    def sort_by_title(solr_parameters)
-      return if solr_parameters[:q]
-      solr_parameters[:sort] ||= "#{sort_field} asc"
+    # @return [Hash{Symbol => Array[Symbol]}] bottom-up map of "what you need" to "what qualifies"
+    # @note i.e., requiring :read access is satisfied by either :read or :edit access
+    def access_levels
+      { read: [:read, :edit], edit: [:edit] }
     end
 
-    attr_writer :discovery_perms
+    attr_writer :discovery_perms # TODO: remove this line
+    ## Overrides
 
+    # unprotect lib/blacklight/access_controls/enforcement.rb methods
+    # Remove these when https://github.com/projectblacklight/blacklight-access_controls/pull/23 is merged/released/required
     def discovery_permissions
       @discovery_perms || super
     end
 
-    def sort_field
-      Solrizer.solr_name('title', :sortable)
+    def discovery_permissions=(*args)
+      super
+    end
+
+    # This overrides the models in FilterByType
+    def models
+      collection_classes
+    end
+
+    # Sort results by title if no query was supplied.
+    # This overrides the default 'relevance' sort.
+    def add_sorting_to_solr(solr_parameters)
+      return if solr_parameters[:q]
+      solr_parameters[:sort] ||= "#{sort_field} asc"
     end
   end
 end

data/app/search_builders/curation_concerns/filter_suppressed.rb

@@ -0,0 +1,15 @@
+module CurationConcerns
+  # Injects a search builder filter to hide documents marked as suppressed
+  module FilterSuppressed
+    extend ActiveSupport::Concern
+
+    included do
+      self.default_processor_chain += [:only_active_works]
+    end
+
+    def only_active_works(solr_parameters)
+      solr_parameters[:fq] ||= []
+      solr_parameters[:fq] << '-suppressed_bsi:true'
+    end
+  end
+end

data/app/search_builders/curation_concerns/filter_suppressed_with_roles.rb

@@ -0,0 +1,30 @@
+module CurationConcerns
+  # Overrides FilterSuppressed filter to hide documents marked as
+  # suppressed when the current user is permitted to take no workflow
+  # actions for the work's current state
+  #
+  # Assumes presence of `blacklight_params[:id]` and a SolrDocument
+  # corresponding to that `:id` value
+  module FilterSuppressedWithRoles
+    extend ActiveSupport::Concern
+    include CurationConcerns::FilterSuppressed
+
+    # Skip the filter if the current user is permitted to take
+    # workflow actions on the work corresponding to the SolrDocument
+    # with id = `blacklight_params[:id]`
+    def only_active_works(solr_parameters)
+      return if user_has_active_workflow_role?
+      super
+    end
+
+    private
+
+      def current_work
+        SolrDocument.find(blacklight_params[:id])
+      end
+
+      def user_has_active_workflow_role?
+        CurationConcerns::Workflow::PermissionQuery.scope_permitted_workflow_actions_available_for_current_state(user: current_ability.current_user, entity: current_work).any?
+      end
+  end
+end

data/app/search_builders/curation_concerns/search_filters.rb

@@ -1,6 +1,7 @@
 module CurationConcerns::SearchFilters
   extend ActiveSupport::Concern
   include CurationConcerns::FilterByType
+  include CurationConcerns::FilterSuppressed
 
   # Override Hydra::AccessControlsEnforcement (or Hydra::PolicyAwareAccessControlsEnforcement)
   # Allows admin users to see everything (don't apply any gated_discovery_filters for those users)

data/app/search_builders/curation_concerns/single_collection_search_builder.rb

@@ -0,0 +1,5 @@
+module CurationConcerns
+  class SingleCollectionSearchBuilder < ::SearchBuilder
+    include CurationConcerns::SingleResult
+  end
+end

data/app/search_builders/curation_concerns/work_search_builder.rb

@@ -1,5 +1,6 @@
 module CurationConcerns
   class WorkSearchBuilder < ::SearchBuilder
     include CurationConcerns::SingleResult
+    include CurationConcerns::FilterSuppressedWithRoles
   end
 end

data/app/services/curation_concerns/actors/actor_factory.rb

@@ -14,7 +14,6 @@ module CurationConcerns
          AttachFilesActor,
          ApplyOrderActor,
          InterpretVisibilityActor,
-         GrantEditToDepositorActor,
          model_actor(curation_concern),
          InitializeWorkflowActor]
       end

data/app/services/curation_concerns/embargo_service.rb

@@ -30,19 +30,6 @@ module CurationConcerns
         def presenter_class
           CurationConcerns::EmbargoPresenter
         end
-
-        def presenters(builder)
-          response = repository.search(builder)
-          response.documents.map { |d| presenter_class.new(d) }
-        end
-
-        def repository
-          config.repository
-        end
-
-        def config
-          @config ||= ::CatalogController.new
-        end
     end
   end
 end

data/app/services/curation_concerns/workflow/action_taken_service.rb

@@ -2,46 +2,56 @@ module CurationConcerns
   module Workflow
     # Responsible for performing additional functions when the given criteria is met.
     class ActionTakenService
-      # For the given :entity and :action
+      # For the given target and :action
       # - Find the appropriate "function" to call
-      # - Then call that function. If the function returns a truthy value, then save the entity
-      def self.handle_action_taken(entity:, action:, comment:, user:)
-        new(entity: entity,
+      # - Then call that function. If the function returns a truthy value, then save the target
+      def self.handle_action_taken(target:, action:, comment:, user:)
+        new(target: target,
             action: action,
             comment: comment,
             user: user).call
       end
 
-      def initialize(entity:, action:, comment:, user:)
-        @entity = entity
+      def initialize(target:, action:, comment:, user:)
+        @target = target
         @action = action
         @comment = comment
         @user = user
       end
 
-      attr_reader :action, :entity, :comment, :user
+      attr_reader :action, :target, :comment, :user
 
+      # Calls all the workflow methods for this action. Stops calling methods if any return falsy
+      # @return [Boolean] true if all methods returned a truthy result
       def call
         return unless action.triggered_methods.any?
         success = action.triggered_methods.order(:weight).all? do |method|
-          process_action(method.service_name)
+          status = process_action(method.service_name)
+          Rails.logger.debug("Result of #{method.service_name} is #{status}")
+          status
         end
 
-        return entity.proxy_for.save if success
-        Rails.logger.error "Not all workflow methods were successful, so not saving (#{entity.id})"
+        return target.save if success
+        Rails.logger.error "Not all workflow methods were successful, so not saving (#{target.id})"
         false
       end
 
+      # @param service_name [String] the fully qualified class name to run the `call` method on
+      # @yieldparam status the result of calling the method
+      # @return the result of calling the method
       def process_action(service_name)
         service = resolve_service(service_name)
         return unless service
-        service.call(entity: entity,
-                     comment: comment,
-                     user: user)
+        result = service.call(target: target,
+                              comment: comment,
+                              user: user)
+        yield(result) if block_given?
+        result
       end
 
-      def resolve_service(service_name)
-        class_name = service_name.classify
+      # @param class_name [String] the fully qualified class name to run
+      # @return [Class, NilClass] return nil if unable to locate the class
+      def resolve_service(class_name)
         klass = begin
                   class_name.constantize
                 rescue NameError

data/app/services/curation_concerns/workflow/activate_object.rb

@@ -1,8 +1,15 @@
 module CurationConcerns
   module Workflow
     class ActivateObject
-      def self.call(entity:, **)
-        entity.proxy_for.state = Vocab::FedoraResourceStatus.active
+      ##
+      # This is a built in function for workflow, setting the `#state`
+      # of the target to the Fedora 'active' status URI
+      #
+      # @param target [#state] an instance of a model that includes `CurationConcerns::Suppressible`
+      #
+      # @return [RDF::Vocabulary::Term] the Fedora Resource Status 'active' term
+      def self.call(target:, **)
+        target.state = Vocab::FedoraResourceStatus.active
       end
     end
   end