alchemy_cms 8.3.11 → 8.4.1

data/app/models/alchemy/node.rb

@@ -1,7 +1,47 @@
 # frozen_string_literal: true
 
+# == Schema Information
+#
+# Table name: alchemy_nodes
+#
+#  id          :integer          not null, primary key
+#  depth       :integer          default(0), not null
+#  external    :boolean          default(FALSE), not null
+#  folded      :boolean          default(FALSE), not null
+#  lft         :integer          not null
+#  menu_type   :string           not null
+#  name        :string
+#  nofollow    :boolean          default(FALSE), not null
+#  rgt         :integer          not null
+#  title       :string
+#  url         :string
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#  creator_id  :integer
+#  language_id :integer          not null
+#  page_id     :integer
+#  parent_id   :integer
+#  updater_id  :integer
+#
+# Indexes
+#
+#  index_alchemy_nodes_on_creator_id   (creator_id)
+#  index_alchemy_nodes_on_language_id  (language_id)
+#  index_alchemy_nodes_on_lft          (lft)
+#  index_alchemy_nodes_on_page_id      (page_id)
+#  index_alchemy_nodes_on_parent_id    (parent_id)
+#  index_alchemy_nodes_on_rgt          (rgt)
+#  index_alchemy_nodes_on_updater_id   (updater_id)
+#
+# Foreign Keys
+#
+#  language_id  (language_id => alchemy_languages.id)
+#  page_id      (page_id => alchemy_pages.id) ON DELETE => restrict
+#
 module Alchemy
   class Node < BaseRecord
+    include Alchemy::RelatableResource
+
     VALID_URL_REGEX = /\A(\/|\D[a-z+\d.-]+:)/
     SKIPPED_ATTRIBUTES_ON_COPY = %w[id created_at updated_at creator_id updater_id lft rgt depth parent_id]
 
@@ -37,16 +77,27 @@ module Alchemy
     # Like #available_to_guests but including nodes attached to restricted pages,
     # which logged in members are allowed to see.
     scope :available_to_members, -> {
+      Alchemy::Deprecation.warn("Node.available_to_members is deprecated and will be removed in Alchemy 9.0. Use Node.available_to(user) instead.")
       from_current_public_site.where(page: nil)
         .or(from_current_public_site.where(page: Alchemy::Page.published))
     }
 
+    # Nodes the given user may see: external links or nodes attached to a
+    # published page the user is allowed to read. Mirrors +Page#readable_by?+
+    # so a node never reveals a page the user cannot open. Passing +nil+ yields
+    # the same result as #available_to_guests.
+    scope :available_to, ->(user) {
+      from_current_public_site.where(page: nil)
+        .or(from_current_public_site.where(page: Alchemy::Page.published.readable_by(user)))
+    }
+
     before_validation :translate_root_menu_name, if: -> { root? }
     before_validation :set_menu_type_from_root, unless: -> { root? }
 
     validates :menu_type, presence: true
     validates :name, presence: true, if: -> { page.nil? }
     validates :url, format: {with: VALID_URL_REGEX}, unless: -> { url.nil? }
+    validates_with Alchemy::SafeUrlValidator, attributes: [:url]
 
     # Returns the name
     #

data/app/models/alchemy/page/page_natures.rb

@@ -31,11 +31,7 @@ module Alchemy
       def expiration_time
         return 0 unless cache_page?
 
-        if definition.cache.to_s.match?(/\d+/)
-          definition.cache.to_i
-        else
-          Alchemy.config.page_cache.max_age
-        end
+        cache_control.max_age || Alchemy.config.page_cache.max_age
       end
 
       def rootpage?
@@ -94,7 +90,7 @@ module Alchemy
       #
       def status_message(status_type)
         if status_type == :scheduled && scheduled?
-          Alchemy.t(public_on&.future? ? :public_on : :public_until, scope: "page_states.scheduled", public_on: public_on && ::I18n.l(public_on, format: :"alchemy.default"), public_until: public_until && ::I18n.l(public_until, format: :"alchemy.default"))
+          Alchemy.t(public_on&.future? ? :public_on : :public_until, scope: "page_states.scheduled", public_on: Alchemy.l(public_on), public_until: Alchemy.l(public_until))
         else
           Alchemy.t(status[status_type].to_s, scope: "page_states.#{status_type}")
         end
