has_helpers 5.0.2

data/app/lib/has_helpers/application_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module ApplicationHelper
+    def self.included(klass)
+      klass.class_eval do
+        extend self # Turn all instance methods into module methods
+      end
+    end
+
+    included(self)
+
+    def translate_klass_name(klass_name)
+      klass_name
+    end
+
+    def translate_klass(klass_name)
+      translate_klass_name(klass_name).safe_constantize
+    end
+  end
+end

data/app/lib/has_helpers/dn/processor.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module DN
+    class Processor
+      include ::HasHelpers::DN::Utils::QueryUtils
+      MAX_PROCESSING_TIME = 5.minutes
+
+      attr_reader :table_name, :record_id, :columns_and_tables_to_update, :class_name, :changes, :change_log_id
+
+      def initialize(table_name, columns_and_tables_to_update, class_name, record_id, changes, change_log_id)
+        @table_name = table_name
+        @changes = changes
+        @columns_and_tables_to_update = columns_and_tables_to_update
+        @record_id = record_id
+        @class_name = class_name.constantize
+        @change_log_id = change_log_id
+      end
+
+      def process
+        process_upsert
+      end
+
+      private
+
+      def process_upsert
+        ::ActiveRecord::Base.connection_pool.with_connection do |connection|
+          connection.transaction do
+            exec_upsert(connection: connection)
+            if change_log_id.present?
+              ChangeLog.find_by(id: change_log_id).update(denormalized_at: Time.zone.now)
+            end
+          end
+        end
+      end
+
+      # Upserts tables that are denormalized
+      def exec_upsert(connection:)
+        @columns_and_tables_to_update.each do |column, tables_to_change|
+          # column represents the column that triggers the change
+          # tables to change is an array of hashes with the tables to change
+          tables_to_change.each do |table_to_change_info|
+            upsert_sql = update_sql(fetch_update_info(column: column, table_to_change_info: table_to_change_info, table_name: table_name, class_name: class_name).merge({ record_id: record_id }))
+            connection.select_value(<<-SQL).to_i
+              WITH rows AS (
+                #{upsert_sql}
+              )
+              SELECT count(*) FROM rows;
+            SQL
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/has_helpers/dn/refresh.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module DN
+    module Refresh
+      def self.refresh(table_name:, table_and_columns:, class_name:, record_id:, changes:, change_log_id:)
+        filtered_columns = table_and_columns.select { |column, _tables| changes.key? column }
+        processor = ::HasHelpers::DN::Processor.new(table_name, filtered_columns, class_name, record_id, changes, change_log_id)
+        processor.process
+      end
+    end
+  end
+end

