[pluginize-solr] Moving acts_as_[searchable,faceted] to the plugin

Rodrigo Souto
1 parent 9c9311bd
Showing 18 changed files with 487 additions and 531 deletions Show diff stats
app/models/article.rb
app/models/category.rb
app/models/product.rb
app/models/profile.rb
config/initializers/dependencies.rb
plugins/solr/lib/ext/article.rb
plugins/solr/lib/ext/category.rb
plugins/solr/lib/ext/product.rb
plugins/solr/lib/ext/profile.rb
plugins/solr/test/unit/category_test.rb
plugins/solr/test/unit/product_test.rb
plugins/solr/test/unit/profile_test.rb
test/unit/acts_as_faceted_test.rb
test/unit/acts_as_searchable_test.rb
test/unit/article_test.rb
test/unit/category_test.rb
test/unit/product_test.rb
test/unit/profile_test.rb
@@ -647,80 +647,12 @@ class Article &lt; ActiveRecord::Base
   Forum
   Event
-  def self.f_type_proc(klass)
-    klass.constantize.type_name
-  end
-
-  def self.f_profile_type_proc(klass)
-    klass.constantize.type_name
-  end
-
-  def f_type
-    #join common types
-    case self.class.name
-    when 'TinyMceArticle', 'TextileArticle'
-      TextArticle.name
-    else
-      self.class.name
-    end
-  end
-
-  def f_profile_type
-    self.profile.class.name
-  end
-
-  def f_published_at
-    self.published_at
-  end
-
-  def f_category
-    self.categories.collect(&:name)
-  end
-
   delegate :region, :region_id, :environment, :environment_id, :to => :profile, :allow_nil => true
   def name_sortable # give a different name for solr
     name
   end
-  def public
-    self.public?
-  end
-
-  def category_filter
-    categories_including_virtual_ids
-  end
-
   public
