has_helpers 5.0.2

data/app/lib/has_helpers/organization_merge.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class OrganizationMerge
+    attr_reader :merge_into_org, :merge_from_org
+
+    def initialize(into: nil, from: nil)
+      @merge_into_org = into
+      @merge_from_org = from
+      @success = false
+      post_initialize
+    end
+
+    def post_initialize
+    end
+
+    def success?
+      @success
+    end
+
+    def included_tables
+      @included_tables ||= []
+    end
+
+    def merge_orgs(into: nil, from: nil)
+      @merge_into_org ||= into
+      @merge_from_org ||= from
+
+      ::ActiveRecord::Base.transaction do
+        pre_merge_function
+        @success = true
+      rescue => e
+        ::HasHelpers::LogNotifier.notify("Org merge failed: #{e.inspect}")
+        @success = false
+      end
+
+      if success?
+        ::ActiveRecord::Base.transaction do
+          disable_triggers
+          start_of_merge_transaction_function
+
+          current_num = 0
+          tables_to_merge = included_tables.any? ? included_tables : connection.tables
+          num_tables = tables_to_merge.length
+          tables_to_merge.each do |table|
+            current_num += 1
+            Rails.logger.info "--------------------------------------------------"
+            Rails.logger.info "#{table} (#{current_num}/#{num_tables})"
+            next unless connection.column_exists?(table, :organization_id)
+
+            Rails.logger.info "Updating import key for #{table}..."
+            connection.execute(update_import_key_sql(table)) if connection.column_exists?(table, :import_key)
+            Rails.logger.info "DONE\n"
+
+            Rails.logger.info "Updating org id for #{table}..."
+            connection.execute(update_org_id_sql(table))
+            Rails.logger.info "DONE\n"
+          end
+
+          Rails.logger.info "--------------------------------------------------"
+          Rails.logger.info "Committing transaction..."
+        rescue => e
+          ::HasHelpers::LogNotifier.notify("Org merge failed: #{e.inspect}")
+          @success = false
+        end
+      end
+
+      if success?
+        ::ActiveRecord::Base.transaction do
+          post_merge_function
+        rescue => e
+          ::HasHelpers::LogNotifier.notify("Org merge failed: #{e.inspect}")
+          @success = false
+        end
+      end
+    end
+
+    # Used when something needs to happen before the merge.
+    # NOTE: THIS OCCURS IN A SEPARATE TRANSACTION AND WILL NOT BE ROLLED BACK
+    # IF THE ORG MERGE FAILS!
+    def pre_merge_function
+    end
+
+    # Used when something needs to happen after the merge.
+    # NOTE: THIS OCCURS IN A SEPARATE TRANSACTION AND THE ORG MERGE WILL NOT
+    # BE ROLLED BACK IF THIS FAILS!
+    def post_merge_function
+    end
+
+    # Allows for custom methods and queries to run in the same transaction as the org merge.
+    def start_of_merge_transaction_function
+    end
+
+    private
+
+    def connection
+      @connection ||= ::ActiveRecord::Base.connection
+    end
+
+    # Disable trigger should be inject from config/initializers/frameworkhq.rb
+    def disable_triggers
+      disable_read_only_triggers
+    end
+
+    # Some tables have triggers that make organization_id into a read_only
+    # column, so we have to disable those triggers in order to move records
+    # between orgs.
+    def disable_read_only_triggers
+      connection.execute("SELECT set_config('psql_hq.skip_triggers.#{::PsqlHq::ReadOnlyTrigger.prefix}', 'true', 'true')")
+    end
+
+    def update_import_key_sql(table)
+      <<~SQL
+        UPDATE #{table}
+        SET import_key = NULL
+        WHERE organization_id = #{merge_from_org.id} AND import_key IS NOT NULL
+      SQL
+    end
+
+    def update_org_id_sql(table)
+      <<~SQL
+        UPDATE #{table}
+        SET organization_id = #{merge_into_org.id}
+        WHERE organization_id = #{merge_from_org.id}
+      SQL
+    end
+  end
+end

data/app/lib/has_helpers/query/elasticsearch.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Query
+    class Elasticsearch
+      include ::HasHelpers::Query::Provider
+      include ::HasHelpers::Search::ElasticsearchShared
+
+      private
+
+      def sanitize_query(query)
+        query
+      end
+
+      def exec_query(resource:, query:, options:)
+        searchkick_results(resource, query, options)
+      end
+    end
+  end
+end

