hyrax 5.0.1 → 5.0.3

data/app/services/hyrax/analytics/ga4/base.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+module Hyrax
+  module Analytics
+    module Ga4
+      class Base
+        attr_reader :start_date, :end_date, :dimensions, :metrics
+
+        def initialize(start_date:,
+                       end_date:,
+                       dimensions: [],
+                       metrics: [])
+          @start_date = start_date.to_date
+          @end_date = end_date.to_date
+          @dimensions = dimensions
+          @metrics = metrics
+        end
+
+        def filters
+          @filters ||= {}
+        end
+
+        def filters=(value)
+          value
+        end
+
+        def add_filter(dimension:, values:)
+          # reset any cached results
+          @results = nil
+          filters[dimension] ||= []
+          filters[dimension] += values
+        end
+
+        def results
+          @results ||= Hyrax::Analytics.client.run_report(report).rows
+        end
+
+        def report
+          ::Google::Analytics::Data::V1beta::RunReportRequest.new(
+            property: Hyrax::Analytics.property,
+            metrics: metrics,
+            date_ranges: [{ start_date: start_date.iso8601, end_date: end_date.iso8601 }],
+            dimensions: dimensions,
+            dimension_filter: dimension_filter
+          )
+        end
+
+        def dimension_filter
+          return nil if filters.blank?
+          {
+            and_group: {
+              expressions: dimension_expressions
+            }
+          }
+        end
+
+        def dimension_expressions
+          filters.map do |dimension, values|
+            {
+              filter: {
+                field_name: dimension,
+                in_list_filter: { values: values.uniq }
+              }
+            }
+          end
+        end
+
+        def results_array(target_type = nil)
+          r = {}
+          # prefill dates so that all dates at least have 0
+          (start_date..end_date).each do |date|
+            r[date] = 0
+          end
+          results.each do |result|
+            date = unwrap_dimension(metric: result, dimension: 0)
+            type = unwrap_dimension(metric: result, dimension: 1)
+            next if date.nil? || type.nil?
+            next if target_type && type != target_type
+            date = date.to_date
+            r[date] += unwrap_metric(result)
+          end
+          Hyrax::Analytics::Results.new(r.to_a)
+        end
+
+        protected
+
+        def unwrap_dimension(metric:, dimension: 0)
+          metric.dimension_values[dimension]&.value
+        end
+
+        def unwrap_metric(metric)
+          metric.metric_values.first.value.to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Hyrax
+  module Analytics
+    module Ga4
+      class Events < Hyrax::Analytics::Ga4::Base
+        def initialize(start_date:,
+                       end_date:,
+                       dimensions: [{ name: 'eventName' }, { name: 'contentType' }, { name: 'contentId' }],
+                       metrics: [{ name: 'eventCount' }])
+          super
+        end
+
+        def self.list(start_date, end_date, action)
+          events = Events.new(start_date: start_date, end_date: end_date)
+          events.add_filter(dimension: 'eventName', values: [action])
+          events.top_result_array
+        end
+
+        def top_result_array
+          results.map { |r| [unwrap_dimension(metric: r, dimension: 2), unwrap_metric(r)] }.sort_by { |r| r[1] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module Hyrax
+  module Analytics
+    module Ga4
+      class EventsDaily < Hyrax::Analytics::Ga4::Base
+        def initialize(start_date:,
+                       end_date:,
+                       dimensions: [{ name: 'date' }, { name: 'eventName' }, { name: 'contentType' }, { name: 'contentId' }],
+                       metrics: [{ name: 'eventCount' }])
+          super
+        end
+
+        # returns a daily number of events for a specific action
+        def self.summary(start_date, end_date, action)
+          events_daily = EventsDaily.new(
+            start_date: start_date,
+            end_date: end_date
+          )
+          events_daily.add_filter(dimension: 'eventName', values: [action])
+          events_daily.results_array
+        end
+
+        # returns a daily number of events for a specific action
+        def self.by_id(start_date, end_date, id, action)
+          events_daily = EventsDaily.new(
+            start_date: start_date,
+            end_date: end_date
+          )
+          events_daily.add_filter(dimension: 'contentId', values: [id])
+          events_daily.add_filter(dimension: 'eventName', values: [action])
+          events_daily.results_array
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Hyrax
+  module Analytics
+    module Ga4
+      class Visits < Hyrax::Analytics::Ga4::Base
+        def initialize(start_date:, end_date:, dimensions: [{ name: 'newVsReturning' }], metrics: [{ name: 'sessions' }])
+          super
+        end
+
+        def new_visits
+          unwrap_metric(results.detect { |r| unwrap_dimension(metric: r) == 'new' })
+        end
+
+        def return_visits
+          unwrap_metric(results.detect { |r| unwrap_dimension(metric: r) == 'returning' })
+        end
+
+        def unknown_visits
+          empty_metrics = results.detect { |r| unwrap_dimension(metric: r) == '' }
+          not_set_metrics = results.detect { |r| unwrap_dimension(metric: r) == '(not set)' }
+          unknown = 0
+          unknown += unwrap_metric(empty_metrics) if empty_metrics.present?
+          unknown += unwrap_metric(not_set_metrics) if not_set_metrics.present?
+          unknown
+        end
+
+        def total_visits
+          new_visits + return_visits + unknown_visits
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Hyrax
+  module Analytics
+    module Ga4
+      class VisitsDaily < Hyrax::Analytics::Ga4::Base
+        def initialize(start_date:, end_date:, dimensions: [{ name: 'date' }, { name: 'newVsReturning' }], metrics: [{ name: 'sessions' }])
+          super
+        end
+
+        def new_visits
+          results_array('new')
+        end
+
+        def return_visits
+          results_array('returning')
+        end
+
+        def total_visits
+          results_array
+        end
+      end
+    end
+  end
+end

data/app/services/hyrax/analytics/ga4.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require 'oauth2'
+
+begin
+  require "google/analytics/data/v1beta"
+rescue LoadError
+  $stderr.puts "Unable to load 'google/analytics/data/v1beta'; this is okay unless you are trying to do analytics reporting."
+end
+
+module Hyrax
+  module Analytics
+    # rubocop:disable Metrics/ModuleLength
+    module Ga4
+      extend ActiveSupport::Concern
+      # rubocop:disable Metrics/BlockLength
+      class_methods do
+        # Loads configuration options from config/analytics.yml. You only need PRIVATE_KEY_PATH or
+        # PRIVATE_KEY_VALUE. VALUE takes precedence.
+        # Expected structure:
+        # `analytics:`
+        # `  ga4:`
+        #      analytics_id: <%= ENV['GOOGLE_ANALYTICS_ID'] %>
+        #      property_id: <%= ENV['GOOGLE_ANALYTICS_PROPERTY_ID'] %>
+        #      account_json: <%= ENV['GOOGLE_ACCOUNT_JSON'] %>
+        #      account_json_path: <%= ENV['GOOGLE_ACCOUNT_JSON_PATH'] %>
+        # @return [Config]
+        def config
+          @config ||= Config.load_from_yaml
+        end
+
+        class Config
+          def self.load_from_yaml
+            filename = Rails.root.join('config', 'analytics.yml')
+            yaml = YAML.safe_load(ERB.new(File.read(filename)).result)
+            unless yaml
+              Hyrax.logger.error("Unable to fetch any keys from #{filename}.")
+              return new({})
+            end
+            config = yaml.fetch('analytics')&.fetch('ga4', nil)
+            unless config
+              Deprecation.warn("Deprecated analytics configuration format found. Please update config/analytics.yml.")
+              config = yaml.fetch('analytics')
+              # this has to exist here with a placeholder so it can be set in the Hyrax initializer
+              # it is only for backward compatibility
+              config['analytics_id'] = '-'
+            end
+            new config
+          end
+
+          KEYS = %w[analytics_id property_id account_json account_json_path].freeze
+          REQUIRED_KEYS = %w[analytics_id property_id].freeze
+
+          def initialize(config)
+            @config = config
+          end
+
+          # @return [Boolean] are all the required values present?
+          def valid?
+            return false unless @config['account_json'].present? || @config['account_json_path'].present?
+
+            REQUIRED_KEYS.all? { |required| @config[required].present? }
+          end
+
+          def base64?(value)
+            value.is_a?(String) && Base64.strict_encode64(Base64.decode64(value)) == value
+          end
+
+          def account_json_string
+            return @account_json_string if @account_json_string
+            @account_json_string = if @config['account_json']
+                                     base64?(@config['account_json']) ? Base64.decode64(@config['account_json']) : @config['account_json']
+                                   else
+                                     File.read(@config['account_json_path'])
+                                   end
+          end
+
+          def account_info
+            @account_info ||= JSON.parse(account_json_string)
+          end
+
+          KEYS.each do |key|
+            # rubocop:disable Style/EvalWithLocation
+            class_eval %{ def #{key}; @config.fetch('#{key}'); end }
+            class_eval %{ def #{key}=(value); @config['#{key}'] = value; end }
+            # rubocop:enable Style/EvalWithLocation
+          end
+        end
+
+        def client
+          @client ||= ::Google::Analytics::Data::V1beta::AnalyticsData::Client.new do |conf|
+            conf.credentials = config.account_info
+          end
+        end
+
+        def property
+          "properties/#{config.property_id}"
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def to_date_range(period)
+          case period
+          when "day"
+            start_date = Time.zone.today
+            end_date = Time.zone.today
+          when "week"
+            start_date = Time.zone.today - 7.days
+            end_date = Time.zone.today
+          when "month"
+            start_date = Time.zone.today - 1.month
+            end_date = Time.zone.today
+          when "year"
+            start_date = Time.zone.today - 1.year
+            end_date = Time.zone.today
+          end
+
+          [start_date, end_date]
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def keyword_conversion(date)
+          case date
+          when "last12"
+            start_date = Time.zone.today - 11.months
+            end_date = Time.zone.today
+
+            [start_date, end_date]
+          else
+            date.split(",")
+          end
+        end
+
+        def date_period(period, date)
+          if period == "range"
+            date.split(",")
+          else
+            to_date_range(period)
+          end
+        end
+
+        # Configure analytics_start_date in ENV file
+        def default_date_range
+          "#{Hyrax.config.analytics_start_date},#{Time.zone.today + 1.day}"
+        end
+
+        # The number of events by day for an action
+        def daily_events(action, date = default_date_range)
+          date = date.split(",")
+          EventsDaily.summary(date[0], date[1], action)
+        end
+
+        # The number of events by day for an action and ID
+        def daily_events_for_id(id, action, date = default_date_range)
+          date = date.split(",")
+          EventsDaily.by_id(date[0], date[1], id, action)
+        end
+
+        # A list of events sorted by highest event count
+        def top_events(action, date = default_date_range)
+          date = date.split(",")
+          Events.list(date[0], date[1], action)
+        end
+
+        def unique_visitors(date = default_date_range); end
+
+        def unique_visitors_for_id(id, date = default_date_range); end
+
+        def new_visitors(period = 'month', date = default_date_range)
+          start_date, end_date = date_period(period, date)
+          Visits.new(start_date: start_date, end_date: end_date).new_visits
+        end
+
+        def new_visits_by_day(date = default_date_range, period = 'range')
+          start_date, end_date = date_period(period, date)
+          VisitsDaily.new(start_date: start_date, end_date: end_date).new_visits
+        end
+
+        def returning_visitors(period = 'month', date = default_date_range)
+          start_date, end_date = date_period(period, date)
+          Visits.new(start_date: start_date, end_date: end_date).return_visits
+        end
+
+        def returning_visits_by_day(date = default_date_range, period = 'range')
+          start_date, end_date = date_period(period, date)
+          VisitsDaily.new(start_date: start_date, end_date: end_date).return_visits
+        end
+
+        def total_visitors(period = 'month', date = default_date_range)
+          start_date, end_date = date_period(period, date)
+          Visits.new(start_date: start_date, end_date: end_date).total_visits
+        end
+
+        def page_statistics(start_date, object)
+          visits = VisitsDaily.new(start_date: start_date, end_date: Date.yesterday)
+          visits.add_filter(dimension: 'contentId', values: [object.id.to_s])
+          visits.total_visits
+        end
+      end
+      # rubocop:enable Metrics/BlockLength
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end
+# rubocop:enable Metrics/ModuleLength

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

@@ -55,7 +55,6 @@ module Hyrax
           # @return [Boolean] are all the required values present?
           def valid?
             return false unless @config['privkey_value'].present? || @config['privkey_path'].present?
-
             REQUIRED_KEYS.all? { |required| @config[required].present? }
           end
 
@@ -203,10 +202,25 @@ module Hyrax
           date = date_period(period, date)
           Visits.total_visits(profile, date[0], date[1])
         end
+
+        # Hyrax::Download is sent to Hyrax::Analytics.profile as #hyrax__download
+        # see Legato::ProfileMethods.method_name_from_klass
+        def page_statistics(start_date, object)
+          path = Rails.application.routes.url_helpers.polymorphic_path(object)
+          profile = Hyrax::Analytics.profile
+          unless profile
+            Hyrax.logger.error("Google Analytics profile has not been established. Unable to fetch statistics.")
+            return []
+          end
+          profile.hyrax__pageview(sort: 'date',
+                                  start_date: start_date,
+                                  end_date: Date.yesterday,
+                                  limit: 10_000)
+                 .for_path(path)
+        end
       end
       # rubocop:enable Metrics/BlockLength
     end
     # rubocop:enable Metrics/ModuleLength
   end
 end
-# rubocop:enable Metrics/ModuleLength

data/app/services/hyrax/analytics/matomo.rb

@@ -154,24 +154,37 @@ module Hyrax
           response["nb_visits_returning"].to_i + response["nb_visits_new"].to_i
         end
 
+        # TODO: implement
+        def page_statistics(_start_date, _object)
+          []
+        end
+
         def results_array(response, metric)
           results = []
           response.each do |result|
             if result[1].empty?
               results.push([result[0].to_date, 0])
             elsif result[1].is_a?(Array)
-              results.push([result[0].to_date, result[1].first[metric]])
+              results.push([result[0].to_date, result[1].first[metric].to_i])
             else
-              results.push([result[0].to_date, result[1][metric].presence || 0])
+              results.push([result[0].to_date, result[1][metric].presence.to_i])
             end
           end
           Hyrax::Analytics::Results.new(results)
         end
 
+        # If Matomo detects an error it will return a reponse with the key {"result":"error"}
+        # instead of returning an error status code. This method checks for that key.
+        def contains_matomo_error?(response)
+          response.is_a?(Hash) && response["result"] == "error"
+        end
+
         def get(params)
           response = Faraday.get(config.base_url, params)
           return [] if response.status != 200
-          JSON.parse(response.body)
+          api_response = JSON.parse(response.body)
+          return [] if contains_matomo_error?(api_response)
+          api_response
         end
 
         def api_params(method, period, date, additional_params = {})

data/app/services/hyrax/analytics/results.rb

@@ -74,6 +74,12 @@ module Hyrax
         fields = [:date, :pageviews]
         results.map { |row| fields.zip(row).to_h }
       end
+
+      def each
+        results.each do |result|
+          yield({ date: result[0], pageviews: result[1] })
+        end
+      end
     end
   end
 end

data/app/services/hyrax/custom_queries/find_access_control.rb

@@ -20,7 +20,7 @@ module Hyrax
           .find_inverse_references_by(resource: resource, property: :access_to)
           .find { |r| r.is_a?(Hyrax::AccessControl) } ||
           raise(Valkyrie::Persistence::ObjectNotFoundError)
-      rescue ArgumentError # some adapters raise ArgumentError for missing resources
+      rescue ArgumentError, Ldp::Gone, Ldp::NotFound # some adapters raise ArgumentError for missing resources
         raise(Valkyrie::Persistence::ObjectNotFoundError)
       end
     end

data/app/services/hyrax/custom_queries/find_by_date_range.rb

@@ -25,30 +25,13 @@ module Hyrax
       # @param models [Array]
       # @param start_datetime [DateTime]
       # @param end_datetime [DateTime]
+      # @return [Array<Hyrax::Resource>]
       def find_by_date_range(start_datetime:, end_datetime: nil, models: nil)
-        end_datetime = 1.second.since(Time.zone.now) if end_datetime.blank?
-        if models.present?
-          query_service.run_query(find_models_by_date_range_query, start_datetime.to_s, end_datetime.to_s, models)
-        else
-          query_service.run_query(find_by_date_range_query, start_datetime.to_s, end_datetime.to_s)
-        end
-      end
-
-      def find_models_by_date_range_query
-        <<-SQL
-          SELECT * FROM orm_resources
-          WHERE created_at >= ?
-          AND created_at <= ?
-          AND internal_resource IN (?);
-        SQL
-      end
-
-      def find_by_date_range_query
-        <<-SQL
-          SELECT * FROM orm_resources
-          WHERE created_at >= ?
-          AND created_at <= ?;
-        SQL
+        end_range = end_datetime.blank? ? '*' : end_datetime.utc.xmlschema
+        query = "system_create_dtsi:[#{start_datetime.utc.xmlschema} TO #{end_range}]"
+        query += " AND has_model_ssim: (#{models.map { |m| "\"#{m}\"" }.join(' OR ')})" unless models.empty?
+        ids = Hyrax::SolrService.query_result(query, fl: 'id')['response']['docs'].map { |doc| doc['id'] }
+        Hyrax.query_service.find_many_by_ids(ids: ids)
       end
     end
   end

