has_helpers 5.0.2

data/app/presenters/has_helpers/resource/email_presenter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class HasHelpers::Resource::EmailPresenter < ::HasHelpers::Resource::RowPresenter
+  attr_accessor :wrapped_object, :current_user
+
+  def title
+    wrapped_object.address
+  end
+
+  def subtitle
+    wrapped_object.location
+  end
+
+  def cells
+    ::HasHelpers::Resource::CellPresenter.wrap([
+                                                 { value: wrapped_object.address,
+                                                   service: service },
+                                                 { value: wrapped_object.location,
+                                                   is_header: true,
+                                                   is_primary: wrapped_object.is_primary,
+                                                   primary_title: wrapped_object["primary_title"] || "Preferred Email" }
+                                               ])
+  end
+
+  def service
+    "mailto:#{wrapped_object.address}"
+  end
+
+  delegate :is_primary, to: :wrapped_object
+
+  def primary_title
+    wrapped_object["primary_title"] || "Preferred Email"
+  end
+end

data/app/presenters/has_helpers/resource/form_presenter.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+class HasHelpers::Resource::FormPresenter < ::HasHelpers::BasePresenter
+  include ::HasForms::FormBuilder if defined?(::HasForms::FormBuilder)
+  attr_writer :current_user, :current_organization, :params
+
+  def express_form(*args)
+    if wrapped_object.express_step.nil? && wrapped_object.new_record?
+      wrapped_object.express_step = "basic_info"
+    elsif wrapped_object.express_step != "basic_info" && wrapped_object.new_record?
+      wrapped_object.express_step = "basic_info"
+      wrapped_object.errors.add(:express_step, "You must complete the first step to continue!")
+    end
+
+    options = args.extract_options!
+
+    resource = wrapped_object.class.name.demodulize.underscore
+    cancel_service =
+      if wrapped_object.new_record?
+        routes.send("new_#{ resource }_path")
+      else
+        routes.send("edit_#{ resource }_path", wrapped_object) << "/#{ wrapped_object.express_step }"
+      end
+
+    options.merge!(
+      legend: wrapped_object.express_step.titleize,
+      cancel_service: cancel_service,
+      submits: [
+        save_and_continue_options,
+        { name: "save_&_finish", value: "Save & Finish", skin: "btn btn-default" }
+      ]
+    )
+
+    form_builder(wrapped_object, options) do |form|
+      form.hidden_field :express_step, value: wrapped_object.express_step.html_safe # rubocop:disable Rails/OutputSafety
+
+      next_express_step = express_form_steps(form)
+
+      if next_express_step
+        form.hidden_field :next_express_step, prefix: "", value: next_express_step.html_safe # rubocop:disable Rails/OutputSafety
+        unless wrapped_object.new_record?
+          form.element.links << { caption: "Next Step", service: "#{form.element.service}/edit/#{ URI.parser.escape(next_express_step.to_s) }" }
+        end
+      end
+    end
+  end
+
+  def params
+    @params || (controller && controller.params)
+  end
+
+  def current_user
+    @current_user || (controller && controller.current_user)
+  end
+
+  def current_organization
+    @current_organization || (controller && controller.current_organization)
+  end
+
+  def authorize_active_element_proc
+    @authorize_active_element_proc ||=
+      ->(fieldset) do
+        if fieldset.respond_to?(:legend) && fieldset.legend.present?
+          controller.current_ability.can?(:read, fieldset.legend)
+        else
+          true
+        end
+      end
+  end
+
+  private
+
+  def save_and_continue_options
+    { name: "save_&_continue", value: "Save & Continue", skin: "btn btn-default form-submit-save", primary: true }
+  end
+end