@@ -174,9 +170,46 @@ module Alchemy
       # @returns Boolean
       #
       def cache_page?
-        return false if !public? || restricted?
+        !cache_control.no_store?
+      end
+
+      # The effective Cache-Control directives for this page: the page layout's
+      # `cache` setting combined (most restrictively) with the `page_cache` of any
+      # published element on the page, then narrowed for restricted / non-public /
+      # search-results pages.
+      #
+      # @returns [Alchemy::CacheControl]
+      def cache_control
+        return @cache_control if defined?(@cache_control)
+
+        control = [definition.cache, *element_cache_controls].reduce(:&)
+
+        control = Alchemy::CacheControl.parse(false) if !public? || definition.searchresults
+
+        if restricted?
+          control = if definition.cache.default?
+            Alchemy::CacheControl.parse(false)
+          else
+            control.restrict_visibility
+          end
+        end
+
+        @cache_control = control
+      end
+
+      private
+
+      # CacheControl of every visible element on the page whose definition
+      # declares a non-default `page_cache`. Reads through the page version's
+      # element repository so it reuses already-loaded elements instead of
+      # firing its own query, and only inspects elements at all when at least
+      # one definition is non-default.
+      def element_cache_controls
+        constrained = Alchemy::Element.definitions.reject { |d| d.page_cache.default? }
+        return [] if constrained.empty?
 
-        definition.cache != false && definition.searchresults != true
+        present_names = public_version&.element_repository&.visible&.named(*constrained.map(&:name))&.map(&:name) || []
+        constrained.select { |d| present_names.include?(d.name) }.map(&:page_cache)
       end
     end
   end

data/app/models/alchemy/page/page_scopes.rb

@@ -45,6 +45,29 @@ module Alchemy
         #
         scope :restricted, -> { where(restricted: true) }
 
+        # All pages readable by the given user. Mirrors the +readable_by?+
+        # predicate for a whole relation, so +accessible_by+ and the per
+        # instance check stay in sync.
+        #
+        # Unrestricted pages are readable by everyone. Restricted pages are only
+        # readable when one of their +permitted_roles+ matches a role of the
+        # user. Roles are stored as a JSON array, so a single quoted role token
+        # is matched with a portable LIKE. +sanitize_sql_like+ escapes any LIKE
+        # wildcards in the role name so a role cannot smuggle in a +%+ or +_+;
+        # the escape character is +!+ instead of the usual backslash to avoid
+        # MySQL treating it as a string escape.
+        #
+        scope :readable_by,
+          ->(user) {
+            roles = Array(user&.alchemy_roles).map(&:to_s).select(&:present?)
+            return not_restricted if roles.empty?
+
+            column = "#{Alchemy::Page.table_name}.permitted_roles"
+            conditions = roles.map { "#{column} LIKE ? ESCAPE '!'" }.join(" OR ")
+            patterns = roles.map { |role| "%\"#{Alchemy::Page.sanitize_sql_like(role, "!")}\"%" }
+            not_restricted.or(restricted.where(conditions, *patterns))
+          }
+
         # All public pages
         #
         scope :published,