data/app/services/hyrax/custom_queries/find_collections_by_type.rb

@@ -28,9 +28,9 @@ module Hyrax
       # @param global_id [GlobalID] global id for a Hyrax::CollectionType
       #
       # @return [Enumerable<PcdmCollection>]
-      def find_collections_by_type(global_id:)
+      def find_collections_by_type(global_id:, model: Hyrax.config.collection_class)
         query_service
-          .find_all_of_model(model: Hyrax.config.collection_model.safe_constantize)
+          .find_all_of_model(model:)
           .select { |collection| collection.collection_type_gid == global_id }
       end
     end

data/app/services/hyrax/custom_queries/find_count_by.rb

@@ -25,37 +25,9 @@ module Hyrax
       # @param hash [Hash] the hash representation of the query
       def find_count_by(hash = {}, models: nil)
         return nil if models.empty? && hash.blank?
-
-        internal_array = ["{ #{hash.map { |k, v| "\"#{k}\": #{v}" }.join(', ')} }"] if hash.present?
-        if models.empty?
-          query_service.orm_class.count_by_sql(([find_count_by_properties_query] + internal_array))
-        elsif hash.blank?
-          query_service.orm_class.count_by_sql([find_count_by_models_query] + [models])
-        else
-          query_service.orm_class.count_by_sql(([find_count_by_properties_and_models_query] + internal_array + [models]))
-        end
-      end
-
-      def find_count_by_properties_and_models_query
-        <<-SQL
-          SELECT count(*) FROM orm_resources
-          WHERE metadata @> ?
-          AND internal_resource IN (?);
-        SQL
-      end
-
-      def find_count_by_models_query
-        <<-SQL
-          SELECT count(*) FROM orm_resources
-          WHERE internal_resource IN (?);
-        SQL
-      end
-
-      def find_count_by_properties_query
-        <<-SQL
-          SELECT count(*) FROM orm_resources
-          WHERE metadata @> ?;
-        SQL
+        flat_hash = hash.map { |k, v| "#{k}: \"#{v}\"" }.join(' ')
+        flat_hash += " has_model_ssim: (#{models.map { |m| "\"#{m}\"" }.join(' OR ')})" unless models.empty?
+        Hyrax::SolrService.count(flat_hash)
       end
     end
   end