data/app/presenters/has_helpers/resource/info_collection_presenter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# This class is used to present a collection of related entities.  Be careful to use ::new instead of ::wrap to instantiate.
+class HasHelpers::Resource::InfoCollectionPresenter < ::HasHelpers::BasePresenter
+  attr_writer :entities
+
+  # FIXME: It seems like there should be a better way to accomplish is_first, is_last without putting logic into the template (see _collection.html.erb)
+  def entities
+    entities = @entities
+
+    if entities.length == 1
+      entities.first.is_first = true
+      entities.first.is_last = true
+    elsif entities.length > 1
+      entities.first.is_first = true
+      entities.first.is_last = false
+
+      entities[1..-2] && entities[1..-2].each do |related_entity|
+        related_entity.is_first = false
+        related_entity.is_last = false
+      end
+
+      entities.last.is_first = false
+      entities.last.is_last = true
+    end
+
+    entities
+  end
+
+  def has_multiple?
+    @entities && @entities.length > 1
+  end
+end

data/app/presenters/has_helpers/resource/info_presenter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# This class is used to present the informational details of a resource such as name, contact info, and provide service URLs for the resource.
+class HasHelpers::Resource::InfoPresenter < ::HasHelpers::Resource::FormPresenter
+  attr_accessor :title, :current_user, :details_lists, :contact_info_caption, :is_primary, :is_warning, :is_first, :is_last
+  attr_writer   :entity, :name, :service
+
+  def contact_info_service
+    service
+  end
+
+  def name
+    @name || (entity.respond_to?(:name) ? entity.name : nil)
+  end
+
+  # Returns a URL to the service associated with this entity
+  def service
+    @service ||=
+      if @service.nil?
+        "/#{entity.class.to_s.tableize}/#{entity.id}" if entity && entity.class.respond_to?(:table_name)
+      else
+        @service
+      end
+  end
+
+  def wrapped_object
+    @wrapped_object || @entity
+  end
+
+  # alias_method :entity, :wrapped_object
+  def entity
+    wrapped_object
+  end
+end