data/app/models/alchemy/page/sitemap_cache_key.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Alchemy
+  # Builds the cache key for the XML sitemap.
+  #
+  # The key combines three independent sources of change:
+  #
+  # 1. The contents of the +Alchemy::Page.sitemap+ scope, as page count and
+  #    latest +updated_at+.
+  # 2. The requested base url (protocol, host and port), because
+  #    +show_alchemy_page_url+ builds absolute urls from +request.base_url+ and
+  #    a site can be served under several of them (see +Alchemy::Site.find_for_host+).
+  # 3. A coarse time bucket of +max_age+ seconds.
+  #
+  # The time bucket is what makes scheduled publishing work. Pages enter and
+  # leave the sitemap when +public_on+ / +public_until+ pass, without any record
+  # being touched, so no content based key can notice that transition. Rotating
+  # the key every +max_age+ seconds bounds how long such a page can be missing.
+  # It also keeps the ETag from freezing: without it, a revalidating client
+  # would receive +304 Not Modified+ forever.
+  class Page::SitemapCacheKey
+    attr_reader :site, :base_url, :max_age
+
+    # @param site [Alchemy::Site] The site the sitemap is rendered for.
+    # @param base_url [String] The requested base url (e.g. +request.base_url+).
+    # @param max_age [Integer] Length of the time bucket in seconds.
+    def initialize(site:, base_url:, max_age: Alchemy.config.sitemap.max_age)
+      @site = site
+      @base_url = base_url
+      @max_age = max_age
+    end
+
+    # @return [Array<Object>]
+    def call
+      [site&.id, base_url, content_version, time_bucket]
+    end
+
+    private
+
+    # Page count and latest +updated_at+ of the sitemap scope.
+    #
+    # We can not use +ActiveRecord::Relation#cache_key_with_version+ here. The
+    # +published+ scope inlines +Time.current+ into its SQL, so the query digest
+    # that +cache_key+ is built from would differ on every single call and the
+    # key would never be stable.
+    def content_version
+      pages = Page.sitemap
+      timestamp = pages.maximum(Page.arel_table[:updated_at])
+      "#{pages.count}-#{timestamp&.to_fs(:usec)}"
+    end
+
+    def time_bucket
+      Time.current.to_i / max_age
+    end
+  end
+end

data/app/models/alchemy/page.rb

@@ -4,35 +4,46 @@
 #
 # Table name: alchemy_pages
 #
-#  id               :integer          not null, primary key
-#  name             :string
-#  urlname          :string
-#  title            :string           (deprecated - use draft_version.title)
-#  language_code    :string
-#  language_root    :boolean
-#  page_layout      :string
-#  meta_keywords    :text             (deprecated - use draft_version.meta_keywords)
-#  meta_description :text             (deprecated - use draft_version.meta_description)
-#  lft              :integer
-#  rgt              :integer
-#  parent_id        :integer
-#  depth            :integer
-#  locked_by        :integer
-#  restricted       :boolean          default(FALSE)
-#  robot_index      :boolean          default(TRUE)
-#  robot_follow     :boolean          default(TRUE)
-#  sitemap          :boolean          default(TRUE)
-#  layoutpage       :boolean          default(FALSE)
-#  created_at       :datetime         not null
-#  updated_at       :datetime         not null
-#  creator_id       :integer
-#  updater_id       :integer
-#  language_id      :integer
-#  cached_tag_list  :text
-#  published_at     :datetime
-#  public_on        :datetime
-#  public_until     :datetime
-#  locked_at        :datetime
+#  id              :integer          not null, primary key
+#  cached_tag_list :text
+#  depth           :integer
+#  language_code   :string
+#  language_root   :boolean          default(FALSE), not null
+#  layoutpage      :boolean          default(FALSE), not null
+#  lft             :integer
+#  locked_at       :datetime
+#  locked_by       :integer
+#  name            :string
+#  page_layout     :string
+#  permitted_roles :text
+#  published_at    :datetime
+#  restricted      :boolean          default(FALSE), not null
+#  rgt             :integer
+#  robot_follow    :boolean          default(TRUE), not null
+#  robot_index     :boolean          default(TRUE), not null
+#  searchable      :boolean          default(TRUE), not null
+#  sitemap         :boolean          default(TRUE), not null
+#  urlname         :string
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#  creator_id      :integer
+#  language_id     :integer          not null
+#  parent_id       :integer
+#  updater_id      :integer
+#
+# Indexes
+#
+#  index_alchemy_pages_on_creator_id               (creator_id)
+#  index_alchemy_pages_on_language_id              (language_id)
+#  index_alchemy_pages_on_locked_at_and_locked_by  (locked_at,locked_by)
+#  index_alchemy_pages_on_rgt                      (rgt)
+#  index_alchemy_pages_on_updater_id               (updater_id)
+#  index_pages_on_parent_id_and_lft                (parent_id,lft)
+#  index_pages_on_urlname                          (urlname)
+#
+# Foreign Keys
+#
+#  language_id  (language_id => alchemy_languages.id)
 #
 
 require_dependency "alchemy/page/fixed_attributes"
@@ -45,6 +56,7 @@ require_dependency "alchemy/page/page_elements"
 module Alchemy
   class Page < BaseRecord
     include Alchemy::Taggable