-
-  acts_as_faceted :fields => {
-      :f_type => {:label => _('Type'), :proc => proc{|klass| f_type_proc(klass)}},
-      :f_published_at => {:type => :date, :label => _('Published date'), :queries => {'[* TO NOW-1YEARS/DAY]' => _("Older than one year"),
-        '[NOW-1YEARS TO NOW/DAY]' => _("In the last year"), '[NOW-1MONTHS TO NOW/DAY]' => _("In the last month"), '[NOW-7DAYS TO NOW/DAY]' => _("In the last week"), '[NOW-1DAYS TO NOW/DAY]' => _("In the last day")},
-        :queries_order => ['[NOW-1DAYS TO NOW/DAY]', '[NOW-7DAYS TO NOW/DAY]', '[NOW-1MONTHS TO NOW/DAY]', '[NOW-1YEARS TO NOW/DAY]', '[* TO NOW-1YEARS/DAY]']},
-      :f_profile_type => {:label => _('Profile'), :proc => proc{|klass| f_profile_type_proc(klass)}},
-      :f_category => {:label => _('Categories')},
-    }, :category_query => proc { |c| "category_filter:\"#{c.id}\"" },
-    :order => [:f_type, :f_published_at, :f_profile_type, :f_category]
-
-  acts_as_searchable :fields => facets_fields_for_solr + [
-      # searched fields
-      {:name => {:type => :text, :boost => 2.0}},
-      {:slug => :text}, {:body => :text},
-      {:abstract => :text}, {:filename => :text},
-      # filtered fields
-      {:public => :boolean}, {:environment_id => :integer},
-      {:profile_id => :integer}, :language,
-      {:category_filter => :integer},
-      # ordered/query-boosted fields
-      {:name_sortable => :string}, :last_changed_by_id, :published_at, :is_image,
-      :updated_at, :created_at,
-    ], :include => [
-      {:profile => {:fields => [:name, :identifier, :address, :nickname, :region_id, :lat, :lng]}},
-      {:comments => {:fields => [:title, :body, :author_name, :author_email]}},
-      {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
-    ], :facets => facets_option_for_solr,
-    :boost => proc { |a| 10 if a.profile && a.profile.enabled },
-    :if => proc{ |a| ! ['RssFeed'].include?(a.class.name) }
   handle_asynchronously :solr_save
   private
@@ -95,17 +95,6 @@ class Category &lt; ActiveRecord::Base
     name
   end
   public
-
-  acts_as_searchable :fields => [
-    # searched fields
-    {:name => {:type => :text, :boost => 2.0}},
-    {:path => :text}, {:slug => :text},
-    {:abbreviation => :text}, {:acronym => :text},
-    # filtered fields
-    :parent_id,
-    # ordered/query-boosted fields
-    {:name_sortable => :string},
-  ]
   handle_asynchronously :solr_save
 end
@@ -212,87 +212,20 @@ class Product &lt; ActiveRecord::Base
   end
   private
-  def f_category
-    self.product_category.name
-  end
-  def f_region
-    self.enterprise.region.id if self.enterprise.region
-  end
-  def self.f_region_proc(id)
-    c = Region.find(id)
-    s = c.parent
-    if c and c.kind_of?(City) and s and s.kind_of?(State) and s.acronym
-      [c.name, ', ' + s.acronym]
-    else
-      c.name
-    end
-  end
-  def self.f_qualifier_proc(ids)
-    array = ids.split
-    qualifier = Qualifier.find_by_id array[0]
-    certifier = Certifier.find_by_id array[1]
-    certifier ? [qualifier.name, _(' cert. ') + certifier.name] : qualifier.name
-  end
-  def f_qualifier
-    product_qualifiers.map do |pq|
-      "#{pq.qualifier_id} #{pq.certifier_id}"
-    end
-  end
-  alias_method :name_sortable, :name
   delegate :enabled, :region, :region_id, :environment, :environment_id, :to => :enterprise
+
+  alias_method :name_sortable, :name
   def name_sortable # give a different name for solr
     name
   end
-  def public
-    self.public?
-  end
+
   def price_sortable
     (price.nil? or price.zero?) ? nil : price
   end
-  def category_filter
-    enterprise.categories_including_virtual_ids << product_category_id
-  end
+
   public
-  acts_as_faceted :fields => {
-      :f_category => {:label => _('Related products')},
-      :f_region => {:label => _('City'), :proc => proc { |id| f_region_proc(id) }},
-      :f_qualifier => {:label => _('Qualifiers'), :proc => proc { |id| f_qualifier_proc(id) }},
-    }, :category_query => proc { |c| "category_filter:#{c.id}" },
-    :order => [:f_category, :f_region, :f_qualifier]
-
-  Boosts = [
-    [:image, 0.55, proc{ |p| p.image ? 1 : 0}],
-    [:qualifiers, 0.45, proc{ |p| p.product_qualifiers.count > 0 ? 1 : 0}],
-    [:open_price, 0.45, proc{ |p| p.price_described? ? 1 : 0}],
-    [:solidarity, 0.45, proc{ |p| p.percentage_from_solidarity_economy[0].to_f/100 }],
-    [:available, 0.35, proc{ |p| p.available ? 1 : 0}],
-    [:price, 0.35, proc{ |p| (!p.price.nil? and p.price > 0) ? 1 : 0}],
-    [:new_product, 0.35, proc{ |p| (p.updated_at.to_i - p.created_at.to_i) < 24*3600 ? 1 : 0}],
-    [:description, 0.3, proc{ |p| !p.description.blank? ? 1 : 0}],
-    [:enabled, 0.2, proc{ |p| p.enterprise.enabled ? 1 : 0}],
-  ]
-
-  acts_as_searchable :fields => facets_fields_for_solr + [
-      # searched fields
-      {:name => {:type => :text, :boost => 2.0}},
-      {:description => :text}, {:category_full_name => :text},
-      # filtered fields
-      {:public => :boolean}, {:environment_id => :integer},
-      {:enabled => :boolean}, {:category_filter => :integer},
-      # ordered/query-boosted fields
-      {:price_sortable => :decimal}, {:name_sortable => :string},
-      {:lat => :float}, {:lng => :float},
-      :updated_at, :created_at,
-    ], :include => [
-      {:product_category => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
-      {:region => {:fields => [:name, :path, :slug, :lat, :lng]}},
-      {:enterprise => {:fields => [:name, :identifier, :address, :nickname, :lat, :lng]}},
-      {:qualifiers => {:fields => [:name]}},
-      {:certifiers => {:fields => [:name]}},
-    ], :facets => facets_option_for_solr,
-    :boost => proc{ |p| boost = 1; Boosts.each{ |b| boost = boost * (1 - ((1 - b[2].call(p)) * b[1])) }; boost}
   handle_asynchronously :solr_save
 end
@@ -887,82 +887,12 @@ private :generate_url, :url_options
   end
   private
-  def self.f_categories_label_proc(environment)
-    ids = environment.top_level_category_as_facet_ids
-    r = Category.find(ids)
-    map = {}
-    ids.map{ |id| map[id.to_s] = r.detect{|c| c.id == id}.name }
-    map
-  end
-  def self.f_categories_proc(facet, id)
-    id = id.to_i
-    return if id.zero?
-    c = Category.find(id)
-    c.name if c.top_ancestor.id == facet[:label_id].to_i or facet[:label_id] == 0
-  end
-  def f_categories
-    category_ids - [region_id]
-  end
-
-  def f_region
-    self.region_id
-  end
-  def self.f_region_proc(id)
-    c = Region.find(id)
-    s = c.parent
-    if c and c.kind_of?(City) and s and s.kind_of?(State) and s.acronym
-      [c.name, ', ' + s.acronym]
-    else
-      c.name
-    end
-  end
-
-  def self.f_enabled_proc(enabled)
-    enabled = enabled == "true" ? true : false
-    enabled ? s_('facets|Enabled') : s_('facets|Not enabled')
-  end
-  def f_enabled
-    self.enabled
-  end
   def name_sortable # give a different name for solr
     name
   end
-  def public
-    self.public?
-  end
-  def category_filter
-    categories_including_virtual_ids
-  end
-  public
-  acts_as_faceted :fields => {
-      :f_enabled => {:label => _('Situation'), :type_if => proc { |klass| klass.kind_of?(Enterprise) },
-        :proc => proc { |id| f_enabled_proc(id) }},
-      :f_region => {:label => _('City'), :proc => proc { |id| f_region_proc(id) }},
-      :f_categories => {:multi => true, :proc => proc {|facet, id| f_categories_proc(facet, id)},
-        :label => proc { |env| f_categories_label_proc(env) }, :label_abbrev => proc{ |env| f_categories_label_abbrev_proc(env) }},
-    }, :category_query => proc { |c| "category_filter:#{c.id}" },
-    :order => [:f_region, :f_categories, :f_enabled]
-
-  acts_as_searchable :fields => facets_fields_for_solr + [:extra_data_for_index,
-      # searched fields
-      {:name => {:type => :text, :boost => 2.0}},
-      {:identifier => :text}, {:nickname => :text},
-      # filtered fields
-      {:public => :boolean}, {:environment_id => :integer},
-      {:category_filter => :integer},
-      # ordered/query-boosted fields
-      {:name_sortable => :string}, {:user_id => :integer},
-      :enabled, :active, :validated, :public_profile,
-      {:lat => :float}, {:lng => :float},
-      :updated_at, :created_at,
-    ],
-    :include => [
-      {:region => {:fields => [:name, :path, :slug, :lat, :lng]}},
-      {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
-    ], :facets => facets_option_for_solr,
-    :boost => proc{ |p| 10 if p.enabled }
+  public
   handle_asynchronously :solr_save
 # locally-developed modules
-require 'acts_as_faceted'
 require 'acts_as_filesystem'
 require 'acts_as_having_settings'
-require 'acts_as_searchable'
 require 'acts_as_having_boxes'
 require 'acts_as_having_image'
 require 'acts_as_having_posts'
@@ -4,4 +4,74 @@ class Article
   def solr_plugin_comments_updated
     solr_save
   end
+
+  acts_as_faceted :fields => {
+      :solr_plugin_f_type => {:label => _('Type'), :proc => proc{|klass| solr_plugin_f_type_proc(klass)}},
+      :solr_plugin_f_published_at => {:type => :date, :label => _('Published date'), :queries => {'[* TO NOW-1YEARS/DAY]' => _("Older than one year"),
+        '[NOW-1YEARS TO NOW/DAY]' => _("In the last year"), '[NOW-1MONTHS TO NOW/DAY]' => _("In the last month"), '[NOW-7DAYS TO NOW/DAY]' => _("In the last week"), '[NOW-1DAYS TO NOW/DAY]' => _("In the last day")},
+        :queries_order => ['[NOW-1DAYS TO NOW/DAY]', '[NOW-7DAYS TO NOW/DAY]', '[NOW-1MONTHS TO NOW/DAY]', '[NOW-1YEARS TO NOW/DAY]', '[* TO NOW-1YEARS/DAY]']},
+      :solr_plugin_f_profile_type => {:label => _('Profile'), :proc => proc{|klass| solr_plugin_f_profile_type_proc(klass)}},
+      :solr_plugin_f_category => {:label => _('Categories')},
+    }, :category_query => proc { |c| "solr_plugin_category_filter:\"#{c.id}\"" },
+    :order => [:solr_plugin_f_type, :solr_plugin_f_published_at, :solr_plugin_f_profile_type, :solr_plugin_f_category]
+
+  acts_as_searchable :fields => facets_fields_for_solr + [
+      # searched fields
+      {:name => {:type => :text, :boost => 2.0}},
+      {:slug => :text}, {:body => :text},
+      {:abstract => :text}, {:filename => :text},
+      # filtered fields
+      {:solr_plugin_public => :boolean}, {:environment_id => :integer},
+      {:profile_id => :integer}, :language,
+      {:solr_plugin_category_filter => :integer},
+      # ordered/query-boosted fields
+      {:name_sortable => :string}, :last_changed_by_id, :published_at, :is_image,
+      :updated_at, :created_at,
+    ], :include => [
+      {:profile => {:fields => [:name, :identifier, :address, :nickname, :region_id, :lat, :lng]}},
+      {:comments => {:fields => [:title, :body, :author_name, :author_email]}},
+      {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
+    ], :facets => facets_option_for_solr,
+    :boost => proc { |a| 10 if a.profile && a.profile.enabled },
+    :if => proc{ |a| ! ['RssFeed'].include?(a.class.name) }
+
+  private
+
+  def self.solr_plugin_f_type_proc(klass)
+    klass.constantize.type_name
+  end
+
+  def self.solr_plugin_f_profile_type_proc(klass)
+    klass.constantize.type_name
+  end
+
+  def solr_plugin_f_type
+    #join common types
+    case self.class.name
+    when 'TinyMceArticle', 'TextileArticle'
+      TextArticle.name
+    else
+      self.class.name
+    end
+  end
+
+  def solr_plugin_f_profile_type
+    self.profile.class.name
+  end
+
+  def solr_plugin_f_published_at
+    self.published_at
+  end
+
+  def solr_plugin_f_category
+    self.categories.collect(&:name)
+  end
+
+  def solr_plugin_public
+    self.public?
+  end
+
+  def solr_plugin_category_filter
+    categories_including_virtual_ids
+  end
 end
@@ -2,4 +2,15 @@ require_dependency &#39;category&#39;
 class Category
   after_save_reindex [:articles, :profiles], :with => :delayed_job
+
+  acts_as_searchable :fields => [
+    # searched fields
+    {:name => {:type => :text, :boost => 2.0}},
+    {:path => :text}, {:slug => :text},
+    {:abbreviation => :text}, {:acronym => :text},
+    # filtered fields
+    :parent_id,
+    # ordered/query-boosted fields
+    {:name_sortable => :string},
+  ]
 end
@@ -2,4 +2,84 @@ require_dependency &#39;product&#39;
 class Product
   after_save_reindex [:enterprise], :with => :delayed_job
+
+  acts_as_faceted :fields => {
+      :solr_plugin_f_category => {:label => _('Related products')},
+      :solr_plugin_f_region => {:label => _('City'), :proc => proc { |id| solr_plugin_f_region_proc(id) }},
+      :solr_plugin_f_qualifier => {:label => _('Qualifiers'), :proc => proc { |id| solr_plugin_f_qualifier_proc(id) }},
+    }, :category_query => proc { |c| "solr_plugin_category_filter:#{c.id}" },
+    :order => [:solr_plugin_f_category, :solr_plugin_f_region, :solr_plugin_f_qualifier]
+
+  SolrPlugin::Boosts = [
+    [:image, 0.55, proc{ |p| p.image ? 1 : 0}],
+    [:qualifiers, 0.45, proc{ |p| p.product_qualifiers.count > 0 ? 1 : 0}],
+    [:open_price, 0.45, proc{ |p| p.price_described? ? 1 : 0}],
+    [:solidarity, 0.45, proc{ |p| p.percentage_from_solidarity_economy[0].to_f/100 }],
+    [:available, 0.35, proc{ |p| p.available ? 1 : 0}],
+    [:price, 0.35, proc{ |p| (!p.price.nil? and p.price > 0) ? 1 : 0}],
+    [:new_product, 0.35, proc{ |p| (p.updated_at.to_i - p.created_at.to_i) < 24*3600 ? 1 : 0}],
+    [:description, 0.3, proc{ |p| !p.description.blank? ? 1 : 0}],
+    [:enabled, 0.2, proc{ |p| p.enterprise.enabled ? 1 : 0}],
+  ]
+
+  acts_as_searchable :fields => facets_fields_for_solr + [
+      # searched fields
+      {:name => {:type => :text, :boost => 2.0}},
+      {:description => :text}, {:category_full_name => :text},
+      # filtered fields
+      {:solr_plugin_public => :boolean}, {:environment_id => :integer},
+      {:enabled => :boolean}, {:solr_plugin_category_filter => :integer},
+      # ordered/query-boosted fields
+      {:price_sortable => :decimal}, {:name_sortable => :string},
+      {:lat => :float}, {:lng => :float},
+      :updated_at, :created_at,
+    ], :include => [
+      {:product_category => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
+      {:region => {:fields => [:name, :path, :slug, :lat, :lng]}},
+      {:enterprise => {:fields => [:name, :identifier, :address, :nickname, :lat, :lng]}},
+      {:qualifiers => {:fields => [:name]}},
+      {:certifiers => {:fields => [:name]}},
+    ], :facets => facets_option_for_solr,
+    :boost => proc{ |p| boost = 1; SolrPlugin::Boosts.each{ |b| boost = boost * (1 - ((1 - b[2].call(p)) * b[1])) }; boost}
+
+  private
+
+  def solr_plugin_f_category
+    self.product_category.name
+  end
+
+  def solr_plugin_f_region
+    self.enterprise.region.id if self.enterprise.region
+  end
+
+  def self.solr_plugin_f_region_proc(id)
+    c = Region.find(id)
+    s = c.parent
+    if c and c.kind_of?(City) and s and s.kind_of?(State) and s.acronym
+      [c.name, ', ' + s.acronym]
+    else
+      c.name
+    end
+  end
+
+  def self.solr_plugin_f_qualifier_proc(ids)
+    array = ids.split
+    qualifier = Qualifier.find_by_id array[0]
+    certifier = Certifier.find_by_id array[1]
+    certifier ? [qualifier.name, _(' cert. ') + certifier.name] : qualifier.name
+  end
+
+  def solr_plugin_f_qualifier
+    product_qualifiers.map do |pq|
+      "#{pq.qualifier_id} #{pq.certifier_id}"
+    end
+  end
+
+  def solr_plugin_category_filter
+    enterprise.categories_including_virtual_ids << product_category_id
+  end
+
+  def solr_plugin_public
+    self.public?
+  end
 end
@@ -2,4 +2,84 @@ require_dependency &#39;profile&#39;
 class Profile
   after_save_reindex [:articles], :with => :delayed_job
+
+  acts_as_faceted :fields => {
+      :solr_plugin_f_enabled => {:label => _('Situation'), :type_if => proc { |klass| klass.kind_of?(Enterprise) },
+        :proc => proc { |id| solr_plugin_f_enabled_proc(id) }},
+      :solr_plugin_f_region => {:label => _('City'), :proc => proc { |id| solr_plugin_f_region_proc(id) }},
+      :solr_plugin_f_categories => {:multi => true, :proc => proc {|facet, id| solr_plugin_f_categories_proc(facet, id)},
+        :label => proc { |env| solr_plugin_f_categories_label_proc(env) }, :label_abbrev => proc{ |env| solr_plugin_f_categories_label_abbrev_proc(env) }},
+    }, :category_query => proc { |c| "solr_plugin_category_filter:#{c.id}" },
+    :order => [:solr_plugin_f_region, :solr_plugin_f_categories, :solr_plugin_f_enabled]
+
+  acts_as_searchable :fields => facets_fields_for_solr + [:extra_data_for_index,
+      # searched fields
+      {:name => {:type => :text, :boost => 2.0}},
+      {:identifier => :text}, {:nickname => :text},
+      # filtered fields
+      {:solr_plugin_public => :boolean}, {:environment_id => :integer},
+      {:solr_plugin_category_filter => :integer},
+      # ordered/query-boosted fields
+      {:name_sortable => :string}, {:user_id => :integer},
+      :enabled, :active, :validated, :public_profile,
+      {:lat => :float}, {:lng => :float},
+      :updated_at, :created_at,
+    ],
+    :include => [
+      {:region => {:fields => [:name, :path, :slug, :lat, :lng]}},
+      {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
+    ], :facets => facets_option_for_solr,
+    :boost => proc{ |p| 10 if p.enabled }
+
+  private
+
+  def self.solr_plugin_f_categories_label_proc(environment)
+    ids = environment.top_level_category_as_facet_ids
+    r = Category.find(ids)
+    map = {}
+    ids.map{ |id| map[id.to_s] = r.detect{|c| c.id == id}.name }
+    map
+  end
+
+  def self.solr_plugin_f_categories_proc(facet, id)
+    id = id.to_i
+    return if id.zero?
+    c = Category.find(id)
+    c.name if c.top_ancestor.id == facet[:label_id].to_i or facet[:label_id] == 0
+  end
+
+  def solr_plugin_f_categories
+    category_ids - [region_id]
+  end
+
+  def solr_plugin_f_region
+    self.region_id
+  end
+
+  def self.solr_plugin_f_region_proc(id)
+    c = Region.find(id)
+    s = c.parent
+    if c and c.kind_of?(City) and s and s.kind_of?(State) and s.acronym
+      [c.name, ', ' + s.acronym]
+    else
+      c.name
+    end
+  end
+
+  def self.solr_plugin_f_enabled_proc(enabled)
+    enabled = enabled == "true" ? true : false
+    enabled ? s_('facets|Enabled') : s_('facets|Not enabled')
+  end
+
+  def solr_plugin_f_enabled
+    self.enabled
+  end
+
+  def solr_plugin_public
+    self.public?
+  end
+
+  def solr_plugin_category_filter
+    categories_including_virtual_ids
+  end
 end
@@ -9,7 +9,7 @@ class CategoryTest &lt; ActiveSupport::TestCase
   attr_accessor :environment
   should 'reindex articles after saving' do
-    cat = Category.create!(:name => 'category 1', :environment_id => Environment.default.id)
+    cat = Category.create!(:name => 'category 1', :environment_id => environment.id)
     art = Article.create!(:name => 'something', :profile_id => fast_create(Person).id)
     art.add_category cat
     cat.reload
@@ -18,4 +18,26 @@ class CategoryTest &lt; ActiveSupport::TestCase
     Article.any_instance.expects(:to_solr_doc).returns(solr_doc)
     cat.save!
   end
+
+  should 'act as searchable' do
+    TestSolr.enable
+    parent = fast_create(Category, :name => 'books')
+    c = Category.create!(:name => "science fiction", :acronym => "sf", :abbreviation => "sci-fi",
+                         :environment_id => environment.id, :parent_id => parent.id)
+
+    # fields
+    assert_includes Category.find_by_contents('fiction')[:results].docs, c
+    assert_includes Category.find_by_contents('sf')[:results].docs, c
+    assert_includes Category.find_by_contents('sci-fi')[:results].docs, c
+    # filters
+    assert_includes Category.find_by_contents('science', {}, {
+      :filter_queries => ["parent_id:#{parent.id}"]})[:results].docs, c
+  end
+
+  should 'boost name matches' do
+    TestSolr.enable
+    c_abbr = Category.create!(:name => "something else", :abbreviation => "science", :environment_id => environment.id)
+    c_name = Category.create!(:name => "science fiction", :environment_id => environment.id)
+    assert_equal [c_name, c_abbr], Category.find_by_contents("science")[:results].docs
+  end
 end
@@ -4,9 +4,11 @@ class ProductTest &lt; ActiveSupport::TestCase
   def setup
     @environment = Environment.default
     @environment.enable_plugin(SolrPlugin)
+    @product_category = fast_create(ProductCategory, :name => 'Products')
+    @profile = fast_create(Enterprise)
   end
-  attr_accessor :environment
+  attr_accessor :environment, :product_category, :profile
   should 'reindex enterprise after saving' do
     ent = fast_create(Enterprise)
@@ -15,5 +17,177 @@ class ProductTest &lt; ActiveSupport::TestCase
     Product.expects(:solr_batch_add).with([ent])
     prod.save!
   end
+
+  should 'act as faceted' do
+    s = fast_create(State, :acronym => 'XZ')
+    c = fast_create(City, :name => 'Tabajara', :parent_id => s.id)
+    ent = fast_create(Enterprise, :region_id => c.id)
+    cat = fast_create(ProductCategory, :name => 'hardcore')
+    p = Product.create!(:name => 'black flag', :enterprise_id => ent.id, :product_category_id => cat.id)
+    pq = p.product_qualifiers.create!(:qualifier => fast_create(Qualifier, :name => 'qualifier'),
+                                      :certifier => fast_create(Certifier, :name => 'certifier'))
+    assert_equal 'Related products', Product.facet_by_id(:solr_plugin_f_category)[:label]
+    assert_equal ['Tabajara', ', XZ'], Product.facet_by_id(:solr_plugin_f_region)[:proc].call(p.send(:solr_plugin_f_region))
+    assert_equal ['qualifier', ' cert. certifier'], Product.facet_by_id(:solr_plugin_f_qualifier)[:proc].call(p.send(:solr_plugin_f_qualifier).last)
+    assert_equal 'hardcore', p.send(:solr_plugin_f_category)
+    assert_equal "solr_plugin_category_filter:#{cat.id}", Product.facet_category_query.call(cat)
+  end
+
+  should 'act as searchable' do
+    TestSolr.enable
+    s = fast_create(State, :acronym => 'XZ')
+    c = fast_create(City, :name => 'Tabajara', :parent_id => s.id)
+    ent = fast_create(Enterprise, :region_id => c.id, :name => "Black Sun")
+    category = fast_create(ProductCategory, :name => "homemade", :acronym => "hm", :abbreviation => "homey")
+    p = Product.create!(:name => 'bananas syrup', :description => 'surrounded by mosquitos', :enterprise_id => ent.id,
+                        :product_category_id => category.id)
+    qual = Qualifier.create!(:name => 'qualificador', :environment_id => Environment.default.id)
+    cert = Certifier.create!(:name => 'certificador', :environment_id => Environment.default.id)
+    pq = p.product_qualifiers.create!(:qualifier => qual,	:certifier => cert)
+    p.qualifiers.reload
+    p.certifiers.reload
+    p.save!
+    # fields
+    assert_includes Product.find_by_contents('bananas')[:results].docs, p
+    assert_includes Product.find_by_contents('mosquitos')[:results].docs, p
+    assert_includes Product.find_by_contents('homemade')[:results].docs, p
+    # filters
+    assert_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["solr_plugin_public:true"]})[:results].docs, p
+    assert_not_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["solr_plugin_public:false"]})[:results].docs, p
+    assert_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, p
+    # includes
+    assert_includes Product.find_by_contents("homemade")[:results].docs, p
+    assert_includes Product.find_by_contents(category.slug)[:results].docs, p
+    assert_includes Product.find_by_contents("hm")[:results].docs, p
+    assert_includes Product.find_by_contents("homey")[:results].docs, p
+    assert_includes Product.find_by_contents("Tabajara")[:results].docs, p
+    assert_includes Product.find_by_contents("Black Sun")[:results].docs, p
+    assert_includes Product.find_by_contents("qualificador")[:results].docs, p
+    assert_includes Product.find_by_contents("certificador")[:results].docs, p
+  end
+
+  should 'boost name matches' do
+    TestSolr.enable
+    ent = fast_create(Enterprise)
+    cat = fast_create(ProductCategory)
+    in_desc = Product.create!(:name => 'something', :enterprise_id => ent.id, :description => 'bananas in the description!',
+                              :product_category_id => cat.id)
+    in_name = Product.create!(:name => 'bananas in the name!', :enterprise_id => ent.id, :product_category_id => cat.id)
+    assert_equal [in_name, in_desc], Product.find_by_contents('bananas')[:results].docs
+  end
+
+  should 'boost search results that include an image' do
+    TestSolr.enable
+    product_without_image = Product.create!(:name => 'product without image', :product_category => product_category,
+                                            :enterprise_id => profile.id)
+    product_with_image = Product.create!(:name => 'product with image', :product_category => product_category,
+                                         :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')},
+                                         :enterprise_id => profile.id)
+    assert_equal [product_with_image, product_without_image], Product.find_by_contents('product image')[:results].docs
+  end
+
+  should 'boost search results that include qualifier' do
+    TestSolr.enable
+    product_without_q = Product.create!(:name => 'product without qualifier', :product_category => product_category,
+                                        :enterprise_id => profile.id)
+    product_with_q = Product.create!(:name => 'product with qualifier', :product_category => product_category,
+                                     :enterprise_id => profile.id)
+    product_with_q.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil)
+    product_with_q.save!
+
+    assert_equal [product_with_q, product_without_q], Product.find_by_contents('product qualifier')[:results].docs
+  end
+
+  should 'boost search results with open price' do
+    TestSolr.enable
+    product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => profile.id, :price => 100)
+    open_price = Product.new(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id, :price => 100)
+    open_price.inputs << Input.new(:product => open_price, :product_category_id => product_category.id, :amount_used => 10, :price_per_unit => 10)
+    open_price.save!
+
+    assert_equal [open_price, product], Product.find_by_contents('product')[:results].docs
+  end
+
+  should 'boost search results with solidarity inputs' do
+    TestSolr.enable
+    product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => profile.id)
+    perc_50 = Product.create!(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id)
+    Input.create!(:product_id => perc_50.id, :product_category_id => product_category.id,
+                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
+    Input.create!(:product_id => perc_50.id, :product_category_id => product_category.id,
+                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false)
+    perc_50.save!
+    perc_75 = Product.create!(:name => 'product 3', :product_category => product_category, :enterprise_id => profile.id)
+    Input.create!(:product_id => perc_75.id, :product_category_id => product_category.id,
+                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false)
+    Input.create!(:product_id => perc_75.id, :product_category_id => product_category.id,
+                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
+    Input.create!(:product_id => perc_75.id, :product_category_id => product_category.id,
+                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
+    Input.create!(:product_id => perc_75.id, :product_category_id => product_category.id,
+                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
+    perc_75.save!
+
+    assert_equal [perc_75, perc_50, product], Product.find_by_contents('product')[:results].docs
+  end
+
+  should 'boost available search results' do
+    TestSolr.enable
+    product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => profile.id)
+    product.available = false
+    product.save!
+    product2 = Product.create!(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id)
+    product2.available = true
+    product2.save!
+
+    assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
+  end
+
+  should 'boost search results created updated recently' do
+    TestSolr.enable
+    product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => profile.id)
+    product.update_attribute :created_at, Time.now - 10.day
+    product2 = Product.create!(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id)
+
+    assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
+  end
+
+  should 'boost search results with description' do
+    TestSolr.enable
+    product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => profile.id,
+                              :description => '')
+    product2 = Product.create!(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id,
+                               :description => 'a small description')
+
+    assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
+  end
+
+  should 'boost if enterprise is enabled' do
+    TestSolr.enable
+    ent = Enterprise.create!(:name => 'ent', :identifier => 'ent', :enabled => false)
+    product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => ent.id)
+    product2 = Product.create!(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id)
+
+    assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
+  end
+
+  should 'combine different boost types' do
+    TestSolr.enable
+    product = Product.create!(:name => 'product', :product_category => product_category,	:enterprise_id => profile.id)
+    image_only = Product.create!(:name => 'product with image', :product_category => product_category,
+                                 :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')},
+                                 :enterprise_id => profile.id)
+    qual_only = Product.create!(:name => 'product with qualifier', :product_category => product_category,
+                                :enterprise_id => profile.id)
+    img_and_qual = Product.create!(:name => 'product with image and qualifier', :product_category => product_category,
+                                   :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')},
+                                   :enterprise_id => profile.id)
+    qual_only.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil)
+    img_and_qual.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil)
+    qual_only.save!
+    img_and_qual.save!
+
+    assert_equal [img_and_qual, image_only, qual_only, product], Product.find_by_contents('product')[:results].docs
+  end
 end