data/app/presenters/has_helpers/resource/list_presenter.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# HasHelpers::Resource::ListPresenter is used to represent overview information for a resource record.
+# The presenter is meant to display tabular data. Each list presenter has rows (RowPresenters) and each
+# row has cells (CellPresenters).
+class HasHelpers::Resource::ListPresenter < ::HasHelpers::BasePresenter
+  attr_writer :actions, :header_options, :icons,
+              :current_user # Used to pass through to presenters for content
+  attr_accessor :service, :caption, :caption_template, :caption_options, :subcaption, :headers, :is_sublist, :is_dropdown, :skin
+
+  # Content attributes:  +rows+, +items+, +tags+
+  #
+  # These attributes provide different ways to specify the content of the current list presenter. Either +rows+ or +items+ can be used to
+  # specify tabular data (rows and cells). The difference between +rows+ and +items+ is that +rows+ must be instances of
+  # HasHelpers::Resource::RowPresenter. +items+ will be converted from Hash arguments into RowPresenter instances (if necessary).
+  #
+  # +tags+ can be used for a list which does not need tabular display but rather can be display in
+  # any manner, such as a horizontal list (wrapped).
+  #
+  # Use +rows+, +items+ and +tags+ _exclusively_
+  #
+  attr_writer :rows # +rows+ Represents the data for the current list and should be set to a either a collection of CellPresenters instances.
+  #
+  # E.g., :rows => [
+  #   HasHelpers::Resource::RowPresenter.new(:items => [{:value => "Hello"}, {:value => "World"}]),
+  #   HasHelpers::Resource::RowPresenter.new(:items => [{:value => "Adios"}])
+  # ]
+  # This manner of setting Row presenters explicitly offers the most flexibility and control.
+
+  attr_accessor :items # +items+ should be an array where each element represents a row and is either an Array of hash values (suitable to create
+  # Cell instances) or a Hash of options for a new RowPresenter. This is a shortcut alternative to setting the +rows+ attribute.
+  #
+  # Example, each element in +items+ represents a row, and each subelement beneath those represents the values for a cell.
+  #   :items => [
+  #     {:toggle => true, :items => [{:value => "Hello"}, {:value => "World"}]},  # Options for first row, two cells
+  #     {:is_child => true, :toggle => true, :items => [{:value => "Adios"}]}     # Options for second row, one cell
+  #   ]
+  #
+  # Example, each element in +items+ represents a row, and each subelement beneath those represents the values for a cell.
+  #   :items => [
+  #     [{:value => "Hello"}, {:value => "World"}],  # Items for first row, two cells
+  #     [{:value => "Adios"}]                        # Items for second row, one cell
+  #   ]
+  #
+  #   ### NOTE: the above code is equivalent to
+  #   # :items => [
+  #   #   {:items => [{:value => "Hello"}, {:value => "World"}]},
+  #   #   {:items => [{:value => "Adios"}]}
+  #   # ]
+  #
+  # In some cases it may be desirable to leave a cell blank, in which case :blank => true should be used. There is also
+  # a :colspan option to have a cell across multiple columns. See HasHelpers::Resource::CellPresenter.
+
+  attr_writer :tags # +tags+ represents a list of non-tabular data and gets its name from its original use similar to a tag cloud.
+  # Tags are intended for horizontal lists which wrap to the container. Each tag displays a data point with an optional
+  # service link. +tags+ should be set to a collection for which each element is either value for a TagPresenter or
+  # a Hash of options for a tag presenter (which may be useful if options in addition to :value are needed).
+  #
+  # Example
+  #   :tags => ["Lead", "Prospect"]
+  #
+  # Example - equivalent to the previous example
+  #   :tags => [{:value => "Lead"}, {:value => "Prospect"}]
+  #
+  # Example - InfoPresenters may be passed as values for tags, see TagPresenter for details.
+  #   writing_advisor_info_presenters = ::HasHelpers::Resource::InfoPresenter.wrap(client.advisors)
+  #   :tags =>  writing_advisor_info_presenters
+
+  # Returns the assigned values of +@rows+ or items converted to rows.
+  def rows
+    @rows_memoized ||= @rows || items_to_rows # rubocop:disable Naming/MemoizedInstanceVariableName
+  end
+
+  # Returns presenter instances for all the options passed to :tags
+  def tags
+    @tags_memoized ||= (@tags || []).map do |tag_options| # rubocop:disable Naming/MemoizedInstanceVariableName
+      case tag_options
+      when ::HasHelpers::Resource::TagPresenter then tag_options
+      else ::HasHelpers::Resource::TagPresenter.new(tag_options)
+      end
+    end
+  end
+
+  # Some lists may have data which should not be display in the initial (closed) state, but which should be
+  # accessible when a user toggles to an open state.
+  def has_rows_to_toggle
+    rows.present? && rows.any?(&:toggle)
+  end
+
+  def actions
+    (@actions || []).map do |action_or_attrs|
+      if action_or_attrs.is_a?(Hash)
+        ::HasHelpers::Resource::ActionPresenter.new(action_or_attrs)
+      else
+        action_or_attrs
+      end
+    end
+  end
+
+  def header_details_template
+    header_options[:template]
+  end
+
+  def header_options
+    @header_options || {}
+  end
+
+  def icons
+    @icons || []
+  end
+
+  private
+
+  def items_to_rows
+    @items && @items.map do |values|
+      options = values.is_a?(Array) ? { items: values } : values # Support two forms of options; either an Array of items to pass through to the row presenter as the value for the :items key, or a hash of values to use when instantiating the row presenter
+      ::HasHelpers::Resource::RowPresenter.new(options.reverse_merge(current_user: @current_user))
+    end
+  end
+end

data/app/presenters/has_helpers/resource/note_presenter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module HasHelpers::Resource::NotePresenter
+  def note_items
+    @note_items ||= begin
+                      if wrapped_object.respond_to?(:note)
+                        note = wrapped_object.note
+                      elsif wrapped_object.respond_to?(:demographic) && wrapped_object.demographic.respond_to?(:note)
+                        note = wrapped_object.demographic.note
+                      end
+                      note.blank? ? [] : [[{ value: note }]]
+                    end
+  end
+end