+    include Alchemy::RelatableResource
 
     # These columns are deprecated in favor of page versions
     self.ignored_columns += [
@@ -92,6 +104,7 @@ module Alchemy
       :layoutpage,
       :menu_id,
       {
+        permitted_roles: [],
         draft_version_attributes: [:id] + PageVersion::METADATA_ATTRIBUTES.map(&:to_sym)
       }
     ]
@@ -135,6 +148,14 @@ module Alchemy
 
     has_many :page_ingredients, class_name: "Alchemy::Ingredients::Page", foreign_key: :related_object_id, dependent: :nullify
 
+    # Stored as a JSON array in a plain text column, so the value is byte
+    # identical on every supported database and the +readable_by+ scope can
+    # match a single quoted role with a portable LIKE. No +type: Array+, as
+    # that would serialize an empty array to NULL, which +readable_by?+ cannot
+    # intersect; the writer already guarantees an array is stored.
+    attribute :permitted_roles, default: -> { ["member"] }
+    serialize :permitted_roles, coder: JSON
+
     before_destroy :check_descendants_for_menu_nodes
 
     before_validation :set_language,
@@ -143,14 +164,18 @@ module Alchemy
     validates_presence_of :page_layout
     validates_format_of :page_layout, with: /\A[a-z0-9_-]+\z/, unless: -> { page_layout.blank? }
     validates_presence_of :parent, unless: -> { layoutpage? || language_root? }
+    validates_presence_of :permitted_roles, if: :restricted?
+    validate :permitted_roles_are_configured
 
     after_initialize :ensure_draft_version, if: :new_record?
 
     before_save :set_language_code,
       if: -> { language.present? }
 
-    before_save :set_restrictions_to_child_pages,
-      if: :restricted_changed?
+    # Runs after save, so descendants inheriting from this page see the new
+    # values instead of the ones still stored in the database.
+    after_save :set_restrictions_to_child_pages,
+      if: -> { saved_change_to_restricted? || saved_change_to_permitted_roles? }
 
     before_save :inherit_restricted_status,
       if: -> { parent && parent.restricted? }
@@ -377,12 +402,22 @@ module Alchemy
 
     def set_restrictions_to_child_pages
       descendants.each do |child|
-        child.update(restricted: restricted?)
+        child.update(restricted: restricted?, permitted_roles: permitted_roles)
       end
     end
 
     def inherit_restricted_status
       self.restricted = parent.restricted?
+      # Roles are only seeded from the parent. An existing page keeps the roles
+      # assigned to it, until the parent pushes its own roles down again.
+      self.permitted_roles = parent.permitted_roles if new_record?
+    end
+
+    def permitted_roles_are_configured
+      unknown = permitted_roles - Alchemy.config.user_roles.map(&:to_s)
+      return if unknown.empty?
+
+      errors.add(:permitted_roles, :inclusion, roles: unknown.to_sentence)
     end
 
     # Returns the first published child
@@ -468,6 +503,27 @@ module Alchemy
       (editor_roles & user.alchemy_roles).any?
     end
 
+    # Accepts an array of role names (as sent by the admin form) and normalizes
+    # it to an array of unique, non blank strings. Whether the roles are
+    # actually configured is enforced by a validation, not silently here.
+    #
+    def permitted_roles=(roles)
+      super(Array(roles).map(&:to_s).select(&:present?).uniq)
+    end
+
+    # Checks if the given user is allowed to read this page.
+    #
+    # Unrestricted pages are readable by everyone. A restricted page is only
+    # readable by users holding one of the page's +permitted_roles+. A restricted
+    # page without any role locks everybody out, which is why at least one role
+    # is validated to be present.
+    #
+    def readable_by?(user)
+      return true unless restricted?
+
+      (permitted_roles & Array(user&.alchemy_roles).map(&:to_s)).any?
+    end
+
     # Returns the value of +public_on+ attribute from public version
     #
     # If it's a fixed attribute then the fixed value is returned instead

data/app/models/alchemy/page_definition.rb

@@ -12,7 +12,7 @@ module Alchemy
     attribute :autogenerate, default: []
     attribute :layoutpage, :boolean, default: false
     attribute :unique, :boolean, default: false