@@ -14,4 +14,45 @@ class ProfileTest &lt; ActiveSupport::TestCase
     Profile.expects(:solr_batch_add).with(includes(art))
     profile.save!
   end
+
+  should 'act as faceted' do
+    st = fast_create(State, :acronym => 'XZ')
+    city = fast_create(City, :name => 'Tabajara', :parent_id => st.id)
+    cat = fast_create(Category)
+    prof = fast_create(Person, :region_id => city.id)
+    prof.add_category(cat, true)
+    assert_equal ['Tabajara', ', XZ'], Profile.facet_by_id(:solr_plugin_f_region)[:proc].call(prof.send(:solr_plugin_f_region))
+    assert_equal "solr_plugin_category_filter:#{cat.id}", Person.facet_category_query.call(cat)
+  end
+
+  should 'act as searchable' do
+    TestSolr.enable
+    st = create(State, :name => 'California', :acronym => 'CA', :environment_id => Environment.default.id)
+    city = create(City, :name => 'Inglewood', :parent_id => st.id, :environment_id => Environment.default.id)
+    p = create(Person, :name => "Hiro", :address => 'U-Stor-It', :nickname => 'Protagonist',
+               :user_id => fast_create(User).id, :region_id => city.id)
+    cat = create(Category, :name => "Science Fiction", :acronym => "sf", :abbreviation => "sci-fi")
+    p.add_category cat
+
+    # fields
+    assert_includes Profile.find_by_contents('Hiro')[:results].docs, p
+    assert_includes Profile.find_by_contents('Protagonist')[:results].docs, p
+    # filters
+    assert_includes Profile.find_by_contents('Hiro', {}, { :filter_queries => ["solr_plugin_public:true"]})[:results].docs, p
+    assert_not_includes Profile.find_by_contents('Hiro', {}, { :filter_queries => ["solr_plugin_public:false"]})[:results].docs, p
+    assert_includes Profile.find_by_contents('Hiro', {}, { :filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, p
+    # includes
+    assert_includes Profile.find_by_contents("Inglewood")[:results].docs, p
+    assert_includes Profile.find_by_contents("California")[:results].docs, p
+    assert_includes Profile.find_by_contents("Science")[:results].docs, p
+    # not includes
+    assert_not_includes Profile.find_by_contents('Stor')[:results].docs, p
+  end
+
+  should 'boost name matches' do
+    TestSolr.enable
+    in_addr = create(Person, :name => 'something', :address => 'bananas in the address!', :user_id => fast_create(User).id)
+    in_name = create(Person, :name => 'bananas in the name!', :user_id => fast_create(User).id)
+    assert_equal [in_name], Person.find_by_contents('bananas')[:results].docs
+  end
 end
 require File.dirname(__FILE__) + '/../test_helper'
+require 'acts_as_faceted'
 class TestModel < ActiveRecord::Base
   def self.f_type_proc(klass)
 require File.dirname(__FILE__) + '/../test_helper'
-
+require 'acts_as_searchable'
 class ActsAsSearchableTest < ActiveSupport::TestCase
@@ -1588,76 +1588,6 @@ class ArticleTest &lt; ActiveSupport::TestCase
     article.environment_id
   end
-  should 'act as faceted' do
-    person = fast_create(Person)
-    cat = Category.create!(:name => 'hardcore', :environment_id => Environment.default.id)
-    a = Article.create!(:name => 'black flag review', :profile_id => person.id)
-    a.add_category(cat, true)
-    a.save!
-    assert_equal Article.type_name, Article.facet_by_id(:f_type)[:proc].call(a.send(:f_type))
-    assert_equal Person.type_name, Article.facet_by_id(:f_profile_type)[:proc].call(a.send(:f_profile_type))
-    assert_equal a.published_at, a.send(:f_published_at)
-    assert_equal ['hardcore'], a.send(:f_category)
-    assert_equal "category_filter:\"#{cat.id}\"", Article.facet_category_query.call(cat)
-  end
-
-  should 'act as searchable' do
-    TestSolr.enable
-    person = fast_create(Person, :name => "Hiro", :address => 'U-Stor-It @ Inglewood, California',
-                         :nickname => 'Protagonist')
-    person2 = fast_create(Person, :name => "Raven")
-    category = fast_create(Category, :name => "science fiction", :acronym => "sf", :abbreviation => "sci-fi")
-    a = Article.create!(:name => 'a searchable article about bananas', :profile_id => person.id,
-                        :body => 'the body talks about mosquitos', :abstract => 'and the abstract is about beer',
-                        :filename => 'not_a_virus.exe')
-    a.add_category(category)
-    c = a.comments.build(:title => 'snow crash', :author => person2, :body => 'wanna try some?')
-    c.save!
-
-    # fields
-    assert_includes Article.find_by_contents('bananas')[:results].docs, a
-    assert_includes Article.find_by_contents('mosquitos')[:results].docs, a
-    assert_includes Article.find_by_contents('beer')[:results].docs, a
-    assert_includes Article.find_by_contents('not_a_virus.exe')[:results].docs, a
-    # filters
-    assert_includes Article.find_by_contents('bananas', {}, {:filter_queries => ["public:true"]})[:results].docs, a
-    assert_not_includes Article.find_by_contents('bananas', {}, {:filter_queries => ["public:false"]})[:results].docs, a
-    assert_includes Article.find_by_contents('bananas', {}, {:filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, a
-    assert_includes Article.find_by_contents('bananas', {}, {:filter_queries => ["profile_id:\"#{person.id}\""]})[:results].docs, a
-    # includes
-    assert_includes Article.find_by_contents('Hiro')[:results].docs, a
-    assert_includes Article.find_by_contents("person-#{person.id}")[:results].docs, a
-    assert_includes Article.find_by_contents("California")[:results].docs, a
-    assert_includes Article.find_by_contents("Protagonist")[:results].docs, a
-# FIXME: After merging with AI1826, searching on comments is not working
-#    assert_includes Article.find_by_contents("snow")[:results].docs, a
-#    assert_includes Article.find_by_contents("try some")[:results].docs, a
-#    assert_includes Article.find_by_contents("Raven")[:results].docs, a
-#
-# FIXME: After merging with AI1826, searching on categories is not working
-#    assert_includes Article.find_by_contents("science")[:results].docs, a
-#    assert_includes Article.find_by_contents(category.slug)[:results].docs, a
-#    assert_includes Article.find_by_contents("sf")[:results].docs, a
-#    assert_includes Article.find_by_contents("sci-fi")[:results].docs, a
-  end
-
-  should 'boost name matches' do
-    TestSolr.enable
-    person = fast_create(Person)
-    in_body = Article.create!(:name => 'something', :profile_id => person.id, :body => 'bananas in the body!')
-    in_name = Article.create!(:name => 'bananas in the name!', :profile_id => person.id)
-    assert_equal [in_name, in_body], Article.find_by_contents('bananas')[:results].docs
-  end
-
-  should 'boost if profile is enabled' do
-    TestSolr.enable
-    person2 = fast_create(Person, :enabled => false)
-    art_profile_disabled = Article.create!(:name => 'profile disabled', :profile_id => person2.id)
-    person1 = fast_create(Person, :enabled => true)
-    art_profile_enabled = Article.create!(:name => 'profile enabled', :profile_id => person1.id)
-    assert_equal [art_profile_enabled, art_profile_disabled], Article.find_by_contents('profile')[:results].docs
-  end
-
   should 'remove all categorizations when destroyed' do
     art = Article.create!(:name => 'article 1', :profile_id => fast_create(Person).id)
     cat = Category.create!(:name => 'category 1', :environment_id => Environment.default.id)
@@ -513,28 +513,6 @@ class CategoryTest &lt; ActiveSupport::TestCase
     assert p.categories.reload.empty?
   end
-  should 'act as searchable' do
-    TestSolr.enable
-    parent = fast_create(Category, :name => 'books')
-    c = Category.create!(:name => "science fiction", :acronym => "sf", :abbreviation => "sci-fi",
-                         :environment_id => Environment.default.id, :parent_id => parent.id)
-
-    # fields
-    assert_includes Category.find_by_contents('fiction')[:results].docs, c
-    assert_includes Category.find_by_contents('sf')[:results].docs, c
-    assert_includes Category.find_by_contents('sci-fi')[:results].docs, c
-    # filters
-    assert_includes Category.find_by_contents('science', {}, {
-      :filter_queries => ["parent_id:#{parent.id}"]})[:results].docs, c
-  end
-
-  should 'boost name matches' do
-    TestSolr.enable
-    c_abbr = Category.create!(:name => "something else", :abbreviation => "science", :environment_id => Environment.default.id)
-    c_name = Category.create!(:name => "science fiction", :environment_id => Environment.default.id)
-    assert_equal [c_name, c_abbr], Category.find_by_contents("science")[:results].docs
-  end
-
   should 'solr save' do
     c = @env.categories.build(:name => 'my category');
     c.expects(:solr_save)
@@ -578,178 +578,6 @@ class ProductTest &lt; ActiveSupport::TestCase
     product.environment_id
   end
-  should 'act as faceted' do
-    s = fast_create(State, :acronym => 'XZ')
-    c = fast_create(City, :name => 'Tabajara', :parent_id => s.id)
-    ent = fast_create(Enterprise, :region_id => c.id)
-    cat = fast_create(ProductCategory, :name => 'hardcore')
-    p = Product.create!(:name => 'black flag', :enterprise_id => ent.id, :product_category_id => cat.id)
-    pq = p.product_qualifiers.create!(:qualifier => fast_create(Qualifier, :name => 'qualifier'),
-                                      :certifier => fast_create(Certifier, :name => 'certifier'))
-    assert_equal 'Related products', Product.facet_by_id(:f_category)[:label]
-    assert_equal ['Tabajara', ', XZ'], Product.facet_by_id(:f_region)[:proc].call(p.send(:f_region))
-    assert_equal ['qualifier', ' cert. certifier'], Product.facet_by_id(:f_qualifier)[:proc].call(p.send(:f_qualifier).last)
-    assert_equal 'hardcore', p.send(:f_category)
-    assert_equal "category_filter:#{cat.id}", Product.facet_category_query.call(cat)
-  end
-
-  should 'act as searchable' do
-    TestSolr.enable
-    s = fast_create(State, :acronym => 'XZ')
-    c = fast_create(City, :name => 'Tabajara', :parent_id => s.id)
-    ent = fast_create(Enterprise, :region_id => c.id, :name => "Black Sun")
-    category = fast_create(ProductCategory, :name => "homemade", :acronym => "hm", :abbreviation => "homey")
-    p = Product.create!(:name => 'bananas syrup', :description => 'surrounded by mosquitos', :enterprise_id => ent.id,
-                        :product_category_id => category.id)
-    qual = Qualifier.create!(:name => 'qualificador', :environment_id => Environment.default.id)
-    cert = Certifier.create!(:name => 'certificador', :environment_id => Environment.default.id)
-    pq = p.product_qualifiers.create!(:qualifier => qual,	:certifier => cert)
-    p.qualifiers.reload
-    p.certifiers.reload
-    p.save!
-    # fields
-    assert_includes Product.find_by_contents('bananas')[:results].docs, p
-    assert_includes Product.find_by_contents('mosquitos')[:results].docs, p
-    assert_includes Product.find_by_contents('homemade')[:results].docs, p
-    # filters
-    assert_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["public:true"]})[:results].docs, p
-    assert_not_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["public:false"]})[:results].docs, p
-    assert_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, p
-    # includes
-    assert_includes Product.find_by_contents("homemade")[:results].docs, p
-    assert_includes Product.find_by_contents(category.slug)[:results].docs, p
-    assert_includes Product.find_by_contents("hm")[:results].docs, p
-    assert_includes Product.find_by_contents("homey")[:results].docs, p
-    assert_includes Product.find_by_contents("Tabajara")[:results].docs, p
-    assert_includes Product.find_by_contents("Black Sun")[:results].docs, p
-    assert_includes Product.find_by_contents("qualificador")[:results].docs, p
-    assert_includes Product.find_by_contents("certificador")[:results].docs, p
-  end
-
-  should 'boost name matches' do
-    TestSolr.enable
-    ent = fast_create(Enterprise)
-    cat = fast_create(ProductCategory)
-    in_desc = Product.create!(:name => 'something', :enterprise_id => ent.id, :description => 'bananas in the description!',
-                              :product_category_id => cat.id)
-    in_name = Product.create!(:name => 'bananas in the name!', :enterprise_id => ent.id, :product_category_id => cat.id)
-    assert_equal [in_name, in_desc], Product.find_by_contents('bananas')[:results].docs
-  end
-
-  should 'boost search results that include an image' do
-    TestSolr.enable
-    product_without_image = Product.create!(:name => 'product without image', :product_category => @product_category,
-                                            :enterprise_id => @profile.id)
-    product_with_image = Product.create!(:name => 'product with image', :product_category => @product_category,
-                                         :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')},
-                                         :enterprise_id => @profile.id)
-    assert_equal [product_with_image, product_without_image], Product.find_by_contents('product image')[:results].docs
-  end
-
-  should 'boost search results that include qualifier' do
-    TestSolr.enable
-    product_without_q = Product.create!(:name => 'product without qualifier', :product_category => @product_category,
-                                        :enterprise_id => @profile.id)
-    product_with_q = Product.create!(:name => 'product with qualifier', :product_category => @product_category,
-                                     :enterprise_id => @profile.id)
-    product_with_q.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil)
-    product_with_q.save!
-
-    assert_equal [product_with_q, product_without_q], Product.find_by_contents('product qualifier')[:results].docs
-  end
-
-  should 'boost search results with open price' do
-    TestSolr.enable
-    product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => @profile.id, :price => 100)
-    open_price = Product.new(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id, :price => 100)
-    open_price.inputs << Input.new(:product => open_price, :product_category_id => @product_category.id, :amount_used => 10, :price_per_unit => 10)
-    open_price.save!
-
-    assert_equal [open_price, product], Product.find_by_contents('product')[:results].docs
-  end
-
-  should 'boost search results with solidarity inputs' do
-    TestSolr.enable
-    product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => @profile.id)
-    perc_50 = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id)
-    Input.create!(:product_id => perc_50.id, :product_category_id => @product_category.id,
-                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
-    Input.create!(:product_id => perc_50.id, :product_category_id => @product_category.id,
-                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false)
-    perc_50.save!
-    perc_75 = Product.create!(:name => 'product 3', :product_category => @product_category, :enterprise_id => @profile.id)
-    Input.create!(:product_id => perc_75.id, :product_category_id => @product_category.id,
-                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false)
-    Input.create!(:product_id => perc_75.id, :product_category_id => @product_category.id,
-                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
-    Input.create!(:product_id => perc_75.id, :product_category_id => @product_category.id,
-                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
-    Input.create!(:product_id => perc_75.id, :product_category_id => @product_category.id,
-                  :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
-    perc_75.save!
-
-    assert_equal [perc_75, perc_50, product], Product.find_by_contents('product')[:results].docs
-  end
-
-  should 'boost available search results' do
-    TestSolr.enable
-    product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => @profile.id)
-    product.available = false
-    product.save!
-    product2 = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id)
-    product2.available = true
-    product2.save!
-
-    assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
-  end
-
-  should 'boost search results created updated recently' do
-    TestSolr.enable
-    product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => @profile.id)
-    product.update_attribute :created_at, Time.now - 10.day
-    product2 = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id)
-
-    assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
-  end
-
-  should 'boost search results with description' do
-    TestSolr.enable
-    product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => @profile.id,
-                              :description => '')
-    product2 = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id,
-                               :description => 'a small description')
-
-    assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
-  end
-
-  should 'boost if enterprise is enabled' do
-    TestSolr.enable
-    ent = Enterprise.create!(:name => 'ent', :identifier => 'ent', :enabled => false)
-    product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => ent.id)
-    product2 = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id)
-
-    assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
-  end
-
-  should 'combine different boost types' do
-    TestSolr.enable
-    product = Product.create!(:name => 'product', :product_category => @product_category,	:enterprise_id => @profile.id)
-    image_only = Product.create!(:name => 'product with image', :product_category => @product_category,
-                                 :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')},
-                                 :enterprise_id => @profile.id)
-    qual_only = Product.create!(:name => 'product with qualifier', :product_category => @product_category,
-                                :enterprise_id => @profile.id)
-    img_and_qual = Product.create!(:name => 'product with image and qualifier', :product_category => @product_category,
-                                   :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')},
-                                   :enterprise_id => @profile.id)
-    qual_only.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil)
-    img_and_qual.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil)
-    qual_only.save!
-    img_and_qual.save!
-
-    assert_equal [img_and_qual, image_only, qual_only, product], Product.find_by_contents('product')[:results].docs
-  end
-
   should 'return more recent products' do
     Product.destroy_all
