hyrax 3.1.0 → 3.4.0

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

@@ -1,94 +1,222 @@
 # frozen_string_literal: true
 module Hyrax
-  # Responsible for creating an AdminSet and its corresponding data:
+  # Responsible for creating a Hyrax::AdministrativeSet and its corresponding data.
   #
   # * An associated permission template
   # * Available workflows
   # * An active workflow
   #
-  # @see AdminSet
+  # @see Hyrax::AdministrativeSet
   # @see Hyrax::PermissionTemplate
   # @see Sipity::Workflow
-  class AdminSetCreateService
-    # @api public
-    # Creates the default AdminSet and corresponding data
-    # @param admin_set_id [String] The default admin set ID
-    # @param title [Array<String>] The title of the default admin set
-    # @return [TrueClass]
-    # @see AdminSet
-    def self.create_default_admin_set(admin_set_id:, title:)
-      admin_set = AdminSet.new(id: admin_set_id, title: Array.wrap(title))
-      begin
-        new(admin_set: admin_set, creating_user: nil).create
-      rescue ActiveFedora::IllegalOperation
-        # It is possible that another thread created the AdminSet just before this method
-        # was called, so ActiveFedora will raise IllegalOperation. In this case we can safely
-        # ignore the error.
-        Rails.logger.error("AdminSet ID=#{AdminSet::DEFAULT_ID} may or may not have been created due to threading issues.")
+  class AdminSetCreateService # rubocop:disable Metrics/ClassLength
+    DEFAULT_ID = 'admin_set/default'
+    DEFAULT_TITLE = ['Default Admin Set'].freeze
+
+    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
+      # Creates the default Hyrax::AdministrativeSet and corresponding data
+      # @param admin_set_id [String] The default admin set ID
+      # @param title [Array<String>] The title of the default admin set
+      # @return [TrueClass]
+      # @see Hyrax::AdministrativeSet
+      # @deprecated
+      # TODO: When this deprecated method is removed, update private method
+      #       .create_default_admin_set! to remove the parameters.
+      def create_default_admin_set(admin_set_id: DEFAULT_ID, title: DEFAULT_TITLE)
+        Deprecation.warn("'##{__method__}' will be removed in Hyrax 4.0.  " \
+                         "Instead, use 'Hyrax::AdminSetCreateService.find_or_create_default_admin_set'.")
+        create_default_admin_set!(admin_set_id: admin_set_id, title: title).present?
+      rescue RuntimeError => _err
+        false
       end
-    end
 
-    # @api public
-    # Creates a non-default AdminSet and corresponding data
-    # @param admin_set [AdminSet] the admin set to operate on
-    # @param creating_user [User] the user who created the admin set
-    # @return [TrueClass, FalseClass] true if it was successful
-    # @see AdminSet
-    # @raise [RuntimeError] if you attempt to create a default admin set via this mechanism
-    def self.call(admin_set:, creating_user:, **kwargs)
-      raise "Use .create_default_admin_set to create a default admin set" if admin_set.default_set?
-      new(admin_set: admin_set, creating_user: creating_user, **kwargs).create
+      # @api public
+      # Finds the default AdministrativeSet if it exists; otherwise, creates it and corresponding data
+      # @return [Hyrax::AdministrativeSet] The default admin set.
+      # @see Hyrax::AdministrativeSet
+      # @raise [RuntimeError] if admin set cannot be persisted
+      def find_or_create_default_admin_set
+        find_default_admin_set || create_default_admin_set!
+      end
+
+      # @api public
+      # @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:)
+        return false if id.blank?
+        id.to_s == default_admin_set_id
+      end
+
+      # @api public
+      # Creates a non-default Hyrax::AdministrativeSet and corresponding data
+      # @param admin_set [Hyrax::AdministrativeSet | AdminSet] the admin set to operate on
+      # @param creating_user [User] the user who created the admin set
+      # @return [TrueClass, FalseClass] true if it was successful
+      # @see Hyrax::AdministrativeSet
+      # @raise [RuntimeError] if you attempt to create a default admin set via this mechanism
+      # @deprecated
+      def call(admin_set:, creating_user:, **kwargs)
+        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_resource(admin_set), creating_user: creating_user, **kwargs).present?
+      rescue RuntimeError => err
+        raise err if default_admin_set?(id: admin_set.id)
+        false
+      end
+
+      # @api public
+      # Creates a non-default Hyrax::AdministrativeSet and corresponding data
+      # @param admin_set [Hyrax::AdministrativeSet] the admin set to operate on
+      # @param creating_user [User] the user who created the admin set
+      # @return [Hyrax::AdministrativeSet] The fully created admin set.
+      # @see Hyrax::AdministrativeSet
+      # @raise [RuntimeError] if you attempt to create a default admin set via this mechanism
+      # @raise [RuntimeError] if admin set cannot be persisted
+      def call!(admin_set:, creating_user:, **kwargs)
+        raise "Use .find_or_create_default_admin_set to create a default admin set" if default_admin_set?(id: admin_set.id)
+        new(admin_set: admin_set, creating_user: creating_user, **kwargs).create!
+      end
+
+      private
+
+      # 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 = 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 [AdminSet] the admin set to operate on
+    # @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
 
     # Creates an admin set, setting the creator and the default access controls.
     # @return [TrueClass, FalseClass] true if it was successful