data/app/lib/has_helpers/dn/utils/backfill_utils.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module DN
+    module Utils
+      module BackfillUtils
+        # default batch size
+        BATCH_SIZE = 1000
+        ID_BATCH_SIZE = 300
+        LOCKED = "LOCKED"
+        STAT_TYPE = "denormalization"
+        STAT_SUBTYPE = "dn_utils"
+
+        def update_sql(table_name, offset, update_statement, where_clause, ids_to_update = nil, disable_triggers = true)
+          disable_trigger_statement = disable_triggers ? "SELECT set_config('psql_hq.skip_triggers.ALL', 'true', true);" : nil
+          inner_id_clause =
+            if ids_to_update.present?
+              "'#{ids_to_update[offset, ID_BATCH_SIZE].join("','")}'"
+            else
+              "SELECT id FROM #{table_name}
+              #{where_clause}
+              ORDER BY created_at DESC, id
+              LIMIT #{BATCH_SIZE} OFFSET #{offset}"
+            end
+          <<~SQL
+            #{disable_trigger_statement}
+            UPDATE #{table_name}
+            SET #{update_statement}
+            WHERE #{table_name}.id IN (
+              #{inner_id_clause}
+            );
+          SQL
+        end
+
+        def prepare_sql_statement(db_columns, resource, **options)
+          # errors = []
+          options = options.symbolize_keys
+          columns = options[:columns] || nil
+          start_updated_at = options[:start_updated_at] || nil
+          end_updated_at = options[:end_updated_at] || nil
+          ids_to_update = options[:ids_to_update] || nil
+          organization_id = options[:organization_id] || nil
+          # set the columns to update
+          update_statement = columns.present? ? columns.map { |c| db_columns[c.to_sym] }.join(",") : db_columns.values.join(",")
+          where_clause = define_where_clause(start_updated_at, end_updated_at, organization_id) if ids_to_update.nil?
+          records_to_update = ids_to_update.present? ? ids_to_update.size : get_records_to_update_count(resource, where_clause)
+          save_to_stats(resource.table_name, STAT_SUBTYPE, { table: resource.table_name, count: records_to_update })
+
+          # Enqueue in batches
+          Array(options[:ids_to_update]).each_slice(BATCH_SIZE) do |batch_ids|
+            ::GoodJob::DNUpdateWorker.perform_deferred(resource.table_name, batch_ids, update_statement, options[:disable_triggers])
+          end
+        end
+
+        def define_where_clause(start_updated_at, end_updated_at, organization_id)
+          # set the where clause for backfills withoud ids
+          use_where_clause = start_updated_at.present? || end_updated_at.present? || organization_id.present?
+          start_where_clause = "updated_at > '#{start_updated_at}'" if start_updated_at.present?
+          end_where_clause = "updated_at < '#{end_updated_at}'" if end_updated_at.present?
+          org_clause = "organization_id = #{organization_id}" if organization_id.present?
+          where_clause = use_where_clause ? "WHERE " + [start_where_clause, end_where_clause, org_clause].compact.join(" AND ") : [start_where_clause, end_where_clause, org_clause].compact.join(" AND ")
+          where_clause
+        end
+
+        def get_records_to_update_count(resource, where_clause)
+          where_clause.blank? ? resource.count : resource.where(where_clause.gsub("WHERE", "")).count
+        end
+
+        def save_to_stats(table_name, subtype, data)
+          stat = ::HasHelpers::Stat.new
+          stat.name = table_name
+          stat.maintype = STAT_TYPE
+          stat.subtype = subtype
+          stat.data = data
+          stat.save!
+        end
+      end
+    end
+  end
+end

data/app/lib/has_helpers/dn/utils/query_utils.rb