@@ -1868,47 +1868,6 @@ class ProfileTest &lt; ActiveSupport::TestCase
     assert profile.errors.invalid?(:identifier)
   end
-  should 'act as faceted' do
-    st = fast_create(State, :acronym => 'XZ')
-    city = fast_create(City, :name => 'Tabajara', :parent_id => st.id)
-    cat = fast_create(Category)
-    prof = fast_create(Person, :region_id => city.id)
-    prof.add_category(cat, true)
-    assert_equal ['Tabajara', ', XZ'], Profile.facet_by_id(:f_region)[:proc].call(prof.send(:f_region))
-    assert_equal "category_filter:#{cat.id}", Person.facet_category_query.call(cat)
-  end
-
-  should 'act as searchable' do
-    TestSolr.enable
-    st = create(State, :name => 'California', :acronym => 'CA', :environment_id => Environment.default.id)
-    city = create(City, :name => 'Inglewood', :parent_id => st.id, :environment_id => Environment.default.id)
-    p = create(Person, :name => "Hiro", :address => 'U-Stor-It', :nickname => 'Protagonist',
-               :user_id => fast_create(User).id, :region_id => city.id)
-    cat = create(Category, :name => "Science Fiction", :acronym => "sf", :abbreviation => "sci-fi")
-    p.add_category cat
-
-    # fields
-    assert_includes Profile.find_by_contents('Hiro')[:results].docs, p
-    assert_includes Profile.find_by_contents('Protagonist')[:results].docs, p
-    # filters
-    assert_includes Profile.find_by_contents('Hiro', {}, { :filter_queries => ["public:true"]})[:results].docs, p
-    assert_not_includes Profile.find_by_contents('Hiro', {}, { :filter_queries => ["public:false"]})[:results].docs, p
-    assert_includes Profile.find_by_contents('Hiro', {}, { :filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, p
-    # includes
-    assert_includes Profile.find_by_contents("Inglewood")[:results].docs, p
-    assert_includes Profile.find_by_contents("California")[:results].docs, p
-    assert_includes Profile.find_by_contents("Science")[:results].docs, p
-    # not includes
-    assert_not_includes Profile.find_by_contents('Stor')[:results].docs, p
-  end
-
-  should 'boost name matches' do
-    TestSolr.enable
-    in_addr = create(Person, :name => 'something', :address => 'bananas in the address!', :user_id => fast_create(User).id)
-    in_name = create(Person, :name => 'bananas in the name!', :user_id => fast_create(User).id)
-    assert_equal [in_name], Person.find_by_contents('bananas')[:results].docs
-  end
-
   should 'respond to redirection_after_login' do
     assert_respond_to Profile.new, :redirection_after_login
   end
	@@ -647,80 +647,12 @@ class Article < ActiveRecord::Base		@@ -647,80 +647,12 @@ class Article < ActiveRecord::Base
647	Forum	647	Forum
648	Event	648	Event
649		649
650	- def self.f_type_proc(klass)
651	- klass.constantize.type_name
652	- end
653	-
654	- def self.f_profile_type_proc(klass)
655	- klass.constantize.type_name
656	- end
657	-
658	- def f_type
659	- #join common types
660	- case self.class.name
661	- when 'TinyMceArticle', 'TextileArticle'
662	- TextArticle.name
663	- else
664	- self.class.name
665	- end
666	- end
667	-
668	- def f_profile_type
669	- self.profile.class.name
670	- end
671	-
672	- def f_published_at
673	- self.published_at
674	- end
675	-
676	- def f_category
677	- self.categories.collect(&:name)
678	- end
679	-
680	delegate :region, :region_id, :environment, :environment_id, :to => :profile, :allow_nil => true	650	delegate :region, :region_id, :environment, :environment_id, :to => :profile, :allow_nil => true
681	def name_sortable # give a different name for solr	651	def name_sortable # give a different name for solr
682	name	652	name
683	end	653	end
684		654
685	- def public
686	- self.public?
687	- end
688	-
689	- def category_filter
690	- categories_including_virtual_ids
691	- end
692	-
693	public	655	public
694	-
695	- acts_as_faceted :fields => {
696	- :f_type => {:label => _('Type'), :proc => proc{\|klass\| f_type_proc(klass)}},
697	- :f_published_at => {:type => :date, :label => _('Published date'), :queries => {'[* TO NOW-1YEARS/DAY]' => _("Older than one year"),
698	- '[NOW-1YEARS TO NOW/DAY]' => _("In the last year"), '[NOW-1MONTHS TO NOW/DAY]' => _("In the last month"), '[NOW-7DAYS TO NOW/DAY]' => _("In the last week"), '[NOW-1DAYS TO NOW/DAY]' => _("In the last day")},
699	- :queries_order => ['[NOW-1DAYS TO NOW/DAY]', '[NOW-7DAYS TO NOW/DAY]', '[NOW-1MONTHS TO NOW/DAY]', '[NOW-1YEARS TO NOW/DAY]', '[* TO NOW-1YEARS/DAY]']},
700	- :f_profile_type => {:label => _('Profile'), :proc => proc{\|klass\| f_profile_type_proc(klass)}},
701	- :f_category => {:label => _('Categories')},
702	- }, :category_query => proc { \|c\| "category_filter:\"#{c.id}\"" },
703	- :order => [:f_type, :f_published_at, :f_profile_type, :f_category]
704	-
705	- acts_as_searchable :fields => facets_fields_for_solr + [
706	- # searched fields
707	- {:name => {:type => :text, :boost => 2.0}},
708	- {:slug => :text}, {:body => :text},
709	- {:abstract => :text}, {:filename => :text},
710	- # filtered fields
711	- {:public => :boolean}, {:environment_id => :integer},
712	- {:profile_id => :integer}, :language,
713	- {:category_filter => :integer},
714	- # ordered/query-boosted fields
715	- {:name_sortable => :string}, :last_changed_by_id, :published_at, :is_image,
716	- :updated_at, :created_at,
717	- ], :include => [
718	- {:profile => {:fields => [:name, :identifier, :address, :nickname, :region_id, :lat, :lng]}},
719	- {:comments => {:fields => [:title, :body, :author_name, :author_email]}},
720	- {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
721	- ], :facets => facets_option_for_solr,
722	- :boost => proc { \|a\| 10 if a.profile && a.profile.enabled },
723	- :if => proc{ \|a\| ! ['RssFeed'].include?(a.class.name) }
724	handle_asynchronously :solr_save	656	handle_asynchronously :solr_save
725		657
726	private	658	private
	@@ -95,17 +95,6 @@ class Category < ActiveRecord::Base		@@ -95,17 +95,6 @@ class Category < ActiveRecord::Base
95	name	95	name
96	end	96	end
97	public	97	public
98	-
99	- acts_as_searchable :fields => [
100	- # searched fields
101	- {:name => {:type => :text, :boost => 2.0}},
102	- {:path => :text}, {:slug => :text},
103	- {:abbreviation => :text}, {:acronym => :text},
104	- # filtered fields
105	- :parent_id,
106	- # ordered/query-boosted fields
107	- {:name_sortable => :string},
108	- ]
109	handle_asynchronously :solr_save	98	handle_asynchronously :solr_save
110		99
111	end	100	end
	@@ -212,87 +212,20 @@ class Product < ActiveRecord::Base		@@ -212,87 +212,20 @@ class Product < ActiveRecord::Base
212	end	212	end
213		213
214	private	214	private
215	- def f_category
216	- self.product_category.name
217	- end
218	- def f_region
219	- self.enterprise.region.id if self.enterprise.region
220	- end
221	- def self.f_region_proc(id)
222	- c = Region.find(id)
223	- s = c.parent
224	- if c and c.kind_of?(City) and s and s.kind_of?(State) and s.acronym
225	- [c.name, ', ' + s.acronym]
226	- else
227	- c.name
228	- end
229	- end
230	- def self.f_qualifier_proc(ids)
231	- array = ids.split
232	- qualifier = Qualifier.find_by_id array[0]
233	- certifier = Certifier.find_by_id array[1]
234	- certifier ? [qualifier.name, _(' cert. ') + certifier.name] : qualifier.name
235	- end
236	- def f_qualifier
237	- product_qualifiers.map do \|pq\|
238	- "#{pq.qualifier_id} #{pq.certifier_id}"
239	- end
240	- end
241		215
242	- alias_method :name_sortable, :name
243	delegate :enabled, :region, :region_id, :environment, :environment_id, :to => :enterprise	216	delegate :enabled, :region, :region_id, :environment, :environment_id, :to => :enterprise
		217	+
		218	+ alias_method :name_sortable, :name
244	def name_sortable # give a different name for solr	219	def name_sortable # give a different name for solr
245	name	220	name
246	end	221	end
247	- def public
248	- self.public?
249	- end	222	+
250	def price_sortable	223	def price_sortable
251	(price.nil? or price.zero?) ? nil : price	224	(price.nil? or price.zero?) ? nil : price
252	end	225	end
253	- def category_filter
254	- enterprise.categories_including_virtual_ids << product_category_id
255	- end	226	+
256	public	227	public
257		228
258	- acts_as_faceted :fields => {
259	- :f_category => {:label => _('Related products')},
260	- :f_region => {:label => _('City'), :proc => proc { \|id\| f_region_proc(id) }},
261	- :f_qualifier => {:label => _('Qualifiers'), :proc => proc { \|id\| f_qualifier_proc(id) }},
262	- }, :category_query => proc { \|c\| "category_filter:#{c.id}" },
263	- :order => [:f_category, :f_region, :f_qualifier]
264	-
265	- Boosts = [
266	- [:image, 0.55, proc{ \|p\| p.image ? 1 : 0}],
267	- [:qualifiers, 0.45, proc{ \|p\| p.product_qualifiers.count > 0 ? 1 : 0}],
268	- [:open_price, 0.45, proc{ \|p\| p.price_described? ? 1 : 0}],
269	- [:solidarity, 0.45, proc{ \|p\| p.percentage_from_solidarity_economy[0].to_f/100 }],
270	- [:available, 0.35, proc{ \|p\| p.available ? 1 : 0}],
271	- [:price, 0.35, proc{ \|p\| (!p.price.nil? and p.price > 0) ? 1 : 0}],
272	- [:new_product, 0.35, proc{ \|p\| (p.updated_at.to_i - p.created_at.to_i) < 24*3600 ? 1 : 0}],
273	- [:description, 0.3, proc{ \|p\| !p.description.blank? ? 1 : 0}],
274	- [:enabled, 0.2, proc{ \|p\| p.enterprise.enabled ? 1 : 0}],
275	- ]
276	-
277	- acts_as_searchable :fields => facets_fields_for_solr + [
278	- # searched fields
279	- {:name => {:type => :text, :boost => 2.0}},
280	- {:description => :text}, {:category_full_name => :text},
281	- # filtered fields
282	- {:public => :boolean}, {:environment_id => :integer},
283	- {:enabled => :boolean}, {:category_filter => :integer},
284	- # ordered/query-boosted fields
285	- {:price_sortable => :decimal}, {:name_sortable => :string},
286	- {:lat => :float}, {:lng => :float},
287	- :updated_at, :created_at,
288	- ], :include => [
289	- {:product_category => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
290	- {:region => {:fields => [:name, :path, :slug, :lat, :lng]}},
291	- {:enterprise => {:fields => [:name, :identifier, :address, :nickname, :lat, :lng]}},
292	- {:qualifiers => {:fields => [:name]}},
293	- {:certifiers => {:fields => [:name]}},
294	- ], :facets => facets_option_for_solr,
295	- :boost => proc{ \|p\| boost = 1; Boosts.each{ \|b\| boost = boost * (1 - ((1 - b[2].call(p)) * b[1])) }; boost}
296	handle_asynchronously :solr_save	229	handle_asynchronously :solr_save
297		230
298	end	231	end
	@@ -887,82 +887,12 @@ private :generate_url, :url_options		@@ -887,82 +887,12 @@ private :generate_url, :url_options
887	end	887	end
888		888
889	private	889	private
890	- def self.f_categories_label_proc(environment)
891	- ids = environment.top_level_category_as_facet_ids
892	- r = Category.find(ids)
893	- map = {}
894	- ids.map{ \|id\| map[id.to_s] = r.detect{\|c\| c.id == id}.name }
895	- map
896	- end
897	- def self.f_categories_proc(facet, id)
898	- id = id.to_i
899	- return if id.zero?
900	- c = Category.find(id)
901	- c.name if c.top_ancestor.id == facet[:label_id].to_i or facet[:label_id] == 0
902	- end
903	- def f_categories
904	- category_ids - [region_id]
905	- end
906	-
907	- def f_region
908	- self.region_id
909	- end
910	- def self.f_region_proc(id)
911	- c = Region.find(id)
912	- s = c.parent
913	- if c and c.kind_of?(City) and s and s.kind_of?(State) and s.acronym
914	- [c.name, ', ' + s.acronym]
915	- else
916	- c.name
917	- end
918	- end
919	-
920	- def self.f_enabled_proc(enabled)
921	- enabled = enabled == "true" ? true : false
922	- enabled ? s_('facets\|Enabled') : s_('facets\|Not enabled')
923	- end
924	- def f_enabled
925	- self.enabled
926	- end
927		890
928	def name_sortable # give a different name for solr	891	def name_sortable # give a different name for solr
929	name	892	name
930	end	893	end
931	- def public
932	- self.public?
933	- end
934	- def category_filter
935	- categories_including_virtual_ids
936	- end
937	- public
938		894
939	- acts_as_faceted :fields => {
940	- :f_enabled => {:label => _('Situation'), :type_if => proc { \|klass\| klass.kind_of?(Enterprise) },
941	- :proc => proc { \|id\| f_enabled_proc(id) }},
942	- :f_region => {:label => _('City'), :proc => proc { \|id\| f_region_proc(id) }},
943	- :f_categories => {:multi => true, :proc => proc {\|facet, id\| f_categories_proc(facet, id)},
944	- :label => proc { \|env\| f_categories_label_proc(env) }, :label_abbrev => proc{ \|env\| f_categories_label_abbrev_proc(env) }},
945	- }, :category_query => proc { \|c\| "category_filter:#{c.id}" },
946	- :order => [:f_region, :f_categories, :f_enabled]
947	-
948	- acts_as_searchable :fields => facets_fields_for_solr + [:extra_data_for_index,
949	- # searched fields
950	- {:name => {:type => :text, :boost => 2.0}},
951	- {:identifier => :text}, {:nickname => :text},
952	- # filtered fields
953	- {:public => :boolean}, {:environment_id => :integer},
954	- {:category_filter => :integer},
955	- # ordered/query-boosted fields
956	- {:name_sortable => :string}, {:user_id => :integer},
957	- :enabled, :active, :validated, :public_profile,
958	- {:lat => :float}, {:lng => :float},
959	- :updated_at, :created_at,
960	- ],
961	- :include => [
962	- {:region => {:fields => [:name, :path, :slug, :lat, :lng]}},
963	- {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
964	- ], :facets => facets_option_for_solr,
965	- :boost => proc{ \|p\| 10 if p.enabled }	895	+ public
966		896
967	handle_asynchronously :solr_save	897	handle_asynchronously :solr_save
968		898
	@@ -4,4 +4,74 @@ class Article		@@ -4,4 +4,74 @@ class Article
4	def solr_plugin_comments_updated	4	def solr_plugin_comments_updated
5	solr_save	5	solr_save
6	end	6	end
		7	+
		8	+ acts_as_faceted :fields => {
		9	+ :solr_plugin_f_type => {:label => _('Type'), :proc => proc{\|klass\| solr_plugin_f_type_proc(klass)}},
		10	+ :solr_plugin_f_published_at => {:type => :date, :label => _('Published date'), :queries => {'[* TO NOW-1YEARS/DAY]' => _("Older than one year"),
		11	+ '[NOW-1YEARS TO NOW/DAY]' => _("In the last year"), '[NOW-1MONTHS TO NOW/DAY]' => _("In the last month"), '[NOW-7DAYS TO NOW/DAY]' => _("In the last week"), '[NOW-1DAYS TO NOW/DAY]' => _("In the last day")},
		12	+ :queries_order => ['[NOW-1DAYS TO NOW/DAY]', '[NOW-7DAYS TO NOW/DAY]', '[NOW-1MONTHS TO NOW/DAY]', '[NOW-1YEARS TO NOW/DAY]', '[* TO NOW-1YEARS/DAY]']},
		13	+ :solr_plugin_f_profile_type => {:label => _('Profile'), :proc => proc{\|klass\| solr_plugin_f_profile_type_proc(klass)}},
		14	+ :solr_plugin_f_category => {:label => _('Categories')},
		15	+ }, :category_query => proc { \|c\| "solr_plugin_category_filter:\"#{c.id}\"" },
		16	+ :order => [:solr_plugin_f_type, :solr_plugin_f_published_at, :solr_plugin_f_profile_type, :solr_plugin_f_category]
		17	+
		18	+ acts_as_searchable :fields => facets_fields_for_solr + [
		19	+ # searched fields
		20	+ {:name => {:type => :text, :boost => 2.0}},
		21	+ {:slug => :text}, {:body => :text},
		22	+ {:abstract => :text}, {:filename => :text},
		23	+ # filtered fields
		24	+ {:solr_plugin_public => :boolean}, {:environment_id => :integer},
		25	+ {:profile_id => :integer}, :language,
		26	+ {:solr_plugin_category_filter => :integer},
		27	+ # ordered/query-boosted fields
		28	+ {:name_sortable => :string}, :last_changed_by_id, :published_at, :is_image,
		29	+ :updated_at, :created_at,
		30	+ ], :include => [
		31	+ {:profile => {:fields => [:name, :identifier, :address, :nickname, :region_id, :lat, :lng]}},
		32	+ {:comments => {:fields => [:title, :body, :author_name, :author_email]}},
		33	+ {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
		34	+ ], :facets => facets_option_for_solr,
		35	+ :boost => proc { \|a\| 10 if a.profile && a.profile.enabled },
		36	+ :if => proc{ \|a\| ! ['RssFeed'].include?(a.class.name) }
		37	+
		38	+ private
		39	+
		40	+ def self.solr_plugin_f_type_proc(klass)
		41	+ klass.constantize.type_name
		42	+ end
		43	+
		44	+ def self.solr_plugin_f_profile_type_proc(klass)
		45	+ klass.constantize.type_name
		46	+ end
		47	+
		48	+ def solr_plugin_f_type
		49	+ #join common types
		50	+ case self.class.name
		51	+ when 'TinyMceArticle', 'TextileArticle'
		52	+ TextArticle.name
		53	+ else
		54	+ self.class.name
		55	+ end
		56	+ end
		57	+
		58	+ def solr_plugin_f_profile_type
		59	+ self.profile.class.name
		60	+ end
		61	+
		62	+ def solr_plugin_f_published_at
		63	+ self.published_at
		64	+ end
		65	+
		66	+ def solr_plugin_f_category
		67	+ self.categories.collect(&:name)
		68	+ end
		69	+
		70	+ def solr_plugin_public
		71	+ self.public?
		72	+ end
		73	+
		74	+ def solr_plugin_category_filter
		75	+ categories_including_virtual_ids
		76	+ end
7	end	77	end
	@@ -2,4 +2,15 @@ require_dependency 'category'		@@ -2,4 +2,15 @@ require_dependency 'category'
2		2
3	class Category	3	class Category
4	after_save_reindex [:articles, :profiles], :with => :delayed_job	4	after_save_reindex [:articles, :profiles], :with => :delayed_job
		5	+
		6	+ acts_as_searchable :fields => [
		7	+ # searched fields
		8	+ {:name => {:type => :text, :boost => 2.0}},
		9	+ {:path => :text}, {:slug => :text},
		10	+ {:abbreviation => :text}, {:acronym => :text},
		11	+ # filtered fields
		12	+ :parent_id,
		13	+ # ordered/query-boosted fields
		14	+ {:name_sortable => :string},
		15	+ ]
5	end	16	end
	@@ -2,4 +2,84 @@ require_dependency 'product'		@@ -2,4 +2,84 @@ require_dependency 'product'
2		2
3	class Product	3	class Product
4	after_save_reindex [:enterprise], :with => :delayed_job	4	after_save_reindex [:enterprise], :with => :delayed_job
		5	+
		6	+ acts_as_faceted :fields => {
		7	+ :solr_plugin_f_category => {:label => _('Related products')},
		8	+ :solr_plugin_f_region => {:label => _('City'), :proc => proc { \|id\| solr_plugin_f_region_proc(id) }},
		9	+ :solr_plugin_f_qualifier => {:label => _('Qualifiers'), :proc => proc { \|id\| solr_plugin_f_qualifier_proc(id) }},
		10	+ }, :category_query => proc { \|c\| "solr_plugin_category_filter:#{c.id}" },
		11	+ :order => [:solr_plugin_f_category, :solr_plugin_f_region, :solr_plugin_f_qualifier]
		12	+
		13	+ SolrPlugin::Boosts = [
		14	+ [:image, 0.55, proc{ \|p\| p.image ? 1 : 0}],
		15	+ [:qualifiers, 0.45, proc{ \|p\| p.product_qualifiers.count > 0 ? 1 : 0}],
		16	+ [:open_price, 0.45, proc{ \|p\| p.price_described? ? 1 : 0}],
		17	+ [:solidarity, 0.45, proc{ \|p\| p.percentage_from_solidarity_economy[0].to_f/100 }],
		18	+ [:available, 0.35, proc{ \|p\| p.available ? 1 : 0}],
		19	+ [:price, 0.35, proc{ \|p\| (!p.price.nil? and p.price > 0) ? 1 : 0}],
		20	+ [:new_product, 0.35, proc{ \|p\| (p.updated_at.to_i - p.created_at.to_i) < 24*3600 ? 1 : 0}],
		21	+ [:description, 0.3, proc{ \|p\| !p.description.blank? ? 1 : 0}],
		22	+ [:enabled, 0.2, proc{ \|p\| p.enterprise.enabled ? 1 : 0}],
		23	+ ]
		24	+
		25	+ acts_as_searchable :fields => facets_fields_for_solr + [
		26	+ # searched fields
		27	+ {:name => {:type => :text, :boost => 2.0}},
		28	+ {:description => :text}, {:category_full_name => :text},
		29	+ # filtered fields
		30	+ {:solr_plugin_public => :boolean}, {:environment_id => :integer},
		31	+ {:enabled => :boolean}, {:solr_plugin_category_filter => :integer},
		32	+ # ordered/query-boosted fields
		33	+ {:price_sortable => :decimal}, {:name_sortable => :string},
		34	+ {:lat => :float}, {:lng => :float},
		35	+ :updated_at, :created_at,
		36	+ ], :include => [
		37	+ {:product_category => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
		38	+ {:region => {:fields => [:name, :path, :slug, :lat, :lng]}},
		39	+ {:enterprise => {:fields => [:name, :identifier, :address, :nickname, :lat, :lng]}},
		40	+ {:qualifiers => {:fields => [:name]}},
		41	+ {:certifiers => {:fields => [:name]}},
		42	+ ], :facets => facets_option_for_solr,
		43	+ :boost => proc{ \|p\| boost = 1; SolrPlugin::Boosts.each{ \|b\| boost = boost * (1 - ((1 - b[2].call(p)) * b[1])) }; boost}
		44	+
		45	+ private
		46	+
		47	+ def solr_plugin_f_category
		48	+ self.product_category.name
		49	+ end
		50	+
		51	+ def solr_plugin_f_region
		52	+ self.enterprise.region.id if self.enterprise.region
		53	+ end
		54	+
		55	+ def self.solr_plugin_f_region_proc(id)
		56	+ c = Region.find(id)
		57	+ s = c.parent
		58	+ if c and c.kind_of?(City) and s and s.kind_of?(State) and s.acronym
		59	+ [c.name, ', ' + s.acronym]
		60	+ else
		61	+ c.name
		62	+ end
		63	+ end
		64	+
		65	+ def self.solr_plugin_f_qualifier_proc(ids)
		66	+ array = ids.split
		67	+ qualifier = Qualifier.find_by_id array[0]
		68	+ certifier = Certifier.find_by_id array[1]
		69	+ certifier ? [qualifier.name, _(' cert. ') + certifier.name] : qualifier.name
		70	+ end
		71	+
		72	+ def solr_plugin_f_qualifier
		73	+ product_qualifiers.map do \|pq\|
		74	+ "#{pq.qualifier_id} #{pq.certifier_id}"
		75	+ end
		76	+ end
		77	+
		78	+ def solr_plugin_category_filter
		79	+ enterprise.categories_including_virtual_ids << product_category_id
		80	+ end
		81	+
		82	+ def solr_plugin_public
		83	+ self.public?
		84	+ end
5	end	85	end
	@@ -2,4 +2,84 @@ require_dependency 'profile'		@@ -2,4 +2,84 @@ require_dependency 'profile'
2		2
3	class Profile	3	class Profile
4	after_save_reindex [:articles], :with => :delayed_job	4	after_save_reindex [:articles], :with => :delayed_job
		5	+
		6	+ acts_as_faceted :fields => {
		7	+ :solr_plugin_f_enabled => {:label => _('Situation'), :type_if => proc { \|klass\| klass.kind_of?(Enterprise) },
		8	+ :proc => proc { \|id\| solr_plugin_f_enabled_proc(id) }},
		9	+ :solr_plugin_f_region => {:label => _('City'), :proc => proc { \|id\| solr_plugin_f_region_proc(id) }},
		10	+ :solr_plugin_f_categories => {:multi => true, :proc => proc {\|facet, id\| solr_plugin_f_categories_proc(facet, id)},
		11	+ :label => proc { \|env\| solr_plugin_f_categories_label_proc(env) }, :label_abbrev => proc{ \|env\| solr_plugin_f_categories_label_abbrev_proc(env) }},
		12	+ }, :category_query => proc { \|c\| "solr_plugin_category_filter:#{c.id}" },
		13	+ :order => [:solr_plugin_f_region, :solr_plugin_f_categories, :solr_plugin_f_enabled]
		14	+
		15	+ acts_as_searchable :fields => facets_fields_for_solr + [:extra_data_for_index,
		16	+ # searched fields
		17	+ {:name => {:type => :text, :boost => 2.0}},
		18	+ {:identifier => :text}, {:nickname => :text},
		19	+ # filtered fields
		20	+ {:solr_plugin_public => :boolean}, {:environment_id => :integer},
		21	+ {:solr_plugin_category_filter => :integer},
		22	+ # ordered/query-boosted fields
		23	+ {:name_sortable => :string}, {:user_id => :integer},
		24	+ :enabled, :active, :validated, :public_profile,
		25	+ {:lat => :float}, {:lng => :float},
		26	+ :updated_at, :created_at,
		27	+ ],
		28	+ :include => [
		29	+ {:region => {:fields => [:name, :path, :slug, :lat, :lng]}},
		30	+ {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
		31	+ ], :facets => facets_option_for_solr,
		32	+ :boost => proc{ \|p\| 10 if p.enabled }
		33	+
		34	+ private
		35	+
		36	+ def self.solr_plugin_f_categories_label_proc(environment)
		37	+ ids = environment.top_level_category_as_facet_ids
		38	+ r = Category.find(ids)
		39	+ map = {}
		40	+ ids.map{ \|id\| map[id.to_s] = r.detect{\|c\| c.id == id}.name }
		41	+ map
		42	+ end
		43	+
		44	+ def self.solr_plugin_f_categories_proc(facet, id)
		45	+ id = id.to_i
		46	+ return if id.zero?
		47	+ c = Category.find(id)
		48	+ c.name if c.top_ancestor.id == facet[:label_id].to_i or facet[:label_id] == 0
		49	+ end
		50	+
		51	+ def solr_plugin_f_categories
		52	+ category_ids - [region_id]
		53	+ end
		54	+
		55	+ def solr_plugin_f_region
		56	+ self.region_id
		57	+ end
		58	+
		59	+ def self.solr_plugin_f_region_proc(id)
		60	+ c = Region.find(id)
		61	+ s = c.parent
		62	+ if c and c.kind_of?(City) and s and s.kind_of?(State) and s.acronym
		63	+ [c.name, ', ' + s.acronym]
		64	+ else
		65	+ c.name
		66	+ end
		67	+ end
		68	+
		69	+ def self.solr_plugin_f_enabled_proc(enabled)
		70	+ enabled = enabled == "true" ? true : false
		71	+ enabled ? s_('facets\|Enabled') : s_('facets\|Not enabled')
		72	+ end
		73	+
		74	+ def solr_plugin_f_enabled
		75	+ self.enabled
		76	+ end
		77	+
		78	+ def solr_plugin_public
		79	+ self.public?
		80	+ end
		81	+
		82	+ def solr_plugin_category_filter
		83	+ categories_including_virtual_ids
		84	+ end
5	end	85	end
	@@ -9,7 +9,7 @@ class CategoryTest < ActiveSupport::TestCase		@@ -9,7 +9,7 @@ class CategoryTest < ActiveSupport::TestCase
9	attr_accessor :environment	9	attr_accessor :environment
10		10
11	should 'reindex articles after saving' do	11	should 'reindex articles after saving' do
12	- cat = Category.create!(:name => 'category 1', :environment_id => Environment.default.id)	12	+ cat = Category.create!(:name => 'category 1', :environment_id => environment.id)
13	art = Article.create!(:name => 'something', :profile_id => fast_create(Person).id)	13	art = Article.create!(:name => 'something', :profile_id => fast_create(Person).id)
14	art.add_category cat	14	art.add_category cat
15	cat.reload	15	cat.reload
	@@ -18,4 +18,26 @@ class CategoryTest < ActiveSupport::TestCase		@@ -18,4 +18,26 @@ class CategoryTest < ActiveSupport::TestCase
18	Article.any_instance.expects(:to_solr_doc).returns(solr_doc)	18	Article.any_instance.expects(:to_solr_doc).returns(solr_doc)
19	cat.save!	19	cat.save!
20	end	20	end
		21	+
		22	+ should 'act as searchable' do
		23	+ TestSolr.enable
		24	+ parent = fast_create(Category, :name => 'books')
		25	+ c = Category.create!(:name => "science fiction", :acronym => "sf", :abbreviation => "sci-fi",
		26	+ :environment_id => environment.id, :parent_id => parent.id)
		27	+
		28	+ # fields
		29	+ assert_includes Category.find_by_contents('fiction')[:results].docs, c
		30	+ assert_includes Category.find_by_contents('sf')[:results].docs, c
		31	+ assert_includes Category.find_by_contents('sci-fi')[:results].docs, c
		32	+ # filters
		33	+ assert_includes Category.find_by_contents('science', {}, {
		34	+ :filter_queries => ["parent_id:#{parent.id}"]})[:results].docs, c
		35	+ end
		36	+
		37	+ should 'boost name matches' do
		38	+ TestSolr.enable
		39	+ c_abbr = Category.create!(:name => "something else", :abbreviation => "science", :environment_id => environment.id)
		40	+ c_name = Category.create!(:name => "science fiction", :environment_id => environment.id)
		41	+ assert_equal [c_name, c_abbr], Category.find_by_contents("science")[:results].docs
		42	+ end
21	end	43	end
	@@ -4,9 +4,11 @@ class ProductTest < ActiveSupport::TestCase		@@ -4,9 +4,11 @@ class ProductTest < ActiveSupport::TestCase
4	def setup	4	def setup
5	@environment = Environment.default	5	@environment = Environment.default
6	@environment.enable_plugin(SolrPlugin)	6	@environment.enable_plugin(SolrPlugin)
		7	+ @product_category = fast_create(ProductCategory, :name => 'Products')
		8	+ @profile = fast_create(Enterprise)
7	end	9	end
8		10
9	- attr_accessor :environment	11	+ attr_accessor :environment, :product_category, :profile
10		12
11	should 'reindex enterprise after saving' do	13	should 'reindex enterprise after saving' do
12	ent = fast_create(Enterprise)	14	ent = fast_create(Enterprise)
	@@ -15,5 +17,177 @@ class ProductTest < ActiveSupport::TestCase		@@ -15,5 +17,177 @@ class ProductTest < ActiveSupport::TestCase
15	Product.expects(:solr_batch_add).with([ent])	17	Product.expects(:solr_batch_add).with([ent])
16	prod.save!	18	prod.save!
17	end	19	end
		20	+
		21	+ should 'act as faceted' do
		22	+ s = fast_create(State, :acronym => 'XZ')
		23	+ c = fast_create(City, :name => 'Tabajara', :parent_id => s.id)
		24	+ ent = fast_create(Enterprise, :region_id => c.id)
		25	+ cat = fast_create(ProductCategory, :name => 'hardcore')
		26	+ p = Product.create!(:name => 'black flag', :enterprise_id => ent.id, :product_category_id => cat.id)
		27	+ pq = p.product_qualifiers.create!(:qualifier => fast_create(Qualifier, :name => 'qualifier'),
		28	+ :certifier => fast_create(Certifier, :name => 'certifier'))
		29	+ assert_equal 'Related products', Product.facet_by_id(:solr_plugin_f_category)[:label]
		30	+ assert_equal ['Tabajara', ', XZ'], Product.facet_by_id(:solr_plugin_f_region)[:proc].call(p.send(:solr_plugin_f_region))
		31	+ assert_equal ['qualifier', ' cert. certifier'], Product.facet_by_id(:solr_plugin_f_qualifier)[:proc].call(p.send(:solr_plugin_f_qualifier).last)
		32	+ assert_equal 'hardcore', p.send(:solr_plugin_f_category)
		33	+ assert_equal "solr_plugin_category_filter:#{cat.id}", Product.facet_category_query.call(cat)
		34	+ end
		35	+
		36	+ should 'act as searchable' do
		37	+ TestSolr.enable
		38	+ s = fast_create(State, :acronym => 'XZ')
		39	+ c = fast_create(City, :name => 'Tabajara', :parent_id => s.id)
		40	+ ent = fast_create(Enterprise, :region_id => c.id, :name => "Black Sun")
		41	+ category = fast_create(ProductCategory, :name => "homemade", :acronym => "hm", :abbreviation => "homey")
		42	+ p = Product.create!(:name => 'bananas syrup', :description => 'surrounded by mosquitos', :enterprise_id => ent.id,
		43	+ :product_category_id => category.id)
		44	+ qual = Qualifier.create!(:name => 'qualificador', :environment_id => Environment.default.id)
		45	+ cert = Certifier.create!(:name => 'certificador', :environment_id => Environment.default.id)
		46	+ pq = p.product_qualifiers.create!(:qualifier => qual, :certifier => cert)
		47	+ p.qualifiers.reload
		48	+ p.certifiers.reload
		49	+ p.save!
		50	+ # fields
		51	+ assert_includes Product.find_by_contents('bananas')[:results].docs, p
		52	+ assert_includes Product.find_by_contents('mosquitos')[:results].docs, p
		53	+ assert_includes Product.find_by_contents('homemade')[:results].docs, p
		54	+ # filters
		55	+ assert_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["solr_plugin_public:true"]})[:results].docs, p
		56	+ assert_not_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["solr_plugin_public:false"]})[:results].docs, p
		57	+ assert_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, p
		58	+ # includes
		59	+ assert_includes Product.find_by_contents("homemade")[:results].docs, p
		60	+ assert_includes Product.find_by_contents(category.slug)[:results].docs, p
		61	+ assert_includes Product.find_by_contents("hm")[:results].docs, p
		62	+ assert_includes Product.find_by_contents("homey")[:results].docs, p
		63	+ assert_includes Product.find_by_contents("Tabajara")[:results].docs, p
		64	+ assert_includes Product.find_by_contents("Black Sun")[:results].docs, p
		65	+ assert_includes Product.find_by_contents("qualificador")[:results].docs, p
		66	+ assert_includes Product.find_by_contents("certificador")[:results].docs, p
		67	+ end
		68	+
		69	+ should 'boost name matches' do
		70	+ TestSolr.enable
		71	+ ent = fast_create(Enterprise)
		72	+ cat = fast_create(ProductCategory)
		73	+ in_desc = Product.create!(:name => 'something', :enterprise_id => ent.id, :description => 'bananas in the description!',
		74	+ :product_category_id => cat.id)
		75	+ in_name = Product.create!(:name => 'bananas in the name!', :enterprise_id => ent.id, :product_category_id => cat.id)
		76	+ assert_equal [in_name, in_desc], Product.find_by_contents('bananas')[:results].docs
		77	+ end
		78	+
		79	+ should 'boost search results that include an image' do
		80	+ TestSolr.enable
		81	+ product_without_image = Product.create!(:name => 'product without image', :product_category => product_category,
		82	+ :enterprise_id => profile.id)
		83	+ product_with_image = Product.create!(:name => 'product with image', :product_category => product_category,
		84	+ :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')},
		85	+ :enterprise_id => profile.id)
		86	+ assert_equal [product_with_image, product_without_image], Product.find_by_contents('product image')[:results].docs
		87	+ end
		88	+
		89	+ should 'boost search results that include qualifier' do
		90	+ TestSolr.enable
		91	+ product_without_q = Product.create!(:name => 'product without qualifier', :product_category => product_category,
		92	+ :enterprise_id => profile.id)
		93	+ product_with_q = Product.create!(:name => 'product with qualifier', :product_category => product_category,
		94	+ :enterprise_id => profile.id)
		95	+ product_with_q.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil)
		96	+ product_with_q.save!
		97	+
		98	+ assert_equal [product_with_q, product_without_q], Product.find_by_contents('product qualifier')[:results].docs
		99	+ end
		100	+
		101	+ should 'boost search results with open price' do
		102	+ TestSolr.enable
		103	+ product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => profile.id, :price => 100)
		104	+ open_price = Product.new(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id, :price => 100)
		105	+ open_price.inputs << Input.new(:product => open_price, :product_category_id => product_category.id, :amount_used => 10, :price_per_unit => 10)
		106	+ open_price.save!
		107	+
		108	+ assert_equal [open_price, product], Product.find_by_contents('product')[:results].docs
		109	+ end
		110	+
		111	+ should 'boost search results with solidarity inputs' do
		112	+ TestSolr.enable
		113	+ product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => profile.id)
		114	+ perc_50 = Product.create!(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id)
		115	+ Input.create!(:product_id => perc_50.id, :product_category_id => product_category.id,
		116	+ :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
		117	+ Input.create!(:product_id => perc_50.id, :product_category_id => product_category.id,
		118	+ :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false)
		119	+ perc_50.save!
		120	+ perc_75 = Product.create!(:name => 'product 3', :product_category => product_category, :enterprise_id => profile.id)
		121	+ Input.create!(:product_id => perc_75.id, :product_category_id => product_category.id,
		122	+ :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false)
		123	+ Input.create!(:product_id => perc_75.id, :product_category_id => product_category.id,
		124	+ :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
		125	+ Input.create!(:product_id => perc_75.id, :product_category_id => product_category.id,
		126	+ :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
		127	+ Input.create!(:product_id => perc_75.id, :product_category_id => product_category.id,
		128	+ :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true)
		129	+ perc_75.save!
		130	+
		131	+ assert_equal [perc_75, perc_50, product], Product.find_by_contents('product')[:results].docs
		132	+ end
		133	+
		134	+ should 'boost available search results' do
		135	+ TestSolr.enable
		136	+ product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => profile.id)
		137	+ product.available = false
		138	+ product.save!
		139	+ product2 = Product.create!(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id)
		140	+ product2.available = true
		141	+ product2.save!
		142	+
		143	+ assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
		144	+ end
		145	+
		146	+ should 'boost search results created updated recently' do
		147	+ TestSolr.enable
		148	+ product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => profile.id)
		149	+ product.update_attribute :created_at, Time.now - 10.day
		150	+ product2 = Product.create!(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id)
		151	+
		152	+ assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
		153	+ end
		154	+
		155	+ should 'boost search results with description' do
		156	+ TestSolr.enable
		157	+ product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => profile.id,
		158	+ :description => '')
		159	+ product2 = Product.create!(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id,
		160	+ :description => 'a small description')
		161	+
		162	+ assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
		163	+ end
		164	+
		165	+ should 'boost if enterprise is enabled' do
		166	+ TestSolr.enable
		167	+ ent = Enterprise.create!(:name => 'ent', :identifier => 'ent', :enabled => false)
		168	+ product = Product.create!(:name => 'product 1', :product_category => product_category, :enterprise_id => ent.id)
		169	+ product2 = Product.create!(:name => 'product 2', :product_category => product_category, :enterprise_id => profile.id)
		170	+
		171	+ assert_equal [product2, product], Product.find_by_contents('product')[:results].docs
		172	+ end
		173	+
		174	+ should 'combine different boost types' do
		175	+ TestSolr.enable
		176	+ product = Product.create!(:name => 'product', :product_category => product_category, :enterprise_id => profile.id)
		177	+ image_only = Product.create!(:name => 'product with image', :product_category => product_category,
		178	+ :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')},
		179	+ :enterprise_id => profile.id)
		180	+ qual_only = Product.create!(:name => 'product with qualifier', :product_category => product_category,
		181	+ :enterprise_id => profile.id)
		182	+ img_and_qual = Product.create!(:name => 'product with image and qualifier', :product_category => product_category,
		183	+ :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')},
		184	+ :enterprise_id => profile.id)
		185	+ qual_only.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil)
		186	+ img_and_qual.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil)
		187	+ qual_only.save!
		188	+ img_and_qual.save!
		189	+
		190	+ assert_equal [img_and_qual, image_only, qual_only, product], Product.find_by_contents('product')[:results].docs
		191	+ end
18	end	192	end
19		193