hyrax 3.2.0 → 3.4.1

data/app/search_builders/hyrax/dashboard/managed_search_filters.rb

@@ -11,15 +11,55 @@ module Hyrax
 
       # Override to exclude 'public' and 'registered' groups from read access.
       def apply_group_permissions(permission_types, ability = current_ability)
+        search_terms = add_managing_role_search_filter(ability: ability)
         groups = ability.user_groups
-        return [] if groups.empty?
-        permission_types.map do |type|
+        return search_terms if groups.empty?
+        permission_types.each do |type|
           field = solr_field_for(type, 'group')
-          user_groups = type == 'read' ? groups - [::Ability.public_group_name, ::Ability.registered_group_name] : groups
+          delete_groups = [::Ability.public_group_name, ::Ability.registered_group_name]
+          user_groups = type == 'read' ? groups - delete_groups : groups
           next if user_groups.empty?
-          "({!terms f=#{field}}#{user_groups.join(',')})" # parens required to properly OR the clauses together.
+          # parens required to properly OR the clauses together:
+          search_terms << "({!terms f=#{field}}#{user_groups.join(',')})"
         end
+        search_terms
       end
+
+      # Look for a user's managing role and add filters for all admin sets that have permission
+      # templates that include managing roles.
+      #
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def add_managing_role_search_filter(ability:, search_terms: [])
+        search_terms ||= []
+        # Look for managing role assignement
+        managing_role = Sipity::Role.find_by(name: Hyrax::RoleRegistry::MANAGING)
+        return search_terms if managing_role.blank?
+        agent = ability.current_user.to_sipity_agent
+        return search_terms if agent.workflow_responsibilities.blank?
+        managing_workflow_roles = []
+        agent.workflow_responsibilities.each do |workflow_responsibility|
+          wfr = Sipity::WorkflowRole.find_by(id: workflow_responsibility.workflow_role_id)
+          managing_workflow_roles << wfr if wfr.role_id == managing_role.id
+        end
+        return search_terms if managing_workflow_roles.empty?
+        # if the user has managing responsibilties, then look up the associated admin set ids
+        admin_set_ids = managing_workflow_roles.map do |wfr|
+          wf = Sipity::Workflow.find_by(id: wfr.workflow_id)
+          pt = Hyrax::PermissionTemplate.find_by(id: wf.permission_template_id)
+          pt.source_id
+        end
+        admin_set_ids.uniq!
+        # create search terms for works that are in managed admin sets
+        admin_set_ids.each do |id|
+          search_terms << "isPartOf_ssim:#{id}"
+        end
+        search_terms
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
     end
   end
 end

data/app/search_builders/hyrax/dashboard/nested_collections_search_builder.rb

@@ -37,7 +37,7 @@ module Hyrax
 
       def limit_ids
         # exclude current collection from returned list
-        limit_ids = [@collection.id]
+        limit_ids = [@collection.id.to_s]
         # cannot add a parent that is already a parent
         limit_ids += @nesting_attributes.parents if @nesting_attributes.parents && @nest_direction == :as_parent
         limit_ids
@@ -91,7 +91,7 @@ module Hyrax
 
       def exclude_if_already_parent
         # 2) Exclude any of Collection F's direct children
-        "-" + ActiveFedora::SolrQueryBuilder.construct_query(Samvera::NestingIndexer.configuration.solr_field_name_for_storing_parent_ids => @collection.id)
+        "-" + ActiveFedora::SolrQueryBuilder.construct_query(Samvera::NestingIndexer.configuration.solr_field_name_for_storing_parent_ids => @collection.id.to_s)
       end
     end
   end

data/app/search_builders/hyrax/my/collections_search_builder.rb

@@ -10,10 +10,7 @@ class Hyrax::My::CollectionsSearchBuilder < ::Hyrax::CollectionSearchBuilder
   # the current user has deposited
   # @param [Hash] solr_parameters
   def show_only_collections_deposited_by_current_user(solr_parameters)
-    clauses = [
-      ActiveFedora::SolrQueryBuilder.construct_query_for_rel(depositor: current_user_key),
-      ActiveFedora::SolrQueryBuilder.construct_query_for_rel(has_model: ::AdminSet.to_s, creator: current_user_key)
-    ]
+    clauses = [query_for_my_collections]
     solr_parameters[:fq] ||= []
     solr_parameters[:fq] += ["(#{clauses.join(' OR ')})"]
   end