data/app/presenters/has_helpers/resource/row_presenter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class HasHelpers::Resource::RowPresenter < ::HasHelpers::BasePresenter
+  attr_accessor :service, :is_child, :is_primary,
+                :toggle, # When set to true the visibility of the current row can be toggled on and off (off by default). This is used to initially hide contact info which is NOT primary.
+                :template, # When set the row will be rendered using the specified template rather than the default row template.
+                # For example the "tags" template can be specified when :value is set to a collection of TagPresenter
+                # objects, and there is a special template for policy advisors.
+                :is_section_header,
+                :items # +items+ should be an array of hash values suitable to create Cell instances.
+  # Set +items+ as an alternative to setting +cells+
+  attr_writer :cells,
+              :current_user # Used to pass through to presenters for content
+
+  # Returns the assigned value of +@cells+ or items converted to cells.
+  def cells
+    @cells ||= items_to_cells
+  end
+
+  private
+
+  def items_to_cells
+    @items && ::HasHelpers::Resource::CellPresenter.wrap_with_options(@items, current_user: @current_user)
+  end
+end

data/app/presenters/has_helpers/resource/tag_presenter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class HasHelpers::Resource::TagPresenter < ::HasHelpers::BasePresenter
+  attr_writer :value # This will be displayed as the content of the tag. By default it will be rendered
+  # as a string, but other objects may be displayed by using a different template.
+  # In particular a value may be an instance of ::HasHelpers::Resource::infoPresenter.
+
+  attr_writer :template # When set, the tag presenter will be rendered with the given template. The only
+  # use I can think of right now is using a related_entity template (value must be
+  # set to an instance of Resource::InfoPresenter)
+
+  def template
+    @template || detect_template_from_value
+  end
+
+  def value
+    wrapped_object
+  end
+
+  private
+
+  def detect_template_from_value
+    case value
+    when ::HasHelpers::Resource::InfoPresenter then "info_tag"
+    end
+  end
+
+  def wrapped_object
+    @wrapped_object || @value
+  end
+end

