has_helpers 5.0.2

data/app/models/has_helpers/user_methods.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module HasHelpers::UserMethods
+  REMOTE_ATTRS = %w[first_name last_name photo_file_name photo_content_type photo_file_size photo_updated_at]
+
+  # Including apps' user models can use this to set common settings
+  # for user photos.
+  PHOTO_OPTIONS = {
+    # Always use the hqadmin bucket for user photos
+    bucket: "hqadmin-#{::HasUtils::Env.current_environment}", # TODO: upgrade paperclip to 6 and you can use  -> { "#{::HasHelpers::Application::HQADMIN.name}-#{ ::HasUtils::Env.current_environment }" },
+  }.freeze
+
+  def self.included(base)
+    base.class_eval do
+      attr_accessor :skip_update_master_record # When set to a truthy value this prevents pushing changes to the AdminHQ API on save.
+      attr_accessor :master_record_attributes # Set with the attributes returned from pushing user changes to the AdminHQ API
+      attr_accessor :extra_attributes # Stores information retrieved from hqsso. These can be handled every time cas_extra_attributes=
+      # is called by creating a method called handle_extra_attributes on the class/module that includes this module.
+
+      def ip_whitelist
+        # The support user does not have an IP whitelist.
+        # Support users can log in from anywhere.
+        return nil if is_support?
+        [*super, *organization.ip_whitelist].presence
+      end
+
+      serialize :permissions_hash, type: Hash
+      serialize :applications_array, type: Array
+
+      # Runs within the save transaction. Pushes changes to IAMHQ
+      # Do not run this callback from within IAMHQ
+      after_save :update_master_record,
+                 unless: -> { HasHelpers::Application.current_application == ::HasHelpers::Application::HQADMIN || skip_update_master_record }
+
+      after_commit :save_master_record_attributes, if: :master_record_attributes
+    end
+    base.send(:include, InstanceMethods)
+  end
+
+  module InstanceMethods
+    def cas_extra_attributes=(extra_attributes)
+      org_id = extra_attributes["organization_id_or_uuid"] || extra_attributes["organization_id"]
+      org = ::HasHelpers::Organization.find_or_initialize_by(id: org_id)
+      time_zone = ::TimeZone.find_by(name: extra_attributes["organization_time_zone_name"])
+      if time_zone.nil?
+        time_zone = org.time_zone
+        data = {
+          message: "TimeZone Lookup Failed",
+          organization: org.inspect,
+          user: self.inspect,
+          extra_attributes: extra_attributes,
+        }.inspect
+        HasHelpers::LogNotifier.notify(
+          HasHelpers::HQException.new(data, backtrace: caller)
+        )
+      end
+
+      organization_attributes = {
+        code_name: extra_attributes["organization_code_name"],
+        domain: extra_attributes["organization_domain"],
+        ip_whitelist: extra_attributes["organization_ip_whitelist"],
+        is_use_roles_for_authorization: extra_attributes["organization_is_use_roles_for_authorization"],
+        name: extra_attributes["organization_name"],
+        time_zone_id: time_zone.id,
+      }
+      organization_attributes[:is_active] = extra_attributes["organization_is_active"] if ::HasHelpers::Organization.column_names.include?("is_active")
+      organization_attributes[:start_date] = extra_attributes["organization_go_live_date"] if org.start_date.blank?
+
+      if !org.update(organization_attributes) && ::Rails.application.config.x.support_email_address.present?
+        notifier_body = {
+          "User" => username,
+          "Class" => self.class.name,
+          "Org ID" => org.id,
+          "Organization name" => org.name,
+          "Org name of extra attrs" => extra_attributes["organization_name"] || "no attr found",
+          "Test org name" => extra_attributes["organization_name_test"] || "no name found",
+          "Created at" => extra_attributes["created_at_test"],
+          "Errors" => org.errors.full_messages.join(", "),
+          "Backtrace" => Thread.current.backtrace.first(100),
+        }
+        ::HasHelpers::EmailNotifier.system(subject: "Error synchronizing organization attributes", to: "tools@onehq.com", body: notifier_body).deliver_now
+      end
+
+      # Ensure there's a join
+      link = user_organizations.find_or_initialize_by(organization_id: org.id)
+      link.is_primary = true
+
+      self.assign_attributes(
+        applications_array: extra_attributes["user_applications_array"],
+        import_key: extra_attributes["user_import_key"],
+        ip_whitelist: extra_attributes["user_ip_whitelist"],
+        is_support: extra_attributes["user_is_support"] ? true : nil, # bi-state bool here, regular bool in hqsso
+        permissions_hash: extra_attributes["user_permissions_hash"],
+        photo_content_type: extra_attributes["user_photo_content_type"],
+        photo_file_name: extra_attributes["user_photo_file_name"],
+        photo_file_size: extra_attributes["user_photo_file_size"],
+        photo_updated_at: extra_attributes["user_photo_updated_at"],
+        production_api_key: extra_attributes["user_production_api_key"],
+        staging_api_key: extra_attributes["user_staging_api_key"],
+        username: extra_attributes["user_username"],
+      )
+
+      self.first_name = extra_attributes["user_first_name"] if respond_to?(:first_name)
+      self.last_name = extra_attributes["user_last_name"] if respond_to?(:last_name)
+
+      # only for new users
+      if new_record?
+        self.id = extra_attributes["user_id"]
+        self.created_by = self
+        self.updated_by = self
+      end
+
+      # Do not push changes to HQAdmin since the latest changes are currently being applied.
+      # This is not strictly necessary, but it currenty prevents a pointless API call.
+      self.skip_update_master_record = true
+
+      self.extra_attributes = extra_attributes.select { |attr_name, _| attr_name.start_with?("user") }
+      org.extra_attributes = extra_attributes.select { |attr_name, _| attr_name.start_with?("organization") }
+      self.send(:handle_extra_attributes) if self.respond_to?(:handle_extra_attributes, true)
+      org.send(:handle_extra_attributes) if org.respond_to?(:handle_extra_attributes, true)
+      link.save!
+      # Make sure all other links are not primary
+      user_organizations.where.not(id: link.id).update_all(is_primary: nil)
+    end
+
+    def abbreviated_name
+      receiver = respond_to?(:demographic) ? demographic : self
+      "#{receiver.first_name}#{receiver.last_name.to_s.sub(/^(.).*/, ' \1.')}"
+    end
+
+    def is_admin?
+      applications_array.include?(::HasHelpers::Application::HQADMIN.name)
+    end
+
+    def is_super_user?
+      is_admin? || is_support?
+    end
+
+    protected
+
+    ###### normalizations ######
+
+    # Pushes changes to the master record (in HQAdmin) through an API.
+    # This should run within the save transaction so that a failed API request will
+    # prevent a local update.
+    def update_master_record
+      changed_attr_names = changed.select { |attr| REMOTE_ATTRS.include?(attr) } # Exclude some attributes from update
+      changed_attrs = attributes.slice(*changed_attr_names)
+
+      # Also grab changed attrs from the associated Demographic record (if applicable).
+      if respond_to?(:demographic) && demographic
+        # Need to access the previous_changes because the Demographic record (child) will be saved before the current user.
+        demographic.previous_changes.select { |attr, _values| REMOTE_ATTRS.include?(attr) }.each do |attr, (_, new_value)|
+          changed_attrs[attr] = new_value
+        end
+      end
+
+      if changed_attrs.any?
+        # TODO: 2015-04-01 Revert this code which disables SSL verification. This was only intended as a temporary measure to work around the issue described below. *
+        response = ::RestClient.post("#{::HasHelpers::Application::HQADMIN.url}/api/v1/users/#{id}", changed_attrs)
+        # response = ::RestClient::Resource.new("#{::HasHelpers::Application::HQADMIN.url}/api/v1/users/#{id}", verify_ssl: OpenSSL::SSL::VERIFY_NONE).post(changed_attrs)  # Turn off SSL verification which has recently started causing connection issues here due to our invalid cert for HQAdmin (in production).
+
+        response_data = JSON.parse(response.body)
+
+        self.master_record_attributes = response_data["user"] # Hold onto the user attributes received in the API response.
+        response_data["message"] == "success" # Returning a falsey value here will cancel the save operation when the current method is used as an after save callback.
+      end
+    end
+
+    def save_master_record_attributes
+      self.skip_update_master_record = true
+      attrs = master_record_attributes # Grab another reference to the new user attributes, so the virtual attribute can be cleared.
+      self.master_record_attributes = nil # Clear this out so the callback does not loop.
+
+      if respond_to?(:demographic) && demographic
+        remote_demographic_attrs = REMOTE_ATTRS.select { |remote_attr| demographic.respond_to?("#{remote_attr}=") } # Get a list of all the remote attrs which match up with Demographic
+        demographic.assign_attributes attrs.slice(*remote_demographic_attrs) # Do not update here. Allow the Demographic to be saved as part of the save operation for the current user in order to have all updates within a single transaction.
+      end
+
+      remote_user_attrs = REMOTE_ATTRS.select { |remote_attr| respond_to?("#{remote_attr}=") } # Get a list of all the remote attrs which match up with User
+      update attrs.slice(*remote_user_attrs) # In addition to updating the current user, this will save the Demographic record if one exists and is modified.
+    end
+  end
+end