@@ -21,6 +18,16 @@ class Hyrax::My::CollectionsSearchBuilder < ::Hyrax::CollectionSearchBuilder
   # This overrides the models in FilterByType
   # @return [Array<Class>] a list of classes to include
   def models
-    [::AdminSet, Hyrax::AdministrativeSet, Hyrax.config.collection_model.safe_constantize].compact
+    [::AdminSet, Hyrax::AdministrativeSet, ::Collection, Hyrax.config.collection_class].uniq.compact
+  end
+
+  private
+
+  def query_for_my_collections
+    query_service = Hyrax::SolrQueryService.new
+    query_service.with_field_pairs(field_pairs: { depositor_ssim: current_user_key }, type: 'terms')
+    query_service.with_field_pairs(field_pairs: { has_model_ssim: Hyrax.config.admin_set_model,
+                                                  creator_ssim: current_user_key }, type: 'terms')
+    query_service.build(join_with: 'OR')
   end
 end

data/app/services/hyrax/access_control_list.rb

@@ -174,6 +174,19 @@ module Hyrax
       true
     end
 
+    ##
+    # @api public
+    #
+    # Deletes the ACL for the resource
+    #
+    # @return [Boolean]
+    def destroy
+      persister.delete(resource: change_set.resource) if change_set.resource.persisted?
+      @change_set = nil
+
+      true
+    end
+
     private
 
     ##

data/app/services/hyrax/admin_set_create_service.rb

@@ -13,8 +13,9 @@ module Hyrax
     DEFAULT_ID = 'admin_set/default'
     DEFAULT_TITLE = ['Default Admin Set'].freeze
 
-    class_attribute :permissions_create_service
+    class_attribute :permissions_create_service, :default_admin_set_persister
     self.permissions_create_service = Hyrax::Collections::PermissionsCreateService
+    self.default_admin_set_persister = Hyrax::DefaultAdministrativeSet
 
     class << self
       # @api public
@@ -40,16 +41,15 @@ module Hyrax
       # @see Hyrax::AdministrativeSet
       # @raise [RuntimeError] if admin set cannot be persisted
       def find_or_create_default_admin_set
-        Hyrax.query_service.find_by(id: DEFAULT_ID)
-      rescue Valkyrie::Persistence::ObjectNotFoundError
-        create_default_admin_set!
+        find_default_admin_set || create_default_admin_set!
       end
 
       # @api public
-      # Is the admin_set the default Hyrax::AdministrativeSet
-      # @param id [#to_s] the id of the admin set to check
+      # @param id [#to_s] id of the admin set to check
+      # @return [Boolean] true if the id is for the default admin set; otherwise, false
       def default_admin_set?(id:)
-        id.to_s == DEFAULT_ID
+        return false if id.blank?
+        id.to_s == default_admin_set_id
       end
 
       # @api public
@@ -64,7 +64,7 @@ module Hyrax
         Deprecation.warn("'##{__method__}' will be removed in Hyrax 4.0.  " \
                          "Warning: This method may hide runtime errors.  " \
                          "Instead, use 'Hyrax::AdminSetCreateService.call!'.  ")
-        call!(admin_set: admin_set, creating_user: creating_user, **kwargs).present?
+        call!(admin_set: admin_set_resource(admin_set), creating_user: creating_user, **kwargs).present?
       rescue RuntimeError => err
         raise err if default_admin_set?(id: admin_set.id)
         false
@@ -88,18 +88,89 @@ module Hyrax
       # TODO: Parameters admin_set_id and title are defined to support .create_default_admin_set
       #       which is deprecated.  When it is removed, the parameters will no longer be required.
       def create_default_admin_set!(admin_set_id: DEFAULT_ID, title: DEFAULT_TITLE)