-    attribute :cache, default: true
+    attribute :cache, Alchemy::CacheControlType.new, default: true
     attribute :insert_elements_at, :string, default: "bottom"
     attribute :fixed_attributes, default: {}
     attribute :searchable, :boolean, default: true

data/app/models/alchemy/page_mutex.rb

@@ -1,5 +1,21 @@
 # frozen_string_literal: true
 
+# == Schema Information
+#
+# Table name: alchemy_page_mutexes
+#
+#  id         :integer          not null, primary key
+#  created_at :datetime
+#  page_id    :integer          not null
+#
+# Indexes
+#
+#  index_alchemy_page_mutexes_on_page_id  (page_id) UNIQUE
+#
+# Foreign Keys
+#
+#  page_id  (page_id => alchemy_pages.id)
+#
 module Alchemy
   class PageMutex < BaseRecord
     class LockFailed < StandardError; end

data/app/models/alchemy/page_version.rb

@@ -1,5 +1,28 @@
 # frozen_string_literal: true
 
+# == Schema Information
+#
+# Table name: alchemy_page_versions
+#
+#  id               :integer          not null, primary key
+#  meta_description :text
+#  meta_keywords    :text
+#  public_on        :datetime
+#  public_until     :datetime
+#  title            :string
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#  page_id          :integer          not null
+#
+# Indexes
+#
+#  index_alchemy_page_versions_on_page_id                     (page_id)
+#  index_alchemy_page_versions_on_public_on_and_public_until  (public_on,public_until)
+#
+# Foreign Keys
+#
+#  page_id  (page_id => alchemy_pages.id) ON DELETE => cascade
+#
 module Alchemy
   class PageVersion < BaseRecord
     include Alchemy::Publishable
@@ -30,7 +53,7 @@ module Alchemy
     before_destroy :delete_elements
 
     def element_repository
-      ElementsRepository.new(elements)
+      @element_repository ||= ElementsRepository.new(elements)
     end
 
     private

data/app/models/alchemy/permissions.rb

@@ -69,13 +69,14 @@ module Alchemy
           e.public?
         end
 
-        can :read, Alchemy::Page, Alchemy::Page.published.from_current_site do |p|
-          p.public? && p.site == Alchemy::Current.site
+        can :read, Alchemy::Page,
+          Alchemy::Page.published.from_current_site.readable_by(@user) do |p|
+          p.public? && p.site == Alchemy::Current.site && p.readable_by?(@user)
         end
 
-        can :read, Alchemy::Node, Alchemy::Node.available_to_members do |node|
+        can :read, Alchemy::Node, Alchemy::Node.available_to(@user) do |node|
           node.language.public? && node.language.site_id == Alchemy::Current.site&.id &&
-            (node.page.nil? || node.page.public?)
+            (node.page.nil? || (node.page.public? && node.page.readable_by?(@user)))
         end
       end
     end
@@ -104,7 +105,7 @@ module Alchemy
 
         # Controller actions
         can :leave, :alchemy_admin
-        can [:info, :help, :show], :alchemy_admin_dashboard
+        can [:info, :license, :help, :show], :alchemy_admin_dashboard
         can :manage, :alchemy_admin_clipboard
         can :update, :alchemy_admin_layoutpages
         can :tree, :alchemy_admin_pages

data/app/models/alchemy/picture.rb

@@ -5,19 +5,27 @@
 # Table name: alchemy_pictures
 #
 #  id                :integer          not null, primary key
-#  name              :string
+#  cached_tag_list   :text
+#  image_file_format :string
+#  image_file_height :integer
 #  image_file_name   :string
+#  image_file_size   :integer
+#  image_file_uid    :string
 #  image_file_width  :integer
-#  image_file_height :integer
+#  name              :string
+#  upload_hash       :string
 #  created_at        :datetime         not null
 #  updated_at        :datetime         not null
 #  creator_id        :integer
 #  updater_id        :integer
-#  upload_hash       :string
-#  cached_tag_list   :text
-#  image_file_uid    :string
-#  image_file_size   :integer
-#  image_file_format :string
+#
+# Indexes
+#
+#  index_alchemy_pictures_on_created_at       (created_at)
+#  index_alchemy_pictures_on_creator_id       (creator_id)
+#  index_alchemy_pictures_on_image_file_name  (image_file_name)
+#  index_alchemy_pictures_on_name             (name)
+#  index_alchemy_pictures_on_updater_id       (updater_id)
 #
 
 module Alchemy