data/app/models/has_helpers/user_organization.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class UserOrganization < ApplicationRecord
+    self.table_name = :user_organizations
+
+    ###### callbacks ######
+
+    ###### variables ######
+
+    ###### associations ######
+    belongs_to :organization, class_name: "::HasHelpers::Organization", optional: false
+    belongs_to :user, class_name: "::HasHelpers::User", optional: false
+
+    ###### triggers ######
+    auto_primary foreign_keys: ["user_id"]
+    after_delete_primary foreign_keys: ["user_id"]
+
+    ###### externals ######
+
+    ###### validations ######
+    validates :user_id, uniqueness: {
+      scope: :organization_id,
+      message: "The user already has this organization set"
+    }
+
+    ###### scopes ######
+
+    ###### class methods ######
+
+    ###### instance methods ######
+  end
+end

data/app/models/has_helpers/user_role.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class UserRole < ApplicationRecord
+    self.table_name = :user_roles
+
+    ###### callbacks ######
+    autoset :organization_id
+
+    ###### variables ######
+
+    ###### associations ######
+    belongs_to :role, optional: false
+    belongs_to :organization, class_name: "::HasHelpers::Organization"
+    belongs_to :user, class_name: "::HasHelpers::User", optional: false
+
+    ###### externals ######
+
+    ###### validations ######
+
+    ###### scopes ######
+
+    ###### class methods ######
+
+    ###### instance methods ######
+  end
+end