-        admin_set = Hyrax::AdministrativeSet.new(id: admin_set_id, title: Array.wrap(title))
-        new(admin_set: admin_set, creating_user: nil).create!
+        admin_set = create_admin_set(suggested_id: admin_set_id, title: title)
+        admin_set = new(admin_set: admin_set, creating_user: nil, default_admin_set: true).create!
+        default_admin_set_persister.update(default_admin_set_id: admin_set.id) if save_default?
+        admin_set
+      end
+
+      def save_default?
+        default_admin_set_persister.save_supported?
+      end
+
+      # Create an instance of `Hyrax::AdministrativeSet` with the suggested_id if supported.
+      # @return [Hyrax::AdministrativeSet] the new admin set
+      def create_admin_set(suggested_id:, title:)
+        if suggested_id.blank? || Hyrax.config.disable_wings || !Hyrax.metadata_adapter.is_a?(Wings::Valkyrie::MetadataAdapter)
+          # allow persister to assign id
+          Hyrax::AdministrativeSet.new(title: Array.wrap(title))
+        else
+          # use suggested_id
+          Hyrax::AdministrativeSet.new(id: suggested_id, title: Array.wrap(title))
+        end
+      end
+
+      # Find default AdministrativeSet using saved id
+      # @return [Hyrax::AdministrativeSet] the default admin set; nil if id not saved
+      # @raise [RuntimeError] if an admin set with the saved id doesn't exist
+      def find_default_admin_set
+        id = default_admin_set_id
+        return if id.blank?
+        Hyrax.query_service.find_by(id: id)
+      rescue Valkyrie::Persistence::ObjectNotFoundError
+        # The default ID is DEFAULT_ID when saving is not supported.  It is ok
+        # for this default id to be known but not found.  The admin set will be
+        # created with DEFAULT_ID by find_or_create_default_admin_set.
+        return unless save_default?
+
+        # id is saved in the default_admin_set_persister's table but doesn't exist
+        # NOTE: This is a corrupt state and shouldn't happen.  Manual intervention
+        #       is required to determine the correct value for the default admin
+        #       set id.  The saved id either needs to be updated to the correct
+        #       value or deleted to allow a new default admin set to be found
+        #       (i.e. an admin set with id DEFAULT_ID) or generated.
+        raise "Corrupt default admin set.  Persisted admin set with saved default_admin_set_id doesn't exist."
+      end
+
+      # Find default AdministrativeSet using DEFAULT_ID.
+      # @note Use of hardcoded ID is being deprecated as some Valkyrie adapters
+      #       do not support hardcoded IDs (e.g. postgres)
+      # @return [Hyrax::AdministrativeSet] the default admin set; nil if not found
+      def find_unsaved_default_admin_set
+        admin_set = Hyrax.query_service.find_by(id: DEFAULT_ID)
+        default_admin_set_persister.update(default_admin_set_id: DEFAULT_ID) if save_default?
+        admin_set
+      rescue Valkyrie::Persistence::ObjectNotFoundError
+        # a default admin set hasn't been created yet
+      end
+
+      # @return [String | nil] the default admin set id; returns nil if not set
+      # @note For general use, it is better to use `Hyrax.config.default_admin_set_id`.
+      def default_admin_set_id
+        return DEFAULT_ID unless save_default?
+        id = default_admin_set_persister.first&.default_admin_set_id
+        id = find_unsaved_default_admin_set&.id&.to_s if id.blank?
+        id
+      end
+
+      def admin_set_resource(admin_set)
+        case admin_set
+        when Valkyrie::Resource
+          admin_set
+        else
+          admin_set.valkyrie_resource
+        end
       end
     end
 
     # @param admin_set [Hyrax::AdministrativeSet | AdminSet] the admin set to operate on
     # @param creating_user [User] the user who created the admin set (if any).
     # @param workflow_importer [#call] imports the workflow
-    def initialize(admin_set:, creating_user:, workflow_importer: default_workflow_importer)
-      @admin_set = admin_set
+    def initialize(admin_set:, creating_user:, workflow_importer: default_workflow_importer, default_admin_set: false)
+      @admin_set = Hyrax::AdminSetCreateService.send(:admin_set_resource, admin_set)
       @creating_user = creating_user
       @workflow_importer = workflow_importer
+      @default_admin_set = default_admin_set
     end
 
     attr_reader :creating_user, :admin_set, :workflow_importer
@@ -120,31 +191,15 @@ module Hyrax
     # @return [Hyrax::AdministrativeSet] The fully created admin set.
     # @raise [RuntimeError] if admin set cannot be persisted
     def create!
-      admin_set.respond_to?(:valkyrie_resource) ? active_fedora_create! : valkyrie_create!
-    end
-
-    private
-
-    def default_admin_set?(id:)
-      self.class.default_admin_set?(id: id)
-    end
-
-    def admin_group_name
-      ::Ability.admin_group_name
-    end
-
-    # Creates an admin set, setting the creator and the default access controls.
-    # @return [Hyrax::AdministrativeSet] The fully created admin set.
-    # @raise [RuntimeError] if admin set cannot be persisted
-    def valkyrie_create!
       admin_set.creator = [creating_user.user_key] if creating_user
       updated_admin_set = Hyrax.persister.save(resource: admin_set).tap do |result|
         if result
           ActiveRecord::Base.transaction do