data/app/models/alchemy/picture_description.rb

@@ -1,3 +1,25 @@
+# == Schema Information
+#
+# Table name: alchemy_picture_descriptions
+#
+#  id          :integer          not null, primary key
+#  text        :text
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#  language_id :integer          not null
+#  picture_id  :integer          not null
+#
+# Indexes
+#
+#  alchemy_picture_descriptions_on_picture_id_and_language_id  (picture_id,language_id) UNIQUE
+#  index_alchemy_picture_descriptions_on_language_id           (language_id)
+#  index_alchemy_picture_descriptions_on_picture_id            (picture_id)
+#
+# Foreign Keys
+#
+#  language_id  (language_id => alchemy_languages.id)
+#  picture_id   (picture_id => alchemy_pictures.id)
+#
 module Alchemy
   class PictureDescription < ActiveRecord::Base
     belongs_to :picture, class_name: "Alchemy::Picture"

data/app/models/alchemy/picture_thumb.rb

@@ -1,5 +1,23 @@
 # frozen_string_literal: true
 
+# == Schema Information
+#
+# Table name: alchemy_picture_thumbs
+#
+#  id         :integer          not null, primary key
+#  signature  :string           not null
+#  uid        :text             not null
+#  picture_id :integer          not null
+#
+# Indexes
+#
+#  index_alchemy_picture_thumbs_on_picture_id  (picture_id)
+#  index_alchemy_picture_thumbs_on_signature   (signature) UNIQUE
+#
+# Foreign Keys
+#
+#  picture_id  (picture_id => alchemy_pictures.id)
+#
 module Alchemy
   # The persisted version of a rendered picture variant
   #

data/app/models/alchemy/publishable/timestamp_resolver.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Publishable
+    # Default resolver for Publishable records.
+    #
+    # Uses the +public_on+ and +public_until+ timestamp columns to determine
+    # whether a record is public, scheduled, or publishable.
+    #
+    # This class defines the interface that custom resolvers configured via
+    # +Alchemy.config.publishable_resolver+ must implement.
+    #
+    class TimestampResolver
+      class << self
+        # Returns records without a +public_on+ date set.
+        def draft(publishables)
+          publishables.where(public_on: nil)
+        end
+
+        # Returns records with a +public_on+ date set.
+        def scheduled(publishables)
+          publishables.where.not(public_on: nil)
+        end
+
+        # Returns records that are public at the given time.
+        def published(publishables, at:)
+          table_name = publishables.table_name
+          scheduled(publishables)
+            .where("#{table_name}.public_on <= :at", at:)
+            .where("#{table_name}.public_until IS NULL OR #{table_name}.public_until > :at", at:)
+        end
+      end
+
+      def initialize(publishable)
+        @publishable = publishable
+      end
+
+      # Determines if the record is public at the given time.
+      def public?(at: Current.preview_time)
+        already_public_for?(at:) && still_public_for?(at:)
+      end
+
+      # Determines if the record has a future publication or expiration event.
+      def scheduled?(at: Current.preview_time)
+        (publishable.public_on.present? && publishable.public_on > at) ||
+          (publishable.public_until.present? && publishable.public_until > at)
+      end
+
+      # Determines if the record is publishable.
+      #
+      # A record is publishable if a +public_on+ timestamp is set and not
+      # expired yet.
+      def publishable?
+        !publishable.public_on.nil? && still_public_for?(at: Time.current)
+      end
+
+      private
+
+      attr_reader :publishable
+
+      def already_public_for?(at: Current.preview_time)
+        !publishable.public_on.nil? && publishable.public_on <= at
+      end
+
+      def still_public_for?(at: Current.preview_time)
+        publishable.public_until.nil? || publishable.public_until > at
+      end
+    end
+  end
+end

data/app/models/alchemy/resource.rb

@@ -229,7 +229,7 @@ module Alchemy
     # Joins all searchable attribute names into a Ransack compatible search query
     #
     def search_field_name
-      searchable_attribute_names.join("_or_") + "_cont"
+      searchable_attribute_names.join("_or_") + "_i_cont"
     end
 
     def in_engine?