data/app/lib/has_helpers/query/provider.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+
+module HasHelpers
+  module Query # TODO: Rename to "Search" after the old "Query" module has been removed. •
+    # TODO: I think none of the providers are maintaining state, so they can be converted to modules. Need to evaluate this further. •
+    module Provider
+      PAGINATION_ATTRS = %i[current_page per_page total_entries]
+
+      def self.included(klass)
+        klass.extend(ClassMethods)
+        all << klass.name
+      end
+
+      # Returns a list of names of all provider classes
+      def self.all
+        @all ||= Set.new
+      end
+
+      # Returns a triple of scope relation name, owner relation name, and
+      # an ActiveRecord::Relation object built from the given scope (Relation
+      # or model class) which includes the joined owner view, as well as the
+      # relation names related to the owner view. If no owner view is detected
+      # then `nil` is returned as the relation.
+      #
+      #=== Examples
+      #
+      #   scope_with_owner_view(Advisor) # => ["advisors", "owner_advisors_view", <#ActiveRecord::Relation>]
+      #
+      #   # Hierarchy does _not_ have an owner view.
+      #   scope_with_owner_view(Hierarchy) # => ["hierarchies", "owner_hierarchies_view", nil]
+      #
+      def self.owner_relation_from_scope(scope)
+        scope_relation_name = scope.table_name
+        owner_relation_name = "owner_#{ scope_relation_name }_view"
+
+        if relation_exists?(owner_relation_name) # Check if the owner view is present.
+          owner_relation = scope.joins("LEFT OUTER JOIN #{ owner_relation_name } ON #{ owner_relation_name }.id = #{ scope_relation_name }.id")
+          owner_relation.select_values = ["#{ scope_relation_name }.*"]
+        end
+
+        [scope_relation_name, owner_relation_name, owner_relation]
+      end
+
+      # NOTE: This method is currently intended for internal use only. Schema
+      # and table names are _NOT_ being sanitized, so values from user input
+      # are not currently safe to use here.
+      def self.relation_exists?(table, schema: "public")
+        query = "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = '#{ schema }' AND table_name = '#{ table }');"
+        result = ::ActiveRecord::Base.connection.execute(query)
+        result.first["exists"].to_bool
+      end
+
+      # Returns an provider class instance which matches the given short name.
+      # @param String short_name - The short name for a provider, e.g. "Sphinx" or "SQL"
+      #
+      #=== Examples
+      #   from_short_name("Sphinx")   # => HasHelpers::Query::Sphinx
+      #   from_short_name("Unknown")  # => nil
+      def self.from_short_name(short_name)
+        all.lazy.
+          select do |provider_name|
+          provider_name == "#{ name.deconstantize }::#{ short_name }"
+        end.
+          map(&:constantize).
+          first
+      end
+
+      def query_options(resource: nil, query: nil, options: {}) # rubocop:disable Lint/UnusedMethodArgument
+        options
+      end
+
+      def search(resource:, query:, options: {})
+        exec_query(
+          resource: resource,
+          query: sanitize_query(query),
+          options: query_options(resource: resource, query: query, options: options)
+        )
+      end
+
+      private
+
+      def sanitize_query(query)
+        query
+      end
+
+      # Executes the search based on the given arguments and returns paginated results.
+      # Returns an object which must be JSON-serializable.
+      def exec_query(...)
+        # Override freely. If you don't then your search will not be very useful.
+        # Your method should accept :resource, :query and :options keyword arguments.
+      end
+
+      module ClassMethods
+        def search(query:, resource: nil, options: {})
+          new.search(
+            resource: resource,
+            query: query,
+            options: options
+          )
+        end
+      end
+    end
+  end
+end