-            permission_template = permissions_create_service.create_default(collection: result,
+            permission_template = PermissionTemplate.find_by(source_id: result.id.to_s) ||
+                                  permissions_create_service.create_default(collection: result,
                                                                             creating_user: creating_user)
             workflow = create_workflows_for(permission_template: permission_template)
-            create_default_access_for(permission_template: permission_template, workflow: workflow) if default_admin_set?(id: admin_set.id)
+            create_default_access_for(permission_template: permission_template, workflow: workflow) if default_admin_set?
           end
         end
       end
@@ -152,23 +207,14 @@ module Hyrax
       updated_admin_set
     end
 
-    # Creates an admin set, setting the creator and the default access controls.
-    # @return [Hyrax::AdministrativeSet] The fully created admin set.
-    # @raise [RuntimeError] if admin set cannot be persisted
-    def active_fedora_create!
-      admin_set.creator = [creating_user.user_key] if creating_user
-      admin_set.save.tap do |result|
-        if result
-          ActiveRecord::Base.transaction do
-            permission_template = permissions_create_service.create_default(collection: admin_set,
-                                                                            creating_user: creating_user)
-            workflow = create_workflows_for(permission_template: permission_template)
-            create_default_access_for(permission_template: permission_template, workflow: workflow) if default_admin_set?(id: admin_set.id)
-          end
-        end
-      end
-      raise 'Admin set failed to persist.' unless admin_set.persisted?
-      admin_set.valkyrie_resource
+    private
+
+    def default_admin_set?
+      @default_admin_set
+    end
+
+    def admin_group_name
+      ::Ability.admin_group_name
     end
 
     def create_workflows_for(permission_template:)

data/app/services/hyrax/analytics/google/events.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module Hyrax
+  module Analytics
+    module Google
+      module Events
+        extend Legato::Model
+
+        metrics :total_events
+        dimensions :event_category, :event_action, :event_label
+
+        # Filter by event id
+        filter :for_id, &->(id) { matches(:eventLabel, id) }
+
+        # Filter by event action
+        filter(:work_view) { |_event_action| matches(:eventAction, 'work-view') }
+        filter(:work_in_collection_view) { |_event_action| matches(:eventAction, 'work-in-collection-view') }
+        filter(:collection_page_view) { |_event_action| matches(:eventAction, 'collection-page-view') }
+        filter(:file_set_download) { |_event_action| matches(:eventAction, 'file-set-download') }
+        filter(:work_in_collection_download) { |_event_action| matches(:eventAction, 'work-in-collection-download') }
+        filter(:file_set_in_work_download) { |_event_action| matches(:eventAction, 'file-set-in-work-download') }
+        filter(:collection_file_download) { |_event_action| matches(:eventAction, 'file-set-in-collection-download') }
+
+        def self.list(profile, start_date, end_date, action)
+          action = action.underscore
+          results = []
+          Events.results(profile,
+            start_date: start_date,
+            end_date: end_date,
+            sort: ['-totalEvents']).send(action).each do |result|
+              results.push([result.eventLabel, result.totalEvents.to_i])
+            end
+          results
+        end
+      end
+    end
+  end
+end

data/app/services/hyrax/analytics/google/events_daily.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module Hyrax
+  module Analytics
+    module Google
+      module EventsDaily
+        extend Legato::Model
+
+        metrics :total_events
+        dimensions :date, :event_category, :event_action
+
+        # Filter by event id
+        filter :for_id, &->(id) { matches(:eventLabel, id) }
+
+        # Filter by event action
+        filter(:work_view) { |_event_action| matches(:eventAction, 'work-view') }
+        filter(:work_in_collection_view) { |_event_action| matches(:eventAction, 'work-in-collection-view') }
+        filter(:collection_page_view) { |_event_action| matches(:eventAction, 'collection-page-view') }
+        filter(:file_set_download) { |_event_action| matches(:eventAction, 'file-set-download') }
+        filter(:work_in_collection_download) { |_event_action| matches(:eventAction, 'work-in-collection-download') }
+        filter(:file_set_in_work_download) { |_event_action| matches(:eventAction, 'file-set-in-work-download') }
+        filter(:collection_file_download) { |_event_action| matches(:eventAction, 'file-set-in-collection-download') }
+
+        # returns a daily number of events for a specific action
+        def self.summary(profile, start_date, end_date, action)
+          action = action.underscore
+          response = EventsDaily.results(profile,
+            start_date: start_date,
+            end_date: end_date).send(action)
+          dates = (start_date.to_date...end_date.to_date)
+          results_array(response, dates)
+        end
+
+        # returns a daily number of events for a specific action
+        def self.by_id(profile, start_date, end_date, id, action)
+          action = action.underscore
+          response = EventsDaily.results(profile,
+            start_date: start_date,
+            end_date: end_date).for_id(id).send(action)
+          dates = (start_date.to_date...end_date.to_date)
+          results_array(response, dates)
+        end
+
+        # def self.pageviews(profile, start_date, end_date, ref)
+        #   ref = ref.underscore
+        #   response = PageviewsDaily.results(profile,
+        #     start_date: start_date,
+        #     end_date: end_date).send(ref)
+        #   dates = (start_date.to_date...end_date.to_date)
+        #   results_array(response, dates)
+        # end
+
+        # takes all the dates in between the date range and generate an array [date, totalEvents]
+        def self.results_array(response, dates)
+          results = []
+          response.to_a.each do |result|
+            results.push([result.date.to_date, result.totalEvents.to_i])
+          end
+          new_results = []
+          dates.each do |date|
+            match = results.detect { |a, _b| a == date }
+            if match
+              new_results.push(match)
+            else
+              new_results.push([date, 0])
+            end
+          end
+          Hyrax::Analytics::Results.new(new_results)
+        end
+      end
+    end
+  end
+end

data/app/services/hyrax/analytics/google/visits.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+module Hyrax
+  module Analytics
+    module Google
+      module Visits
+        extend Legato::Model
+
+        dimensions :user_type
+        metrics :sessions
+
+        def self.results_array(response)
+          results = []
+          response.to_a.each do |result|
+            results.push([result.date.to_date, result.result.sessions.to_i])
+          end
+          Hyrax::Analytics::Results.new(results)
+        end
+
+        def self.new_visits(profile, start_date, end_date)
+          x = Visits.results(profile,
+            start_date: start_date,
+            end_date: end_date).to_a
+          x.first.sessions.to_i
+        end
+
+        def self.return_visits(profile, start_date, end_date)
+          x = Visits.results(profile,
+            start_date: start_date,
+            end_date: end_date).to_a
+          x.last.sessions.to_i
+        end
+
+        def self.total_visits(profile, start_date, end_date)
+          x = Visits.results(profile,
+            start_date: start_date,
+            end_date: end_date).to_a
+          new_visits = x.first.sessions.to_i
+          returning_visits = x.last.sessions.to_i
+          new_visits + returning_visits
+        end
+      end
+    end
+  end
+end

data/app/services/hyrax/analytics/google/visits_daily.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Hyrax
+  module Analytics
+    module Google
+      module VisitsDaily
+        extend Legato::Model
+
+        dimensions :date, :user_type
+        metrics :sessions
+
+        filter(:returning) { |_user_type| matches(:userType, 'Returning Visitor') }
+        filter(:new_visit) { |_user_type| matches(:userType, 'New Visitor') }
+
+        def self.new_visits(profile, start_date, end_date)
+          response = VisitsDaily.results(profile,
+            start_date: start_date,
+            end_date: end_date).new_visit.to_a
+          dates = (start_date.to_date...end_date.to_date)
+          results_array(response, dates)
+        end
+
+        def self.return_visits(profile, start_date, end_date)
+          response = VisitsDaily.results(profile,
+            start_date: start_date,
+            end_date: end_date).returning.to_a
+          dates = (start_date.to_date...end_date.to_date)
+          results_array(response, dates)
+        end
+
+        def self.results_array(response, dates)
+          results = []
+          response.to_a.each do |result|
+            results.push([result.date.to_date, result.sessions.to_i])
+          end
+          new_results = []
+          dates.each do |date|
+            match = results.detect { |a, _b| a == date }
+            if match
+              new_results.push(match)
+            else
+              new_results.push([date, 0])
+            end
+          end
+          Hyrax::Analytics::Results.new(new_results)
+        end
+      end
+    end
+  end
+end