@@ -0,0 +1,216 @@
+# typed: false
+# frozen_string_literal: true
+
+module HasHelpers
+  module DN
+    module Utils
+      module QueryUtils
+        def fetch_update_info(column:, table_to_change_info:, table_name:, class_name:)
+          table_to_change_info = table_to_change_info&.symbolize_keys
+          table_to_change = table_to_change_info[:dependent_table].to_s
+          column_to_change = table_to_change_info[:column_name].to_s
+          foreign_key = table_to_change_info[:foreign_key]&.to_s
+          table_with_changes_included = table_to_change_info[:table_with_changes].present?
+          table_with_changes = table_to_change_info[:table_with_changes].present? ? table_to_change_info[:table_with_changes].symbolize_keys[:table].to_s : table_name
+          association = class_name.reflect_on_all_associations.find { |assoc| assoc.plural_name == (table_to_change_info[:alias] ? table_to_change_info[:alias].to_s : table_to_change) }
+          reverse_association = nil
+          if table_name != table_to_change
+            class_to_change = table_to_change&.classify&.safe_constantize
+            class_to_change = ActiveRecord::Base.descendants.find { |klass| klass.table_name == table_to_change } if class_to_change.nil?
+            reverse_association = class_to_change&.reflect_on_all_associations&.find { |assoc| assoc.plural_name == table_name }
+          end
+          column_with_changes =
+            if table_to_change_info[:table_with_changes].present?
+              table_to_change_info[:table_with_changes].symbolize_keys[:column].to_s
+            elsif table_to_change_info[:column_with_changes].present?
+              table_to_change_info[:column_with_changes].to_s
+            else
+              column
+            end
+
+          inner_association = class_name.reflect_on_all_associations.find { |assoc| assoc.plural_name == table_with_changes } if table_to_change_info[:table_with_changes].present?
+          { table_name: table_name, column: column, table_to_change: table_to_change, column_to_change: column_to_change, table_with_changes: table_with_changes, column_with_changes: column_with_changes, association: association, reverse_association: reverse_association, inner_association: inner_association, foreign_key: foreign_key, table_with_changes_included: table_with_changes_included }
+        end
+
+        def update_sql (options = {})
+          table_name = options[:table_name]
+          column = options[:column]
+          table_to_change = options[:table_to_change]
+          column_to_change = options[:column_to_change]
+          table_with_changes = options[:table_with_changes]
+          column_with_changes = options[:column_with_changes]
+          association = options[:association]
+          reverse_association = options[:reverse_association]
+          inner_association = options[:inner_association]
+          foreign_key = options[:foreign_key]
+          record_id = options[:record_id]
+          table_with_changes_included = options[:table_with_changes_included]
+          # table_name --> table that changes and triggers the refresh. Ex: advisors
+          # column --> column of the table that changed. Ex: column= name in table advisors
+          # table_to_change --> table that will be changed. Ex: licenses
+          # column_to_change --> column on the table_to_change that will be updated. Ex advisor_name on licenses
+          # Continuing with the example: Changes on the column "name" of the table "advisors" will cause
+          # changes on the colum "advisor_name" on the table "licenses"
+          # table_with_changes --> table that contains the changes. (in the previous example its the same table, but there could be a case that changes are not on the same table)
+          # association--> association between the class of the table that was changed and the one that should be changed
+          # reverse_association --> reverse association between the class of the table that was changed and the one that should be changed
+          # we use the association and the reverse_association to determine the type of relationship between resources
+          # foreign_key --> foreign key between relationships
+          # alias --> the name we use to find the class that a resource is associated with, we need to do that to the relationship type. Ex: Between Contract Levels and Levels we need CarrierLevels.
+
+          association_type = association&.macro
+          reverse_association_type = reverse_association&.macro
+          foreign_key ||= reverse_association_type == :has_one ? reverse_association&.foreign_key : association&.foreign_key
+          is_many_to_many = association_type == :has_many && association.options[:through].present?
+          is_one_to_one = association_type == :belongs_to && reverse_association_type == :has_one
+          is_many_to_one = association_type == :belongs_to && inner_association.nil?
+          is_one_to_many = (association_type == :has_many || association_type == :has_one) && !table_with_changes_included
+
+          # depending on the type of relationship we have different sql updates
+          # 1.changes on the same table. Ex: when we change advisor_id on the license table we need to update the advisor_name column on the license table as well
+          # 2.changes on records of has many to many relationship (has many trough). Ex: when you change the advisor name of an advisor that belong to a writing adv of an oppty,
+          #   In this case we need to change the primary_advisor of the opportunities table.
+          #   For this types of relationships we only update the primary record (normally specified with an is_primary column)
+          # 3.Changes on records of relationship has_many. Ex: when we update the name of an advisor we need to update the column advisor_name of all the associated
+          #    licenses.
+          # 4. Changes on records with one to one relationship. (belongs_to and has one) Ex: demographics and advisors.
+          # 5.Changes on records with a belongs_to relationship. Ex: when we update the number of a phone of an advisor. In this case we need to change the primary_number column
+          #   on the advisors tables. For this types of relationships we only update the primary record (normally specified with an is_primary column)
+          # 6. When we are updating an intermediary table of many to many relationship. Ex: when you update a writing_advisor of an oppty (change the advisor or the is_primary)
+
+          upsert_sql =
+            if table_to_change == table_name
+              # Case 1
+              update_table(column: column, record_id: record_id, table_to_change: table_to_change,
+                           column_to_change: column_to_change, table_with_changes: table_with_changes,
+                           column_with_changes: column_with_changes)
+            elsif is_many_to_many
+              # Case 2
+              update_many_to_many(record_id: record_id, table_to_change: table_to_change,
+                                  column_to_change: column_to_change, table_with_changes: table_with_changes,
+                                  column_with_changes: column_with_changes, association: association)
+            elsif is_one_to_many
+              # case 3
+              update_one_to_many(record_id: record_id, table_to_change: table_to_change,
+                                 column_to_change: column_to_change, table_with_changes: table_with_changes,
+                                 column_with_changes: column_with_changes, foreign_key: foreign_key)
+            elsif is_one_to_one
+              # case 4
+              # when we include the hash table_with_changes then we are updating intermediary table, which is the last case
+              update_one_to_one(record_id: record_id, table_to_change: table_to_change,
+                                column_to_change: column_to_change, table_with_changes: table_with_changes,
+                                column_with_changes: column_with_changes, foreign_key: foreign_key)
+            elsif is_many_to_one
+              # case 5
+              update_many_to_one(record_id: record_id, table_to_change: table_to_change,
+                                 column_to_change: column_to_change, table_with_changes: table_with_changes,
+                                 column_with_changes: column_with_changes, foreign_key: foreign_key)
+            else
+              # in case where we are updating an intermediary table of many-to-many relationship
+              # Case 6
+              inner_foreign_key = inner_association&.foreign_key
+              update_intermediate_of_many_to_many(record_id: record_id, table_name: table_name, table_to_change: table_to_change,
+                                                  column_to_change: column_to_change, table_with_changes: table_with_changes,
+                                                  column_with_changes: column_with_changes, foreign_key: foreign_key,
+                                                  inner_foreign_key: inner_foreign_key)
+            end
+
+          upsert_sql
+        end
+
+        def update_table(column:, record_id:, table_to_change:, column_to_change:, table_with_changes:, column_with_changes:)
+          <<-SQL
+            UPDATE
+              #{table_to_change}
+            SET
+              #{column_to_change} =
+              (
+                SELECT #{table_with_changes}.#{column_with_changes} FROM #{table_with_changes}
+                LEFT OUTER JOIN #{table_to_change} ON
+                #{table_to_change}.#{column} = #{table_with_changes}.id
+                WHERE #{table_to_change}.id = '#{record_id}'
+              )
+            WHERE #{table_to_change}.id = '#{record_id}'
+            RETURNING #{table_to_change}.id
+          SQL
+        end
+
+        def update_many_to_many(record_id:, table_to_change:, column_to_change:, table_with_changes:, column_with_changes:, association:)
+          <<-SQL
+            UPDATE
+              #{table_to_change}
+            SET
+              #{column_to_change} = #{table_with_changes}.#{column_with_changes}
+            FROM
+              #{association.options[:through]}
+            INNER JOIN
+              #{table_with_changes} ON #{table_with_changes}.id = #{association.options[:through]}.#{association.through_reflection.foreign_key}
+            WHERE
+              #{table_with_changes}.id = '#{record_id}' AND
+              #{association.options[:through]}.is_primary = TRUE AND
+              #{association.options[:through]}.#{association.foreign_key} = #{table_to_change}.id
+            RETURNING #{table_to_change}.id
+          SQL
+        end
+
+        def update_one_to_many(record_id:, table_to_change:, column_to_change:, table_with_changes:, column_with_changes:, foreign_key:)
+          update_assoc(record_id: record_id, table_to_change: table_to_change, column_to_change: column_to_change,
+                       table_with_changes: table_with_changes, column_with_changes: column_with_changes,
+                       foreign_key: foreign_key, relation_type: "one_to_many")
+        end
+
+        def update_one_to_one(record_id:, table_to_change:, column_to_change:, table_with_changes:, column_with_changes:, foreign_key:)
+          update_assoc(record_id: record_id, table_to_change: table_to_change, column_to_change: column_to_change,
+                       table_with_changes: table_with_changes, column_with_changes: column_with_changes,
+                       foreign_key: foreign_key, relation_type: "one_to_one")
+        end
+
+        def update_many_to_one(record_id:, table_to_change:, column_to_change:, table_with_changes:, column_with_changes:, foreign_key:)
+          update_assoc(record_id: record_id, table_to_change: table_to_change, column_to_change: column_to_change,
+                       table_with_changes: table_with_changes, column_with_changes: column_with_changes,
+                       foreign_key: foreign_key, relation_type: "many_to_one")
+        end
+
+        def update_assoc(record_id:, table_to_change:, column_to_change:, table_with_changes:, column_with_changes:, foreign_key:, relation_type:)
+          where_clause =
+            if relation_type == "one_to_many"
+              "#{table_with_changes}.id = #{table_to_change}.#{foreign_key}"
+            else
+              "#{table_with_changes}.#{foreign_key} = #{table_to_change}.id"
+            end
+          where_clause += " AND #{table_with_changes}.id = '#{record_id}'"
+          where_clause += " AND #{table_with_changes}.is_primary = TRUE" if relation_type == "many_to_one"
+          <<-SQL
+            UPDATE
+              #{table_to_change}
+            SET
+              #{column_to_change} = #{table_with_changes}.#{column_with_changes}
+            FROM
+              #{table_with_changes}
+            WHERE
+              #{where_clause}
+            RETURNING #{table_with_changes}.id
+          SQL
+        end
+
+        def update_intermediate_of_many_to_many(record_id:, table_name:, table_to_change:, column_to_change:, table_with_changes:, column_with_changes:, foreign_key:, inner_foreign_key:)
+          <<-SQL
+            UPDATE
+              #{table_to_change}
+            SET
+              #{column_to_change} = #{table_with_changes}.#{column_with_changes}
+            FROM
+              #{table_name}
+            LEFT JOIN
+              #{table_with_changes} ON #{table_with_changes}.id = #{table_name}.#{inner_foreign_key}
+            WHERE
+              #{table_name}.id = '#{record_id}' AND
+              #{table_name}.#{foreign_key} = #{table_to_change}.id AND
+              #{table_name}.is_primary = TRUE
+            RETURNING #{table_to_change}.id
+          SQL
+        end
+      end
+    end
+  end
+end