data/app/lib/has_helpers/query/sql.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Query
+    class Sql
+      include ::HasHelpers::Query::Provider
+
+      def self.sql(vector, query)
+        [
+          "to_tsvector('#{ ts_search_config("english_nostop") }', #{ vector }) @@ to_tsquery('#{ ts_search_config("english_nostop") }', ?)",
+          query.strip.tr("'", " ").split(/\s/).map { |qpart| "'#{qpart}':*" }.join(" & ")
+        ]
+      end
+
+      def self.scope_to_organization?(_klass)
+        true
+      end
+
+      def self.ts_search_config(name)
+        available_ts_search_configs.find { |c| c == name } || "english" # I'm pretty sure "english" will be always available, at least on any of the OneHQ Postgres instances.
+      end
+
+      def self.available_ts_search_configs
+        @available_ts_search_configs = ::ActiveRecord::Base.connection.execute("SELECT cfgname FROM pg_ts_config").map { |r| r["cfgname"] }
+      end
+
+      private
+
+      def exec_query(resource:, query:, options:)
+        resource_klasses = Array(resource).map { |r| r.constantize.base_class }.uniq
+
+        limit = (15 / resource_klasses.size).floor
+
+        intermediate_results = resource_klasses.map do |klass|
+          if klass.respond_to?(:sql_search)
+            sql_results = klass.sql_search(query, sql_search_options(options)) # Any class implementing its own search function may paginate its results.
+
+            # Pagination is required, so first check whether the results are already paginated.
+            # If so, simply return the results. Otherwise, perform default pagination.
+            if sql_results.respond_to?(:current_page)
+              sql_results
+            else
+              sql_results.page(options[:page]).per_page(options[:per_page])
+            end
+          else
+            resource_relation_name,
+              owner_relation_name,
+              owner_relation = owner_relation_from_scope(klass)
+
+            # If an owner relation exists then search on its name and sub_item columns.
+            # Otherwise fallback to searching the name column for the base relation.
+            if owner_relation
+              scope = owner_relation
+              search_vector = "CONCAT_WS(' ', #{ owner_relation_name }.name, #{ owner_relation_name }.sub_item)"
+            else
+              scope = klass
+              search_vector = "#{ resource_relation_name }.name"
+            end
+
+            # TODO: excepting filter option and select option because they are not organization specific.
+            # Had to do it this way for now, because if we checked for the presence of organization_id on the model,
+            # searches like "BankAccount" would start working and not be filtered to org.
+            scope = scope.where(organization_id: options[:with][:organization_id]) if self.class.scope_to_organization?(klass)
+
+            scope.
+              where(self.class.sql(search_vector, query)).
+              # TODO: Need to order here (by best match?) otherwise the results come back in random order. *
+              page(options[:page]).
+              per_page(limit)
+          end
+        end
+
+        {
+          results: intermediate_results.map { |results| join_owner_info(results, options) || results }.flatten,
+          total_entries: intermediate_results.map(&:total_entries).max,
+          current_page: intermediate_results.first.current_page,
+          per_page: intermediate_results.first.per_page
+        }
+      end
+
+      def sql_search_options(options)
+        options.tap do |opts|
+          if opts[:with] && opts[:with][:organization_id]
+            # TODO: deprecate the :organization option in favor of with: { organization_id: } •
+            options.merge!(organization_id: opts[:with][:organization_id])
+          end
+        end
+      end
+
+      # Accepts a scope which may be either an ActiveRecord model class or an ActiveRecord::Relation
+      # object. Owner views are joined into the scope if possible. If no owner view is detected then
+      # nil is returned.
+      def join_owner_info(scope, options = {})
+        scope = scope.all # Ensure that scope is an ActiveRecord::Relation.
+
+        _, owner_relation_name, owner_relation = owner_relation_from_scope(scope)
+
+        if owner_relation
+          # Detect column names for the owner relation.
+          owner_relation_columns = scope.klass.instance_eval do
+            @owner_column_names ||= Class.new(::ActiveRecord::Base) do
+              self.table_name = owner_relation_name
+            end.column_names
+          end
+
+          # Add select clauses for owner columns.
+          owner_relation_columns.each do |owner_column|
+            owner_relation.select_values << "#{ owner_relation_name }.#{ owner_column } AS #{ owner_column }"
+          end
+
+          # Paginate results - preserve the pagination from the paginated_collection option or the original scope.
+          # This is done by first evaluating the `owner_relation` by calling `#to_a` on it, then paginating the
+          # results to get a paginated collection (i.e. WillPaginate::Collection instance). Then assign the pagination
+          # info to the collection.
+          paginated_collection = options[:paginated_collection] || scope
+          owner_relation.to_a.paginate(page: 1, per_page: owner_relation.size).tap do |paginated_results|
+            # Just get a paginated collection for the results
+            PAGINATION_ATTRS.each do |attr|
+              # Copy pagination data to the search results.
+              # E.g. @total_entries = 321
+              paginated_results.instance_variable_set("@#{ attr }", paginated_collection.send(attr))
+            end
+          end
+        end
+      end
+
+      # wrapper around the class method
+      def owner_relation_from_scope(scope)
+        ::HasHelpers::Query::Provider.owner_relation_from_scope(scope)
+      end
+    end
+  end
+end

data/app/lib/has_helpers/query.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Query # TODO: Rename to "Search" after the old "Query" module has been removed. •
+    def self.provider
+      provider = @provider.call if @provider.respond_to?(:call)
+      provider || @provider || ::HasHelpers::Query::Sql
+    end
+
+    def self.provider=(provider = nil, &block)
+      @provider = provider || block
+    end
+  end
+end