data/app/presenters/has_helpers/search_presenter.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+class HasHelpers::SearchPresenter < ::HasHelpers::BasePresenter
+  class DetailListPresenter < ::HasHelpers::BasePresenter
+    class DetailItemPresenter < ::HasHelpers::BasePresenter
+      attr_accessor :skin, :abbreviation
+      attr_writer :name, # String value to be displayed
+                  :value, # TODO: Refactor name to value *
+                  :icons,
+                  :format,
+                  :meta # Holds metadata for the detail item.
+      alias_method :icon=, :icons=
+
+      # === Returns
+      # One of the following in the given order:
+      # - The string explicitly set using the :name option.
+      # - The value passed as the :value option.
+      # - The name attribute of the wrapped object, if the object is present and responds to name (i.e. ActiveRecord models).
+      # - The wrapped_object itself, which is useful for just passing a string instead of a Hash arguments.
+      def value
+        unformatted_value = @name || @value || (wrapped_object && wrapped_object.try(:name)) || wrapped_object
+
+        transformed_value =
+          case @format
+          when "date" then Chronic.parse(unformatted_value)
+          else
+            unformatted_value
+          end
+        @format ? ::HasHelpers::Helpers::Application.send("format_#{ @format }", transformed_value) : transformed_value
+      end
+
+      def icons
+        [*(@icons || @icon)].lazy.map(&:to_icon)
+      end
+
+      def meta
+        @meta ||= {}
+      end
+
+      def to_h
+        { name: value }
+      end
+    end
+
+    attr_accessor :skin
+
+    def details
+      (wrapped_object || []).lazy.select do |_heading, *items|
+        items.any?
+      end.map do |heading, *items|
+        detail_items = (
+          case items.first
+          when Hash then [items.first]
+          else
+            [*[*items].first] # [*[*items].first] handles *items catching either a single record instance or an array of hashes.
+          end
+        ).map do |detail_args|
+          unless detail_args.has_key?("format")
+            # Automatically select format
+            format = heading.to_s.singularize.underscore
+            if ::HasHelpers::Helpers::Application.respond_to?("format_#{ format }")
+              detail_args["format"] = format
+            end
+          end
+
+          DetailItemPresenter.new(detail_args)
+        end
+
+        [
+          heading,
+          detail_items,
+          detail_items.all? { |item| item.skin && item.skin.include?("sub-item") } ? "sub-item-group" : nil
+        ]
+      end
+    end
+
+    def to_h
+      details.map do |heading, detail_items, skin|
+        {
+          id: detail_items.hash,
+          heading: heading,
+          detail_items: detail_items,
+          skin: skin
+        }
+      end
+    end
+  end
+
+  class ResultPresenter < ::HasHelpers::BasePresenter
+    attr_accessor :name, :id, :klass, :is_heading, :search_submit,
+                  :photo_info, :sub_item, :sub_item_type, :screen, :abbreviation, :show_type
+    attr_writer :details, :icon, :klass_name, :service, :type
+
+    def detail_list
+      details = @details || {}
+      detail_list_options = { wrapped_object: details }
+      detail_list_options[:skin] = "sub-item-only" if @details.blank? || (@details && @details.all? { |_k, v| v.blank? })
+      DetailListPresenter.new(detail_list_options)
+    end
+
+    def icon
+      !photo_service && @icon # && @icon.to_icon # only return icon name
+    end
+
+    def photo_service
+      if @photo_service_memoized
+        @photo_service
+      else
+        @photo_service_memoized = true
+        @photo_service ||= ::HasHelpers::Helpers::Application.photo_info_service(
+          @photo_info,
+          application: ->(resource_typish, *_) { %w[users organizations].include?(resource_typish) ? "hqadmin" : ::HasHelpers::Application.project }
+        )
+      end
+    end
+
+    def service
+      @service ||= "/#{ klass_name.demodulize.tableize }/#{ id }".to_service
+      @service.respond_to?(:call) ? @service.call : @service
+    end
+
+    def klass_name
+      @klass_name || klass.name
+    end
+
+    def base_type
+      @type&.safe_constantize&.base_class&.name
+    end
+
+    def type
+      return unless show_type && @type
+      @type.demodulize.titleize
+    end
+
+    def to_h
+      {
+        image_url: photo_service&.url,
+        icon: icon,
+        abbreviation: abbreviation,
+        label: name,
+        value: id,
+        sub_item: sub_item,
+        details: detail_list.to_h,
+        type: type,
+        baseType: base_type&.demodulize,
+        screen: screen,
+        showType: show_type
+      }
+    end
+  end
+
+  attr_writer :search_submit, :results_id_field
+  attr_accessor :screen, :multiscreen, :inline_add, :page, :per_page, :show_type, :exact_submit
+
+  # Returns an associative Array, where the keys are screen names and values are collections of results.
+  def results(
+    format_ungrouped: false # When set to true the results will NOT be grouped.
+  )
+    intermediate_results = raw_results || {}
+
+    intermediate_results = intermediate_results.map do |result|
+      case result
+      when ::ActiveRecord::Base
+        # `result` should be an owner detail object, e.g. an OwnerAdvisor rather than an Advisor.
+        ResultPresenter.new(
+          name: result.try(:name),
+          type: result.try(:type) || result.class.name,
+          klass: result.class,
+          service: -> { result.to_service }, # Service may not be needed, so delay its evaluation by wrapping it in a proc.
+          id: result.try(results_id_field),
+          details: result.try(:detail) || {},
+          sub_item: result.try(:sub_item),
+          sub_item_type: result.try(:sub_item_type),
+          photo_info: result.try(:photo_info),
+          icon: result.try(:icon) || :circle,
+          abbreviation: result.try(:abbreviation),
+          search_submit: search_submit.is_a?(Proc) ? search_submit.call(result) : search_submit,
+          screen: screen,
+          show_type: show_type
+        )
+      when ::Hash
+        ResultPresenter.new(result)
+      else  # Handles String, which is displayed as a heading
+        ResultPresenter.new(name: result.to_s.titleize, is_heading: true)
+      end
+    end
+
+    if format_ungrouped
+      intermediate_results.map(&:to_h)
+    else
+      # Wrap the results in a hash if they are not already.
+      intermediate_results = { nil => intermediate_results } unless intermediate_results.respond_to?(:keys) || intermediate_results.try(:blank?)
+      intermediate_results
+    end
+  end
+
+  def raw_results
+    wrapped_object
+  end
+
+  def search_submit
+    @search_submit_memoized ||= if @multiscreen # rubocop:disable Naming/MemoizedInstanceVariableName
+      if @exact_submit
+        @exact_submit
+      elsif @search_submit.is_a?(Proc)
+        -> result { "#{ @search_submit[result] }[#{ @screen.singularize.foreign_key }]" }
+      else
+        "#{ @search_submit }[#{ @screen.singularize.foreign_key }]"
+      end
+    else
+      @search_submit
+    end
+  end
+
+  def icon
+    @icon && @icon.to_icon("icon-item")
+  end
+
+  def to_h
+    results.map do |group, results|
+      { name: group, results: results.map(&:to_h) }
+    end
+  end
+
+  private
+
+  def results_id_field ### We could also do the same thing with name, table_name, etc. if needed. ###
+    @results_id_field || :id
+  end
+end