data/app/services/hyrax/custom_queries/find_file_metadata.rb

@@ -31,7 +31,7 @@ module Hyrax
         result = query_service.find_by(id: id)
         unless result.is_a? Hyrax::FileMetadata
           raise ::Valkyrie::Persistence::ObjectNotFoundError,
-                "Result type #{result.internal_resource} for id #{id} is not a `Hyrax::FileMetadata`"
+                "Result type #{result&.internal_resource} for id #{id} is not a `Hyrax::FileMetadata`"
         end
         result
       end
@@ -44,7 +44,7 @@ module Hyrax
         result = query_service.find_by_alternate_identifier(alternate_identifier: alternate_identifier)
         unless result.is_a? Hyrax::FileMetadata
           raise ::Valkyrie::Persistence::ObjectNotFoundError,
-                "Result type #{result.internal_resource} for alternate_identifier #{alternate_identifier} is not a `Hyrax::FileMetadata`"
+                "Result type #{result&.internal_resource} for alternate_identifier #{alternate_identifier} is not a `Hyrax::FileMetadata`"
         end
         result
       end

data/app/services/hyrax/custom_queries/find_models_by_access.rb

@@ -24,35 +24,13 @@ module Hyrax
       #
       # @param model [Class]
       # @param ids [Enumerable<#to_s>, Symbol]