data/app/lib/has_helpers/search/elasticsearch.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "will_paginate/array"
+
+class HasHelpers::Search::Elasticsearch
+  prepend ::SearchExtensions::ProviderExtensions
+  include ::HasHelpers::Search::Provider
+  include ::HasHelpers::Search::ElasticsearchShared
+
+  def sanitize_query(query)
+    query
+  end
+
+  def exec_query(resource, query, options)
+    results = searchkick_results(resource, query, query_options(resource, query, options))
+    new_results = results[:results]
+    new_results = new_results.paginate(page: 1, per_page: 15)
+
+    self.class::PAGINATION_ATTRS.each do |attr|
+      # set the instance variables for will_paginate
+      #   { results: [...], current_page: 1, per_page: 15, total_entries: 42 }
+      new_results.instance_variable_set("@#{ attr }", results[attr])
+    end
+
+    new_results
+  end
+
+  def query_options(resource, query, options)
+    if ::HasHelpers::SearchAPI.options_hook.respond_to?(:to_proc)
+      ::HasHelpers::SearchAPI.options_hook.call(
+        resources: Array(resource),
+        query: query,
+        options: options,
+        current_user: current_user,
+        provider: ::HasHelpers::Query::Elasticsearch
+      )
+    else
+      options
+    end
+  end
+end

data/app/lib/has_helpers/search/elasticsearch_shared.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Search
+    module ElasticsearchShared
+      def searchkick_results(resource, query, options)
+        organization_id = options[:with]&.symbolize_keys&.dig(:organization_id)
+        klasses = Array(resource).map { |r| class_from_resource(r.to_s) }
+
+        if klasses.size === 1
+          klass = klasses.first
+          if klass != klass.base_class && klass.search_index.fields.include?(:type)
+            options[:with][:type] = klass.name
+          end
+        end
+
+        show_inactive = options[:with] && options[:with][:show_inactive]
+        options[:with].delete(:show_inactive) if show_inactive
+        searchkick_results = HasHelpers::Index.search(query,
+                                                      indexes: klasses.map(&:search_index),
+                                                      where: options[:with].symbolize_keys, # Searchkick expects keys to be symbols
+                                                      load: false,
+                                                      per_page: 15,
+                                                      page: options[:page],
+                                                      show_inactive: show_inactive
+        )
+
+        results = {}
+        # group into classes
+        searchkick_results.each do |result|
+          key = result["_type"].classify.remove("Index")
+          results[key] ||= []
+          results[key] << result["_id"]
+        end
+
+        # remove hidden options
+        results = ::HasHelpers::Index.filter_hidden_constants(results, organization_id) || results if organization_id.present?
+
+        # switch ids to active record, preserving order
+        results.each { |key, array| results[key] = owner_relation(key).where(id: array).index_by { |r| r.id.to_s } }
+
+        results = searchkick_results.
+          map do |result|
+          results[result["_type"].classify.remove("Index")][result["_id"]]
+        end.
+          compact
+
+        results = { results: results }
+
+        self.class::PAGINATION_ATTRS.each do |attr|
+          # set the instance variables for will_paginate
+          #   { results: [...], current_page: 1, per_page: 15, total_entries: 42 }
+          results[attr] = searchkick_results.send(attr)
+        end
+
+        results
+      end
+
+      def owner_relation(class_name)
+        klass = class_name.dup.safe_constantize
+        base_class_name = klass.base_class.name.demodulize
+        "Owner#{base_class_name}".classify.constantize rescue klass # Default to owner view class, fallback to model.
+      end
+
+      def class_from_resource(resource)
+        resource.safe_constantize
+      end
+    end
+  end
+end