data/app/models/has_helpers/user_session.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class UserSession < ApplicationRecord
+    self.table_name = :user_sessions
+
+    ###### associations ######
+    belongs_to :user
+
+    ###### validations ######
+    validates :user_id, presence: true
+    validates :session_id, presence: true, uniqueness: { scope: [:user_id] }
+    validates :expired_at, presence: true
+
+    ###### scopes ######
+    scope :expired, -> { where("expired_at < ?", Time.current) }
+    scope :active, -> { where("? BETWEEN created_at AND expired_at", Time.current) }
+  end
+end

data/app/presenters/has_helpers/barcode_base_presenter.rb

@@ -0,0 +1,113 @@
+# typed: false
+# frozen_string_literal: true
+
+# An "abstract" superclass for BarcodePresenter subclasses. Each subclass must
+# overwrite the private #get_texts method to return the data that should be
+# rendered as barcodes.
+require "barby/barcode/code_128"
+require "barby/outputter/png_outputter"
+require "barby/outputter/html_outputter"
+
+module HasHelpers
+  class BarcodeBasePresenter < ::HasHelpers::BasePresenter
+    ##### CLASS METHODS #####
+
+    # Returns a BarcodePresenter class that matches the object passed in. It
+    # does this by looking for a BarcodePresenter matching the object's base
+    # class. For example, if the object is a Policy (or any subclass of Policy),
+    # this method will see if there is a Policy::BarcodePresenter class. If it
+    # finds a matching class, it returns the class; if not, it returns nil.
+    def self.get_presenter_class(object)
+      base_class_name = object.class.base_class.name
+      "::#{base_class_name}::BarcodePresenter".safe_constantize
+    end
+
+    # Same as #get_presenter_class, but raises an error if it cannot find a
+    # matching BarcodePresenter class.
+    def self.get_presenter_class!(object)
+      presenter_class = get_presenter_class(object)
+      raise "Cannot find a barcode presenter for #{object.class}." unless presenter_class
+      presenter_class
+    end
+
+    ##### INSTANCE METHODS #####
+
+    # Returns an array of hashes representing barcodes. Each hash has the
+    # following keys:
+    #   :text => String with the plain text version of the barcode
+    #   :image_src => String with the Base64-encoded barcode PNG, prefixed with
+    #                 the necessary inline image HTML prefix; intended to be
+    #                 the entire value needed for an IMG tag's SRC attribute
+    #   :last => Set to true for last barcode (to help rendering)
+    # It gets the actual content for the hashes from the #get_texts method,
+    # and then adds one more barcode representing the wrapped object's base
+    # class name.
+    def barcode_infos
+      @barcode_infos ||= begin
+                           texts = get_texts
+                           texts << ("#{base_class_name}/") if base_class_name
+
+                           infos = texts.map do |text|
+                             { text: text, image_src: barcode_inline_image_src(text) }
+                           end
+                           infos.last[:last] = true
+                           infos
+                         end
+    end
+
+    private
+
+    # All subclasses must overwrite this method to return an array of
+    # strings to generate barcodes for. The strings should already be formatted
+    # (upcased, invalid chars removed, max length enforced, etc.).
+    def get_texts # rubocop:disable Naming/AccessorMethodName
+      raise "Subclasses of HasHelpers::BarcodeBasePresenter must implement #get_texts."
+    end
+
+    # Returns a String that is the wrapped object's base class's name. Overwrite
+    # this in the subclass if you want it to return a different String, or set
+    # it to return nil if you don't want this included in the barcodes.
+    def base_class_name
+      @base_class_name ||= wrapped_object.class.base_class.name
+    end
+
+    # Returns a copy of the string passed in with the following changes:
+    # 1. Removes all non-alphanumeric chars. Note that this also removes
+    #    underscores, even though regex considers those alphanumeric - i.e.
+    #    we only preserve a-z, A-Z, and 0-9.
+    # 2. Upcases the string.
+    # 3. If a maximum length is passed in, truncates the string to be no longer
+    #    than that.
+    # If the string passed in is nil, returns an empty string.
+    def format_alphanumeric(str, maximum_length = nil)
+      return "" if str.blank?
+
+      formatted_string = str.upcase.gsub(/[^a-zA-Z\d]/, "")
+      formatted_string = formatted_string[0, maximum_length] if maximum_length
+      formatted_string
+    end
+
+    # Returns a copy of the string passed in with the following changes:
+    # 1. Removes all non-numeric chars.
+    # 2. If a maximum length is passed in, truncates the string to be no longer
+    #    than that.
+    # If the string passed in is nil, returns an empty string.
+    def format_numeric(str, maximum_length = nil)
+      return "" if str.blank?
+
+      formatted_string = str.gsub(/[\D]/, "")
+      formatted_string = formatted_string[0, maximum_length] if maximum_length
+      formatted_string
+    end
+
+    def barcode_inline_image_src(text)
+      "data:image/png;base64,#{barcode_base64(text)}"
+    end
+
+    # Takes the text passed in, returns a base64 string representing the PNG
+    # data for the barcode representation of that text.
+    def barcode_base64(text)
+      Base64.encode64(::Barby::Code128B.new(text).to_png(xdim: 2, height: 36))
+    end
+  end
+end