+      # @return [Array<Hyrax::Resource>]
       #
       def find_models_by_access(mode:, models: nil, agent:, group: nil)
-        agent = "group/#{agent}" if group.present?
-        internal_array = "{\"permissions\": [{\"mode\": \"#{mode}\", \"agent\": \"#{agent}\"}]}"
-        if models.present?
-          query_service.run_query(find_models_by_access_query, internal_array, models)
-        else
-          query_service.run_query(find_by_access_query, internal_array)
-        end
-      end
-
-      def find_models_by_access_query
-        <<-SQL
-          SELECT * FROM orm_resources
-          WHERE id IN (
-            SELECT uuid(metadata::json#>'{access_to,0}'->>'id') FROM orm_resources
-            WHERE metadata @> ?
-          ) AND internal_resource IN (?);
-        SQL
-      end
-
-      def find_by_access_query
-        <<-SQL
-          SELECT * FROM orm_resources
-          WHERE id IN (
-            SELECT uuid(metadata::json#>'{access_to,0}'->>'id') FROM orm_resources
-            WHERE metadata @> ?
-          );
-        SQL
+        query = "#{Hydra.config.permissions[mode.to_sym][(group ? 'group' : 'individual').to_sym]}:#{agent}"
+        query += " AND has_model_ssim: (#{models.map { |m| "\"#{m}\"" }.join(' OR ')})" unless models.empty?
+        ids = Hyrax::SolrService.query_result(query, fl: 'id')['response']['docs'].map { |doc| doc['id'] }
+        Hyrax.query_service.find_many_by_ids(ids: ids)
       end
     end
   end