[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	647	Forum
648	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	650	delegate :region, :region_id, :environment, :environment_id, :to => :profile, :allow_nil => true
681	651	def name_sortable # give a different name for solr
682	652	name
683	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	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	656	handle_asynchronously :solr_save
725	657
726	658	private
...	...
...	...	@@ -95,17 +95,6 @@ class Category < ActiveRecord::Base
95	95	name
96	96	end
97	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	98	handle_asynchronously :solr_save
110	99
111	100	end
...	...
...	...	@@ -212,87 +212,20 @@ class Product < ActiveRecord::Base
212	212	end
213	213
214	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	216	delegate :enabled, :region, :region_id, :environment, :environment_id, :to => :enterprise
	217	+
	218	+ alias_method :name_sortable, :name
244	219	def name_sortable # give a different name for solr
245	220	name
246	221	end
247		- def public
248		- self.public?
249		- end
	222	+
250	223	def price_sortable
251	224	(price.nil? or price.zero?) ? nil : price
252	225	end
253		- def category_filter
254		- enterprise.categories_including_virtual_ids << product_category_id
255		- end
	226	+
256	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	229	handle_asynchronously :solr_save
297	230
298	231	end
...	...
...	...	@@ -887,82 +887,12 @@ private :generate_url, :url_options
887	887	end
888	888
889	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	891	def name_sortable # give a different name for solr
929	892	name
930	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	897	handle_asynchronously :solr_save
968	898
...	...
1	1	# locally-developed modules
2		-require 'acts_as_faceted'
3	2	require 'acts_as_filesystem'
4	3	require 'acts_as_having_settings'
5		-require 'acts_as_searchable'
6	4	require 'acts_as_having_boxes'
7	5	require 'acts_as_having_image'
8	6	require 'acts_as_having_posts'
...	...
...	...	@@ -4,4 +4,74 @@ class Article
4	4	def solr_plugin_comments_updated
5	5	solr_save
6	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	77	end
...	...
...	...	@@ -2,4 +2,15 @@ require_dependency 'category'
2	2
3	3	class Category
4	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	16	end
...	...
...	...	@@ -2,4 +2,84 @@ require_dependency 'product'
2	2
3	3	class Product
4	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	85	end
...	...
...	...	@@ -2,4 +2,84 @@ require_dependency 'profile'
2	2
3	3	class Profile
4	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	85	end
...	...
...	...	@@ -9,7 +9,7 @@ class CategoryTest < ActiveSupport::TestCase
9	9	attr_accessor :environment
10	10
11	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	13	art = Article.create!(:name => 'something', :profile_id => fast_create(Person).id)
14	14	art.add_category cat
15	15	cat.reload
...	...	@@ -18,4 +18,26 @@ class CategoryTest < ActiveSupport::TestCase
18	18	Article.any_instance.expects(:to_solr_doc).returns(solr_doc)
19	19	cat.save!
20	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	43	end
...	...