has_helpers 5.0.2

data/app/triggers/has_helpers/limit_favorites.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class LimitFavorites < ::PsqlHq::Trigger
+    attr_reader :klass, :limit
+
+    def initialize(klass:, limit:, **options)
+      @klass = klass
+      @limit = limit
+      super(options)
+    end
+
+    def self.prefix
+      "FHQ"
+    end
+
+    def self.constraint_trigger?
+      true
+    end
+
+    def self.data_trigger?
+      false
+    end
+
+    def name
+      "limit_favorites_#{klass.table_name}"
+    end
+
+    def create
+      ::ActiveRecord::Base.connection.execute trigger_function
+
+      ::ActiveRecord::Base.connection.execute <<-SQL
+        CREATE CONSTRAINT TRIGGER "#{trigger_name}"
+        AFTER INSERT OR UPDATE OF #{favorite_foreign_key} ON favorites DEFERRABLE INITIALLY DEFERRED
+        FOR EACH ROW EXECUTE PROCEDURE "#{function_name}"();
+      SQL
+
+      puts "-- Created trigger #{trigger_name} and function #{function_name}."
+    end
+
+    def drop
+      LimitFavorites.drop_by_function_name(function_name)
+    end
+
+    def trigger_function
+      <<-SQL
+        CREATE OR REPLACE FUNCTION public."#{function_name}"() RETURNS TRIGGER LANGUAGE plpgsql AS $function$
+          DECLARE
+            row_limit INTEGER;
+            nrows INTEGER;
+            resource_id TEXT;
+          BEGIN
+            #{exit_if_skipped_sql}
+
+            row_limit := #{limit};
+
+            SELECT
+              COUNT(*) INTO nrows
+            FROM favorites
+            WHERE favorites.created_by_id = NEW.created_by_id
+            AND #{favorite_foreign_key} IS NOT NULL;
+
+            IF nrows > row_limit THEN
+              SELECT
+                format('%s-%s', '#{favorite_foreign_key.titleize}', NEW.#{favorite_foreign_key}::text)
+              INTO resource_id;
+
+              RAISE NOTICE 'favorite limit: resource_id = %', resource_id;
+              RAISE 'Exceeded favorite limit of % for %', row_limit, resource_id;
+            END IF;
+
+            RETURN NULL;
+          END
+        $function$;
+      SQL
+    end
+
+    private
+
+    def favorite_foreign_key
+      klass.name.foreign_key
+    end
+
+    class << self
+      def triggers
+        @triggers ||= []
+      end
+
+      def drop_by_function_name(function_name)
+        ::ActiveRecord::Base.connection.execute <<-SQL
+          DROP FUNCTION IF EXISTS \"#{function_name}\"() CASCADE;
+        SQL
+        puts "-- Dropped #{function_name} (if it existed) and any dependent triggers"
+      end
+    end
+  end
+end

data/app/utils/has_helpers/redis_configurable.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module RedisConfigurable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def redis
+        @redis ||= RedisConf.current
+      end
+
+      def config_defaults(defaults)
+        @config_defaults = defaults
+      end
+
+      def config
+        @config ||= ConfigStruct.new(self, @config_defaults || {})
+      end
+    end
+
+    class ConfigStruct
+      def initialize(klass, defaults)
+        @klass = klass
+        @defaults = defaults
+      end
+
+      def [](key)
+        fetch_value(key)
+      end
+
+      def []=(key, value)
+        store_value(key, value)
+      end
+
+      def method_missing(name, *args)
+        key = name.to_s.sub(/=$/, "").to_sym
+
+        if name.to_s.end_with?("=")
+          store_value(key, args.first)
+        else
+          fetch_value(key)
+        end
+      end
+
+      def respond_to_missing?(_name, _include_private = false)
+        true
+      end
+
+      private
+
+      def redis
+        @klass.redis
+      end
+
+      def fetch_value(key)
+        redis_key = "config::#{@klass.name.underscore}::#{key}"
+        redis_value = redis.get(redis_key)
+        redis_value ? parse_redis_value(redis_value) : @defaults[key]
+      end
+
+      def store_value(key, value)
+        redis_key = "config::#{@klass.name.underscore}::#{key}"
+        redis.set(redis_key, value)
+      end
+
+      def parse_redis_value(value)
+        case value
+        when /^\d+$/ then value.to_i # Integer
+        when /^\d+\.\d+$/ then value.to_f # Float
+        when "true" then true # Boolean true
+        when "false" then false # Boolean false
+        else value # String or other format
+        end
+      end
+    end
+  end
+end

data/app/utils/has_helpers/sync_utils.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+# == HasHelpers::SyncUtils
+#
+# Utility module to manage synchronization of data from external sources
+# to application resources, such as syncing a remote API's data with
+# a local record in the database (e.g., updating a User's profile).
+#
+# === Usage
+#
+# 1. Configure custom field mappings in your initializer to match the resource's attributes.
+#
+#   # config/initializers/has_helpers.rb
+#   HasHelpers.configure do |config|
+#     config.sync_custom_mapping = {
+#       user: {
+#         first_name: :first_name,
+#         last_name: ->(data) {data[:last_name]},
+#         email: :email
+#       }
+#     }
+#   end
+#
+# 2. Use `HasHelpers::SyncUtils.apply_mapping` to apply the mapping to a resource,
+#    such as syncing an external data source to an existing user:
+#
+#   HasHelpers::SyncUtils.apply_mapping(user, external_data, resource_key: :user)
+#
+# === Notes
+#
+# - The method `apply_mapping` supports symbols (direct field mapping) and Procs (for computed values).
+# - Missing or nil values in the external data are ignored.
+# - The method now also supports syncing when the resource is destroyed.
+#
+module HasHelpers
+  module SyncUtils
+    # Applies a custom mapping to a resource, updating it with values from the provided data.
+    # It now supports handling resource destruction.
+    #
+    # Arguments:
+    #   - resource (ApplicationRecord): The record to update, e.g., a User.
+    #   - data (Hash): The external data to sync with the resource.
+    #   - resource_key (Symbol): The key for the resource in the sync configuration.
+    #   - is_destroyed (Boolean): Whether the resource is being destroyed (defaults to false).
+    #
+    # Returns:
+    #   - The updated resource or nil if no updates are made.
+    #   - When the resource is destroyed, it triggers a sync for deletion.
+    #
+    def self.apply_mapping(resource, data, resource_key:, is_destroyed: false)
+      return unless resource && (data.present? || is_destroyed)
+
+      if is_destroyed
+        # Logic for when the resource is destroyed, you may want to sync this deletion
+        # Example: Mark the corresponding remote record as deleted
+        return handle_destruction(resource)
+      end
+
+      # Transform the data keys to snake_case if provided
+      data = self.deep_transform_keys_to_snake_case(data) if data
+
+      # Fetch the custom mapping for the resource
+      mapping = HasHelpers.config.sync_custom_mapping[resource_key.to_sym]
+
+      # If mapping is nil, create or update resource directly with the data
+      if mapping.nil?
+        # Update the resource with external data directly
+        resource.assign_attributes(data.deep_symbolize_keys)
+        return save_with_result(resource)
+      end
+
+      # Symbolize the keys of the external data to match the mapping
+      data = data.deep_symbolize_keys if data
+      attrs = {}
+
+      # Iterate over the mapping and apply it to the resource
+      mapping.each do |model_key, mapper|
+        # Add the mapped value to the attributes hash
+        case mapper
+        when Proc
+          # Call the proc with the external data
+          attrs[model_key] = mapper.call(data)
+        when Symbol
+          # Map the symbol directly from the external data
+          attrs[model_key] = data[mapper]
+        end
+      end
+
+      resource.assign_attributes(attrs)
+
+      save_with_result(resource)
+    end
+
+    # Handles the logic when a resource is destroyed
+    #
+    # For example, sync with an external system to delete the resource or mark it as inactive.
+    #
+    # Arguments:
+    #   - resource (ApplicationRecord): The record to sync (which is being destroyed).
+    #
+    # Returns:
+    #   - `true` if the sync was successful, or an error message if it wasn't.
+    #
+    def self.handle_destruction(resource)
+      unless resource.respond_to?(:id) && resource.id.present?
+        message = "Failed to destroy #{resource.class.name}: missing resource id"
+        Rails.logger.error(message)
+        return message
+      end
+
+      return true if resource.destroy
+
+      message = "Failed to destroy resource #{resource.class.name} with ID #{resource.id}: #{resource.errors.full_messages.join(', ')}"
+      Rails.logger.error(message)
+      message
+    end
+
+    # Transforms the keys of a nested hash or array to snake_case
+    # (recursive transformation for deep structures)
+    #
+    # Arguments:
+    #   - data (Hash, Array, or other): The data structure to transform.
+    #
+    # Returns:
+    #   - The transformed data structure with all keys in snake_case.
+    #
+    def self.deep_transform_keys_to_snake_case(data)
+      case data
+      when Hash
+        # if data is serialized, deserialize
+        if data["_aj_serialized"].present?
+          return ActiveJob::Serializers.deserialize(data)
+        end
+
+        data.transform_keys { |key| key.to_s.underscore.to_sym }.each_with_object({}) do |(key, value), result|
+          result[key] = deep_transform_keys_to_snake_case(value)
+        end
+      when Array
+        data.map { |element| deep_transform_keys_to_snake_case(element) }
+      else
+        data
+      end
+    end
+
+    # Attempts to save the resource and returns a success or error message
+    #
+    # Arguments:
+    #   - resource (ApplicationRecord): The resource to save.
+    #
+    # Returns:
+    #   - `true` if the resource was saved successfully, or an error message if it failed.
+    #
+    def self.save_with_result(resource)
+      resource.save ? true : resource.errors.full_messages.join(", ")
+    end
+
+    # Checks whether all declared sync dependencies are satisfied.
+    #
+    # Arguments:
+    #   - data (Hash): The payload being synced.
+    #   - dependencies (Array<String, Symbol>): Dependency names (e.g. "user", "organization").
+    #
+    # Returns:
+    #   - true if all dependencies exist
+    #   - false if any dependency is missing
+    #
+    def self.dependencies_satisfied?(data, dependencies)
+      Array(dependencies).compact.each do |dependency|
+        next if dependency.blank?
+
+        dependency_class = resolve_dependency_class(dependency)
+        next unless dependency_class
+
+        dependency_id = extract_dependency_id(data, dependency)
+
+        return false unless dependency_id && dependency_class.exists?(id: dependency_id)
+      end
+
+      true
+    end
+
+    # Touches declared dependency records so their updated_at reflects related sync changes.
+    #
+    # Arguments:
+    #   - data (Hash): The payload being synced.
+    #   - dependencies (Array<String, Symbol>): Dependency names.
+    #
+    # Returns:
+    #   - nil (side-effect only)
+    #
+    def self.touch_dependencies!(data, dependencies)
+      Array(dependencies).compact.each do |dependency|
+        next if dependency.blank?
+
+        dependency_class = resolve_dependency_class(dependency)
+        next unless dependency_class
+
+        dependency_id = extract_dependency_id(data, dependency)
+        unless dependency_id
+          Rails.logger.warn("Could not touch dependency #{dependency}: missing dependency id in payload")
+          next
+        end
+
+        dependency_record = dependency_class.find_by(id: dependency_id)
+        unless dependency_record
+          Rails.logger.warn("Could not touch dependency #{dependency}: #{dependency_class.name} with id=#{dependency_id} was not found")
+          next
+        end
+
+        dependency_record.touch # rubocop:disable Rails/SkipsModelValidations -- touch required to bump updated_at on sync dependencies without running callbacks/validations
+      rescue => e
+        Rails.logger.warn("Could not touch dependency #{dependency} with id=#{dependency_id}: #{e.message}")
+      end
+
+      nil
+    end
+
+    def self.resolve_dependency_class(dependency)
+      ::ActiveRecord::Base.descendants.find do |model|
+        model.name.demodulize.casecmp(dependency.to_s.classify).zero?
+      end
+    end
+    private_class_method :resolve_dependency_class
+
+    def self.extract_dependency_id(data, dependency)
+      dependency_key = dependency.to_s
+      data[dependency_key] ||
+        data[dependency_key.to_sym] ||
+        data["#{dependency_key}_id"] ||
+        data[:"#{dependency_key}_id"]
+    end
+    private_class_method :extract_dependency_id
+  end
+end

data/app/views/has_helpers/actions/_action.html.erb

@@ -0,0 +1,31 @@
+<% nested ||= false %>
+<li class="<% if nested %>itm<% else %>action<% end %><%= " #{ action.skin } " if action.skin %><% if action.cast_actions.any? %> dropdown<% end %>">
+  <% if action.cast_actions.any? %>
+    <span class="btn btn-default" data-toggle="dropdown"><%= action.label %> <i class="<%= action.icon %>"></i></span>
+    <ul class="itms dropdown-menu itms-options itms-caption caption-right">
+      <%= render action.cast_actions, :nested => true %>
+    </ul>
+  <% elsif action.input %>
+    <%# It would be nice to just render the input normally, but the nested option makes that difficult. %>
+    <% action.input.raw_html_attrs.merge!(:class => "input-under-label") %><%# TODO: Move this out of the view * %>
+    <% if action.input.service %>
+      <form action="<%= action.input.service %>" method="<%= action.input.service.http_method || :post %>" autocomplete="off" novalidate="novalidate" data-replacement-strategy="replace">
+        <% unless action.input.service.http_method == :get %><input name="authenticity_token" type="hidden" value="<%= form_authenticity_token %>" /><% end %>
+    <% end %>
+
+    <label class="label-over-input <% if nested %>itm-lnk<% else %>btn btn-default<% end %>">
+      <% if action.input.icon %><i class="<%= action.input.icon %>"></i> <% end %><%= action.input.label %>
+      <input type="<%= action.input.type %>" <%= render action.input.html_attrs %> name="<%= action.input.name %>" value="<%= action.input.value %>" />
+    </label>
+
+    <% if action.input.service %>
+      </form>
+    <% end %>
+  <% elsif action.service %>
+    <%# It would be nice to just rend the service normally, but the nested option makes this difficult. %>
+    <% action.service.raw_html_attrs.merge!(:class => "itm-lnk") if nested %><%# TODO: Move this out of the view * %>
+    <a href="<%= action.service.url %>" <%= render action.service.html_attrs %>><% if action.service.icon %><i class="<%= action.service.icon %>"></i> <% end %><%= action.service %></a>
+  <% elsif action.render_object %>
+    <%= render *action.render_object.args %>
+  <% end %>
+</li>

data/app/views/has_helpers/alerts/_alert.html.erb

@@ -0,0 +1,3 @@
+<div class="alert alert-<%= alert.type %>" role="alert">
+  <% alert.details.each do |detail| %><p><%= render detail.to_renderable %></p><% end %>
+</div>

data/app/views/has_helpers/barcodes.html.erb

@@ -0,0 +1,36 @@
+<html>
+  <head>
+    <style type="text/css">
+      body {
+        padding: 0.25in;
+      }
+
+      div.barcode_label {
+        font-family: arial, sans-serif;
+        font-size: 10pt;
+      }
+
+      img.barcode {
+        margin-bottom: 36px;
+        display: block;
+      }
+
+      div.spacer {
+        height: 36px;
+      }
+    </style>
+  </head>
+  <body>
+    <%# Text labels %>
+    <% presenter.barcode_infos.each do |barcode_info| %>
+      <div class="barcode_label"><%= barcode_info[:text] %></div>
+    <% end %>
+
+    <div class="spacer">&nbsp;</div>
+
+    <%# Barcodes %>
+    <% presenter.barcode_infos.each do |barcode_info| %>
+      <img class="barcode" src="<%= barcode_info[:image_src] %>" />
+    <% end %>
+  </body>
+</html>

data/app/views/has_helpers/containers/_container.html.erb

@@ -0,0 +1,3 @@
+<<%= container.tag %> <%= render container.html_attrs %>>
+  <%= render container.renderable if container.renderable %>
+</<%= container.tag %>>

data/app/views/has_helpers/email_notifier/system.html.erb

@@ -0,0 +1,8 @@
+<h1 style="margin: 0; padding: 0; font-size: 18px; font-weight: bold;">Message</h1>
+<% if @body %>
+<ul>
+<% @body.each do |key, value| %>
+  <li style="white-space: pre-line"><%= key %>: <%= value %></li>
+<% end %>
+</ul>
+<% end %>

data/app/views/has_helpers/email_notifier/system.text.erb

@@ -0,0 +1,7 @@
+Message
+=============
+<% if @body %>
+<% @body.each do |key, value| %>
+<%= key %>: <%= value %>
+<% end %>
+<% end %>

data/app/views/has_helpers/enumerables/_enumerable.html.erb

@@ -0,0 +1 @@
+<%= render enumerable.map(&:to_renderable) %>

data/app/views/has_helpers/icons/_icon.html.erb

@@ -0,0 +1 @@
+<i <%= render icon.html_attrs %>></i>

data/app/views/has_helpers/render_objects/_render_object.html.erb

@@ -0,0 +1 @@
+<%= render *render_object.args %>

data/app/views/has_helpers/services/_service.html.erb

@@ -0,0 +1 @@
+<a href="<%= service.url %>" <%= render service.html_attrs %> <% if service.external %> rel="external" target="_blank"<% end %> ><% if service.icon && service.icon_placement == :left %><%= render service.icon %> <% end %><%= service %><% if service.icon && service.icon_placement == :right %> <%= render service.icon %> <% end %></a>

data/app/views/has_helpers/text_nodes/_text_node.html.erb

@@ -0,0 +1,4 @@
+<%# Render the text node string. If html attrs are present then wrap the text in a span %>
+<% if text_node.html_attrs.any? %><span <%= render text_node.html_attrs %>><% end %>
+  <%= text_node %>
+<% if text_node.html_attrs.any? %></span><% end %>

data/app/views/has_helpers/ui_attributes/_html_attrs.html.erb

@@ -0,0 +1 @@
+<% html_attrs.each do |k,v| %> <%= k.to_s.dasherize %><% unless v.nil? %>="<%= v %>"<% end %><% end %>

data/app/workers/elasticsearch_process_queue.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ElasticsearchProcessQueue
+  def self.perform_async(*args)
+    if ::Rails.application.config.x.goodjob_elasticsearch_enabled == true
+      ::GoodJob::ElasticsearchProcessQueue.perform_later(*args)
+    else
+      ::Sidekiq::ElasticsearchProcessQueue.perform_async(*args)
+    end
+  end
+end

data/app/workers/elasticsearch_reindex.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ElasticsearchReindex
+  def self.perform_async(*args)
+    if ::Rails.application.config.x.goodjob_elasticsearch_enabled == true
+      ::GoodJob::ElasticsearchReindex.perform_later(*args)
+    else
+      ::Sidekiq::ElasticsearchReindex.perform_async(*args)
+    end
+  end
+end

data/app/workers/elasticsearch_reindex_scheduler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class ElasticsearchReindexScheduler
+  include ::Sidekiq::Worker
+  sidekiq_options queue: "elasticsearch_reindex"
+
+  def perform(index_class_name)
+    index_class = index_class_name.constantize
+
+    logger.info "ElasticsearchReindexScheduler #{index_class_name}"
+
+    return self.class.perform_in(1.minute, index_class) unless index_class.indexing_allowed? || !index_class.is_heavy_index
+
+    starting_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    options = { index_class_name: index_class_name, start_time: starting_time }
+
+    reindex_batch = Sidekiq::Batch.new
+    reindex_batch.on(:success, self.class, options)
+    reindex_batch.description = "Reindex for #{index_class_name} started at #{DateTime.current.iso8601}"
+    reindex_batch.jobs do
+      index_class.reindex
+    end
+
+    ::HasUtils::Env.run_on_environment(::HasUtils::Env::TEST) do
+      if Sidekiq::Testing.inline?
+        on_success("status", options)
+      end
+    end
+  end
+
+  def on_success(_status, options)
+    index_class_name = options["index_class_name"]
+    ::Stat.save_to_stats(::Stat.new, index_class_name, "Elasticsearch", "Reindex", index_class_name.constantize.model.table_name, options["start_time"], Process.clock_gettime(Process::CLOCK_MONOTONIC))
+  end
+end

data/app/workers/good_job/configurable_backfill.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# You can use to run this backfill i.e: ::GoodJob::ConfigurableBackfill.perform_async([:texts], columns: [:from_phone_number], start_updated_at: "2022-02-15", end_updated_at:"2023-02-26")
+# possible options:
+# columns --> dn columns to update
+# start_updated_at -> start date of the records to update
+# end_updated_at -> end date of the records to update
+# ids -> ids of the records to update
+# organization_id -> organization_id of the records to update
+
+module GoodJob
+  class ConfigurableBackfill < HasUtils::GoodJob::BaseWorker
+    include HasUtils::GoodJob::UniqueJob
+    STARTED = "STARTED"
+    FINISHED = "FINISHED"
+    LOCKED = "LOCKED"
+    STAT_TYPE = "denormalization"
+    STAT_SUBTYPE = "configurable_backfill"
+
+    queue_as :dn
+    self.unique_until_start = true
+
+    COLUMNS_DENORMALIZED = {
+      texts: "::GoodJob::DN::BackfillTextDenormalization"
+    }
+
+    good_job_control_concurrency_with(
+      key: -> { "db-configurable-backfill" },
+      perform_limit: 10
+    )
+
+    def perform(table_names = [], options = {})
+      starting_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      save_to_stats(table_names, STAT_TYPE, STAT_SUBTYPE, { table: table_names, options: options, status: STARTED, errors: nil }, starting_time, starting_time)
+      begin
+        backfill_tables(table_names, **options)
+      rescue => e
+        save_to_stats(table_names, STAT_TYPE, STAT_SUBTYPE, { table: table_names, options: options, status: LOCKED, errors: e&.message }, starting_time, ::Process.clock_gettime(::Process::CLOCK_MONOTONIC))
+        return
+      end
+      save_to_stats(table_names, STAT_TYPE, STAT_SUBTYPE, { table: table_names, options: options, status: FINISHED, errors: nil }, starting_time, ::Process.clock_gettime(::Process::CLOCK_MONOTONIC))
+    end
+
+    def backfill_tables(table_names, **options)
+      table_names.each do |table_name|
+        backfill_run(COLUMNS_DENORMALIZED[table_name.to_sym], **options)
+      end
+    end
+
+    def backfill_run(backfill_name, **options)
+      # execute the backfills corresponding to the resource
+      backfill_name.classify.constantize.new.run(**options)
+    end
+
+    def save_to_stats(name, type, subtype, data, _starting_time, _ending_time = 0)
+      stat = ::HasHelpers::Stat.new
+      stat.name = name
+      stat.maintype = type
+      stat.subtype = subtype
+      stat.data = data
+      stat.save!
+    end
+  end
+end