data/app/lib/has_helpers/feature.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "flipper"
+require "flipper/adapters/redis"
+require "flipper/adapters/memory"
+
+module HasHelpers
+  module Feature
+    ::HasHelpers::Organization.class_eval do
+      def flipper_id
+        "Organization:#{id}"
+      end
+    end
+
+    ::HasHelpers::User.class_eval do
+      def flipper_id
+        "User:#{id}"
+      end
+    end
+
+    class << self
+      def active?(feature, user_or_org = nil)
+        case
+        when user_or_org.nil?
+          flipper[feature].enabled?
+        when user_or_org.respond_to?(:organization)
+          flipper[feature].enabled?(user_or_org && user_or_org.organization) || flipper[feature].enabled?(user_or_org)
+        else
+          flipper[feature].enabled?(user_or_org)
+        end
+      end
+
+      def off?(feature)
+        # will only be true of the feature is fully disabled (partially enabled for some actors does not count)
+        flipper[feature].off?
+      end
+
+      def active_any?(feature)
+        # true if the feature is fully enabled or if any actor is enabled
+        !flipper[feature].off?
+      end
+
+      def active_orgs(feature)
+        # get all organizations that are enabled for the feature (this method won't work if the feature is fully enabled)
+        # since the actors' format equals "Organization:id", we can just split the string to obtain the organization_id
+        flipper[feature].actors_value.map { |org| org.split(":").last.to_i }
+      end
+
+      def activate!(feature, user_or_org = nil)
+        if user_or_org.nil?
+          flipper[feature].enable
+        else
+          flipper[feature].enable(user_or_org)
+        end
+      end
+
+      def setup(feature)
+        activate!(feature) unless flipper.exist?(feature)
+      end
+
+      def deactivate!(feature, user_or_org = nil)
+        if user_or_org.nil?
+          flipper[feature].disable
+        else
+          flipper[feature].disable(user_or_org)
+        end
+      end
+
+      def register(*args, &block)
+        Flipper.register(*args, &block)
+      end
+
+      def flipper
+        @flipper ||= Flipper.new(adapter)
+      end
+
+      private
+
+      def adapter
+        if ::HasUtils::Env.test?
+          Flipper::Adapters::Memory.new
+        else
+          Flipper::Adapters::Redis.new(RedisConf.current)
+        end
+      end
+    end
+  end
+end

data/app/lib/has_helpers/hq_exception.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class HqException
+    def self.new(error_class_or_message = nil, message = nil, backtrace: caller)
+      if error_class_or_message.is_a? Class
+        error_class = error_class_or_message
+      else
+        error_class = RuntimeError
+        message = error_class_or_message.to_s
+      end
+
+      exception = error_class.new(message)
+      exception.set_backtrace(backtrace)
+      exception
+    end
+  end
+end