+    # @deprecated
     def create
+      Deprecation.warn("'##{__method__}' will be removed in Hyrax 4.0.  " \
+                         "Warning: This method may hide runtime errors.  " \
+                         "Instead, use 'Hyrax::AdminSetCreateService.create!'.  ")
+      create!.persisted?
+    rescue RuntimeError => _err
+      false
+    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 create!
       admin_set.creator = [creating_user.user_key] if creating_user
-      admin_set.save.tap do |result|
+      updated_admin_set = Hyrax.persister.save(resource: admin_set).tap do |result|
         if result
           ActiveRecord::Base.transaction do
-            permission_template = create_permission_template
+            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 admin_set.default_set?
+            create_default_access_for(permission_template: permission_template, workflow: workflow) if default_admin_set?
           end
         end
       end
+      Hyrax.publisher.publish('collection.metadata.updated', collection: updated_admin_set, user: creating_user)
+      updated_admin_set
     end
 
     private
 
-    def access_grants_attributes
-      [
-        { agent_type: 'group', agent_id: admin_group_name, access: Hyrax::PermissionTemplateAccess::MANAGE }
-      ].tap do |attribute_list|
-        # Grant manage access to the creating_user if it exists. Should exist for all but default Admin Set
-        attribute_list << { agent_type: 'user', agent_id: creating_user.user_key, access: Hyrax::PermissionTemplateAccess::MANAGE } if creating_user
-      end
+    def default_admin_set?
+      @default_admin_set
     end
 
     def admin_group_name
       ::Ability.admin_group_name
     end
 
-    ##
-    # @return [PermissionTemplate]
-    def create_permission_template
-      permission_template = PermissionTemplate.create!(source_id: admin_set.id, access_grants_attributes: access_grants_attributes)
-      permission_template.reset_access_controls_for(collection: admin_set)
-      permission_template
-    end
-
     def create_workflows_for(permission_template:)
       workflow_importer.call(permission_template: permission_template)
       grant_all_workflow_roles_to_creating_user_and_admins!(permission_template: permission_template)
@@ -121,7 +249,7 @@ module Hyrax
       end
     end
 
-    # Gives deposit access to registered users to default AdminSet
+    # Give registered users deposit access to default admin set
     def create_default_access_for(permission_template:, workflow:)
       permission_template.access_grants.create(agent_type: 'group', agent_id: ::Ability.registered_group_name, access: Hyrax::PermissionTemplateAccess::DEPOSIT)
       deposit = Sipity::Role[Hyrax::RoleRegistry::DEPOSITING]

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