data/app/triggers/has_helpers/erase_denormalized_belongs_to_column_trigger.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class EraseDenormalizedBelongsToColumnTrigger < ::PsqlHq::Trigger
+    attr_reader :owner_table, :owner_column, :affected_table, :update_fields, :column_to_evaluate
+
+    # owner_table -> table where the trigger resides
+    # owner_column -> column where the trigger resides
+    # affected_table -> table where the update it is made
+    # update_fields -> columns to be changed in affected_table - can be an array or not
+    # column_to_evaluate -> condition that evaluates if the change has to be made or not (eg. writing advisor that belongs to an opportunity has to have opportunity_id not null)
+    def initialize(owner_table, owner_column, affected_table, update_fields, column_to_evaluate, **options)
+      @owner_table = owner_table
+      @owner_column = owner_column
+      @affected_table = affected_table
+      @update_fields = update_fields
+      @column_to_evaluate = column_to_evaluate
+      super(owner_table, update_fields, options)
+    end
+
+    def self.prefix
+      "HQD"
+    end
+
+    # if array then use this
+    def affected_fields
+      update_fields.kind_of?(Array) ? update_fields.join(" = NULL, ") : update_fields.to_s
+    end
+
+    def name
+      fields_name = update_fields.kind_of?(Array) ? update_fields.join("_") : update_fields.to_s
+      "#{fields_name}_on_#{affected_table}_#{owner_table.downcase}"
+    end
+
+    def drop
+      self.drop_by_function_name(function_name)
+    end
+
+    def create
+      ::ActiveRecord::Base.connection.execute sql_to_add_function
+      after_or_before = trigger_after? ? "AFTER" : "BEFORE"
+      ::ActiveRecord::Base.connection.execute <<-SQL
+        CREATE TRIGGER "#{trigger_name}"
+        #{after_or_before} DELETE
+        ON #{owner_table}
+        FOR EACH ROW
+        EXECUTE PROCEDURE "#{function_name}"();
+      SQL
+      puts "-- Created trigger #{trigger_name} and function #{function_name}."
+    end
+
+    private
+
+    def trigger_after?
+      false
+    end
+
+    def sql_to_add_function
+      <<-END_OF_SQL
+        CREATE OR REPLACE FUNCTION public."#{function_name}"()
+          RETURNS trigger
+          LANGUAGE 'plpgsql'
+          SECURITY DEFINER
+          AS $function$
+          BEGIN
+            UPDATE
+              #{affected_table}
+            SET
+              #{update_fields} = NULL
+            WHERE
+              #{column_to_evaluate} = OLD.#{owner_column};
+            RETURN OLD;
+          END
+          $function$;
+      END_OF_SQL
+    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