data/app/presenters/has_helpers/base_presenter.rb

@@ -0,0 +1,100 @@
+# typed: false
+# frozen_string_literal: true
+
+module HasHelpers
+  class BasePresenter
+    module Routing
+      # Returns an object which has the URL helpers for the current Rails application.
+      def self.routes
+        @routes ||= Class.new do
+          include Rails.application.routes.url_helpers # Including the helpers will mix in the polymorphic url helper methods in addition to the regular url helpers.
+        end.new
+      end
+    end
+
+    include ::HasHelpers::Attributes
+    attr_accessor :wrapped_object
+    attr_writer :errors
+
+    # Accepts an object or collection of objects and returns an
+    # Array of presenter instances wrapping each object.
+    def self.wrap(*args, **options)
+      if args.length == 1 && args[0].respond_to?(:map)
+        args[0].map do |data|
+          data_args = ::Array[data]
+          options = data_args.last.is_a?(Hash) ? data_args.pop : {}
+          new(*data_args, options)
+        end
+      else
+        [new(*args, **options)]
+      end
+    end
+
+    # Merges options with each element of the collection argument, and then calls
+    # .wrap passing the result
+    def self.wrap_with_options(collection, **options)
+      self.wrap(collection.lazy.map { |values| values.reverse_merge(options) })
+    end
+
+    def initialize(*args)
+      attrs = args.last.is_a?(Hash) ? args.pop : {}
+      self.wrapped_object = args.first
+      super(attrs) # run Attributes initializer
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && instance_variables.all? do |ivar|
+        instance_variable_get(ivar) == other.instance_variable_get(ivar)
+      end
+    end
+
+    def error_on(accessor_name, include_dot_keys: true)
+      return if errors.blank?
+
+      messages =
+        if errors.respond_to?(:messages)
+          errors.messages
+        else
+          errors
+        end
+
+      if include_dot_keys
+        keys = messages.keys.grep(/\A#{Regexp.quote(accessor_name.to_s)}(\z|\.)/)
+        keys.flat_map { |key| messages[key] }
+      else
+        messages[accessor_name.to_sym] || messages[accessor_name.to_s]
+      end
+    end
+
+    def errors
+      @errors || wrapped_object_errors || {}
+    end
+
+    # Convenience method for accessing application routes.
+    # === Examples
+    #   routes.advisor_path(@advisor)
+    #   routes.polymorphic_url([@advisor, @payment])
+    delegate :routes, to: :'::HasHelpers::BasePresenter::Routing'
+
+    private
+
+    def method_missing(name, *args, &block)
+      if (accessor_name = name.to_s[/\Ahas_error_on_(.*)\Z/, 1]) # Check for names such as `has_error_on_field_name`
+        error_on(accessor_name).present?
+      elsif (accessor_name = name.to_s[/\Ahas_(.*)\Z/, 1]) && respond_to?(accessor_name) # Check for names such as `has_some_method` and strip the leading `has_` portion.
+        result = send(accessor_name)
+        if result.is_a?(Enumerator) # Enumerable#present? does not return the expected value, e.g. `[].to_enum.present?  #=> true`
+          result.size && result.size > 0
+        else
+          result.present?
+        end
+      else
+        super
+      end
+    end
+
+    def wrapped_object_errors
+      wrapped_object && wrapped_object.respond_to?(:errors) && wrapped_object.errors
+    end
+  end
+end

data/app/presenters/has_helpers/cacheable_item.rb

@@ -0,0 +1,28 @@
+# typed: false
+# frozen_string_literal: true
+
+class HasHelpers::CacheableItem
+  attr_writer :cache_key
+  attr_accessor :promised_item
+
+  def initialize(key, item = nil, &block)
+    self.cache_key = key
+    self.promised_item = item || block
+  end
+
+  def item
+    ::HasHelpers::ItemPresenter.new(
+      case promised_item
+      when Proc then promised_item[]
+      else promised_item
+      end
+    )
+  end
+
+  def cache_key
+    case @cache_key
+    when ::ActiveRecord::Base then "#{@cache_key.class.name}/#{@cache_key.id}-#{@cache_key.updated_at.to_i}#{@cache_key['cache_key']}"
+    else @cache_key
+    end
+  end
+end

data/app/presenters/has_helpers/item_presenter.rb

@@ -0,0 +1,52 @@
+# typed: true
+# frozen_string_literal: true
+
+class HasHelpers::ItemPresenter < ::HasHelpers::BasePresenter
+  attr_accessor :selected, :is_heading, :name, :status, :highlight, :tag, :emphasized
+  attr_writer :details, :service, :image_service, :icon, :items,
+              :title, # Value used for the HTML title attribute. When set explicitly to `true` (`TrueClass`) then the value returned by `name` will be used as the title.
+              :data # Set with a hash of data-attribute key/value pairs.
+
+  def details
+    Array[*@details]
+  end
+
+  def service
+    @service && @service.to_service
+  end
+
+  def image_service
+    @image_service && @image_service.to_service
+  end
+
+  def cache_key
+    nil
+  end
+
+  def item
+    self
+  end
+
+  def icon
+    @icon && @icon.to_icon
+  end
+
+  def items
+    ::HasHelpers::ItemPresenter.new(items: @items) if @items
+  end
+
+  def title
+    case @title
+    when TrueClass then name
+    else @title
+    end
+  end
+
+  def attributes
+    (@data || {}).tap do |data_hash|
+      data_hash.keys.each do |k|
+        data_hash["data-#{k}"] = data_hash.delete(k)
+      end
+    end
+  end
+end

data/app/presenters/has_helpers/items_presenter.rb

@@ -0,0 +1,33 @@
+# typed: true
+# frozen_string_literal: true
+
+class HasHelpers::ItemsPresenter < ::HasHelpers::BasePresenter
+  attr_accessor :skin
+  attr_writer :items, :attributes
+
+  def items(i = @items)
+    @memoized_items ||= i.map do |item| # rubocop:disable Naming/MemoizedInstanceVariableName
+      case item
+      when ::HasHelpers::CacheableItem
+        item
+      else
+        ::HasHelpers::ItemPresenter.new(item)
+      end
+    end
+  end
+
+  def attributes
+    @attributes || []
+  end
+
+  def cache_key
+    @cache_key ||= if @cache_key_is_memoized
+      @cache_key_memoized
+    else
+      @cache_key_is_memoized = true
+      @cache_key_memoized = if (cache_key_items = items.map(&:cache_key)).all?
+        Digest::MD5.hexdigest cache_key_items.join
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class HasHelpers::Resource::ActionPresenter < ::HasHelpers::BasePresenter
+  attr_accessor :service, # href attribute
+                :title, # anchor title attribute
+                :icon, # Font awesome icon class, icon- prefix omitted, e.g. "angle-down" or "search"
+                :data # Collection of data attributes for action
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class HasHelpers::Resource::CellPresenter < ::HasHelpers::BasePresenter
+  # Content attributes +value+, +resource+ and +tags+. These attributes should be used exclusively.
+  attr_writer   :value,                 # +value+ will be displayed as the content of the current cell.
+                :resource               # Use +resource+ instead of +value+ when the target should be automatically wrapped in an InfoPresenter.
+  attr_accessor :tags                   # +tags+ will generate an unordered list using the collection it is set to.
+
+  attr_accessor :blank,                 # When set to true no output is generated for the content of the current cell. Without this option
+                # a nil value will be formatted to display "none" as the cell content.
+                :is_primary,
+                :primary_title,         # E.g. the wording of the indication that this object is a favorite
+                :service,               # When set the cell content is wrapped with an anchor tag which links to the given service URL.
+                :service_title,         # E.g. used for link title attributes
+                :is_service_external,   # When set to true the link for the cell (if any) should be externalized.
+                :is_header,             # E.g, If set to true the cell will be rendered within a <TH> tag instead of <TD>
+                :warning,               # When set to true an warning sign icon is displayed along with the cell content.
+                :is_text,               # Used to identify cells with long text values which may need extra styling (or formatting?)
+                :colspan
+  attr_writer   :template,              # Setting template will cause rendering to use a custom partial
+                :current_user           # Used to pass through to presenters for content
+
+  # Returns the content from either +value+ or resource.
+  def content
+    if @value.nil?
+      resource
+    elsif @value.present?
+      @value
+    end
+  end
+
+  def template
+    @template.nil? ? detect_template_from_value : @template
+  end
+
+  private
+
+  def detect_template_from_value
+    case content
+    when ::HasHelpers::Resource::InfoPresenter then "info"
+    end
+  end
+
+  # Return the resource object which was set, wrapped in an InfoPresenter.
+  def resource
+    case @resource
+    when ::HasHelpers::Resource::InfoPresenter, NilClass then @resource
+    when Hash then ::HasHelpers::Resource::InfoPresenter.new(@resource.reverse_merge(current_user: @current_user))
+    else ::HasHelpers::Resource::InfoPresenter.new(@resource, current_user: @current_user)
+    end
+  end
+end