data/app/lib/has_helpers/search/provider.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# === Examples
+#   HasHelpers::Search::Provider.new(controller_instance).results
+module HasHelpers::Search::Provider
+  PAGINATION_ATTRS = [:current_page, :per_page, :total_entries]
+
+  attr_reader :controller
+
+  def initialize(controller = nil)
+    @controller = controller
+  end
+
+  def results
+    # Prefix
+    prefix = search_prefix
+
+    if prefix
+      # Screen
+      screen = search_screen(prefix)
+
+      # Sanitize prefix for use as an instance variable name (:: is not valid)
+      ivar_prefix = prefix.gsub("::", "")
+
+      # Search setup
+      controller.instance_variable_set("@#{ ivar_prefix }_query", params["search_#{ prefix }_query"][0..255])
+      controller.instance_variable_set("@#{ ivar_prefix }_screen", screen)
+
+      # Query
+      sanitized_query = sanitize_query(controller.instance_variable_get("@#{ ivar_prefix }_query"))
+
+      # Options
+      options = search_options(prefix, screen, sanitized_query)
+
+      # Perform search query
+      search(prefix, screen, sanitized_query, options)
+    end
+  end
+
+  # === Returns
+  # @string Prefix to be used in a search. When nil, no search is performed.
+  def search_prefix
+    # Fallback on getting the prefix from the first parameter key which begins wih "search_".
+    key, _ = params.to_h.detect { |k, v| v == "Search" && k.start_with?("search_") }
+    key[/\Asearch_(.*)/, 1] if key
+  end
+
+  # === Returns
+  # @string If no block has been defined then nil will be returned
+  def search_screen(prefix = search_prefix)
+    params["search_#{ prefix }_screen"] || prefix # Get screen from params if block is missing or returned nil.
+  end
+
+  def search_options(prefix, _screen = prefix, _query)
+    {
+      page: (params[:page] || 1).to_i,
+      per_page: (params[:per_page] || 15).to_i
+    }
+  end
+
+  # Returns a triple of scope relation name, owner relation name, and
+  # an ActiveRecord::Relation object built from the given scope (Relation
+  # or model class) which includes the joined owner view, as well as the
+  # relation names related to the owner view. If no owner view is detected
+  # then `nil` is returned as the relation.
+  #
+  #=== Examples
+  #
+  #   scope_with_owner_view(Advisor) # => ["advisors", "owner_advisors_view", <#ActiveRecord::Relation>]
+  #
+  #   # Hierarchy does _not_ have an owner view.
+  #   scope_with_owner_view(Hierarchy) # => ["hierarchies", "owner_hierarchies_view", nil]
+  #
+  def self.owner_relation_from_scope(scope)
+    scope_relation_name = scope.table_name
+    owner_relation_name = "owner_#{ scope_relation_name }_view"
+    if (::ActiveRecord::Base.connection.execute("SELECT 1 FROM #{ owner_relation_name } LIMIT 1") rescue false)  # Check if the owner view is present.
+      owner_relation = scope.joins("LEFT OUTER JOIN #{ owner_relation_name } ON #{ owner_relation_name }.id = #{ scope_relation_name }.id")
+      owner_relation.select_values = ["#{ scope_relation_name }.*"]
+    end
+
+    [scope_relation_name, owner_relation_name, owner_relation]
+  end
+
+  private
+
+  def sanitize_query(query)
+    query
+  end
+
+  # Accepts a scope which may be either an ActiveRecord model class or an ActiveRecord::Relation
+  # object. Owner views are joined into the scope if possible. If no owner view is detected then
+  # nil is returned.
+  def join_owner_info(scope, options = {})
+    scope = scope.all # Ensure that scope is an ActiveRecord::Relation.
+
+    _, owner_relation_name, owner_relation = owner_relation_from_scope(scope)
+
+    if owner_relation
+      # Detect column names for the owner relation.
+      owner_relation_columns = scope.klass.instance_eval do
+        @owner_column_names ||= Class.new(::ActiveRecord::Base) do
+          self.table_name = owner_relation_name
+        end.column_names
+      end
+
+      # Add select clauses for owner columns.
+      owner_relation_columns.each do |owner_column|
+        owner_relation.select_values << "#{ owner_relation_name }.#{ owner_column } AS #{ owner_column }"
+      end
+
+      # Paginate results - preserve the pagination from the paginated_collection option or the original scope.
+      # This is done by first evaluating the `owner_relation` by calling `#to_a` on it, then paginating the
+      # results to get a paginated collection (i.e. WillPaginate::Collection instance). Then assign the pagination
+      # info to the collection.
+      paginated_collection = options[:paginated_collection] || scope
+      owner_relation.to_a.paginate(page: 1, per_page: owner_relation.size).tap do |paginated_results|
+        # Just get a paginated collection for the results
+        PAGINATION_ATTRS.each do |attr|
+          # Copy pagination data to the search results.
+          # E.g. @total_entries = 321
+          paginated_results.instance_variable_set("@#{ attr }", paginated_collection.send(attr))
+        end
+      end
+    end
+  end
+
+  # wrapper around the class method
+  def owner_relation_from_scope(scope)
+    ::HasHelpers::Search::Provider.owner_relation_from_scope(scope)
+  end
+
+  # Executes the search based on the given arguments and returns paginated results.
+  def exec_query(klass, query, options)
+    # Override freely. If you don't then your search will not be very useful.
+  end
+
+  def search(_prefix, screen, query, options)
+    exec_query(screen.classify.safe_constantize, query, options)
+  end
+
+  def params
+    controller.params
+  end
+
+  def current_user
+    controller.current_user
+  end
+end