Macartur Sousa · Macartur Sousa · Macartur Sousa · Macartur Sousa · Macartur Sousa · Macartur Sousa
Showing 36 changed files Show diff stats
plugins/elasticsearch/controllers/elasticsearch_plugin_controller.rb
plugins/elasticsearch/helpers/elasticsearch_helper.rb
plugins/elasticsearch/lib/elasticsearch_indexed_model.rb
plugins/elasticsearch/lib/elasticsearch_plugin/api.rb
plugins/elasticsearch/lib/ext/community.rb
plugins/elasticsearch/lib/ext/event.rb
plugins/elasticsearch/lib/ext/person.rb
plugins/elasticsearch/lib/ext/text_article.rb
plugins/elasticsearch/lib/ext/uploaded_file.rb
plugins/elasticsearch/lib/nested_helper/environment.rb
plugins/elasticsearch/lib/nested_helper/profile.rb
plugins/elasticsearch/lib/searchable_model/elasticsearch_indexed_model.rb
plugins/elasticsearch/lib/searchable_model/filter.rb
plugins/elasticsearch/lib/searchable_model_helper.rb
plugins/elasticsearch/public/style.css
plugins/elasticsearch/test/api/elasticsearch_plugin_api_test.rb
plugins/elasticsearch/test/api/elasticsearch_plugin_entities_test.rb
plugins/elasticsearch/test/functional/elasticsearch_plugin_controller_test.rb
plugins/elasticsearch/test/test_helper.rb
plugins/elasticsearch/test/unit/api/elasticsearch_plugin_api_test.rb
@@ -11,7 +11,7 @@ class ElasticsearchPluginController &lt; ApplicationController
   def search
     define_searchable_types
-    define_search_fields_types
+    define_sort_types
     define_results
   end
@@ -22,13 +22,13 @@ class ElasticsearchPluginController &lt; ApplicationController
   end
   def define_searchable_types
-    @searchable_types = ElasticsearchHelper::searchable_types
+    @searchable_types = searchable_types
     @selected_type = (params[:selected_type]|| :all ).to_sym
   end
-  def define_search_fields_types
-    @filter_types = ElasticsearchHelper::filters
-    @selected_filter = (params[:filter] || :relevance).to_sym
+  def define_sort_types
+    @sort_types = sort_types
+    @selected_sort = (params[:filter] || :relevance).to_sym
   end
 end
 module ElasticsearchHelper
-  def self.searchable_types
+  def searchable_types
     {
      :all              => { label: _("All Results")},
      :text_article     => { label: _("Articles")},
@@ -11,12 +11,20 @@ module ElasticsearchHelper
     }
   end
-  def self.filters
-    {
+  def sort_types
+    sorts = {
      :relevance      => { label: _("Relevance")},
      :lexical        => { label: _("Alphabetical")},
      :more_recent    => { label: _("More Recent")},
     }
+
+    selected_type = params[:selected_type] ||  nil
+
+    if selected_type and selected_type.to_sym != :all
+      klass = selected_type.to_s.classify.constantize
+      sorts.update klass.especific_sort if klass.respond_to? :especific_sort
+    end
+    sorts
   end
   def process_results
@@ -27,15 +35,20 @@ module ElasticsearchHelper
   private
   def search_from_all_models
-    query = get_query params[:query], sort_by: get_sort_by(params[:filter])
-    Elasticsearch::Model.search(query,searchable_models, size: default_per_page(params[:per_page])).page(params[:page]).records
+    begin
+      filter = (params[:filter] || "" ).to_sym
+      query = get_query params[:query], sort_by: get_sort_by(filter)
+      Elasticsearch::Model.search(query,searchable_models, size: default_per_page(params[:per_page])).page(params[:page]).records
+    rescue
+      []
+    end
   end
   def search_from_model model
     begin
       klass = model.to_s.classify.constantize
-
-      query = get_query params[:query], klass: klass, sort_by: get_sort_by(params[:filter])
+      filter = (params[:filter] || "" ).to_sym
+      query = get_query params[:query], klass: klass, sort_by: get_sort_by(filter,klass)
       klass.search(query, size: default_per_page(params[:per_page])).page(params[:page]).records
     rescue
       []
@@ -46,49 +59,58 @@ module ElasticsearchHelper
     per_page ||= 10
   end
-  def get_sort_by sort_by
+  def get_sort_by sort_by, klass=nil
     case sort_by
-      when "lexical"
+      when :lexical
         { "name.raw" => {"order" => "asc" }}
-      when "more_recent"
+      when :more_recent
         { "created_at" => {"order" => "desc"}}
+      else
+        ( klass and klass.respond_to?(:get_sort_by) ) ? klass.get_sort_by(sort_by) : nil
     end
   end
   def searchable_models
-    begin
-      ElasticsearchHelper::searchable_types.except(:all).keys.map { | model | model.to_s.classify.constantize }
-    rescue
-      []
-    end
+      searchable_types.except(:all).keys.map { | model | model.to_s.classify.constantize }
+  end
+
+  def query_string expression="", models=[]
+    return { match_all: {}  } if not expression
+    {
+      query_string: {
+        query: "*"+expression.downcase.split.join('* *')+"*",
+        fields: fields_from_models(models),
+        tie_breaker: 0.4,
+        minimum_should_match: "100%"
+      }
+    }
   end
-  def query_method expression="", fields=[]
-    query_exp = {}
-    if expression.blank?
-    else
-      query_exp = {
-        query: {
-          query_string: {
-            query: "*"+expression.downcase.split.join('* *')+"*",
-            fields: fields,
-            tie_breaker: 0.4,
-            minimum_should_match: "100%"
-          },
+
+  def query_method expression="", models=[]
+    {
+      query: {
+        filtered: {
+          query: query_string(expression,models),
+          filter: {
+            bool: {
+              should: models.map {|model| model.filter(environment: @environment.id) }
+            }
+          }
         }
       }
-    end
-    query_exp
+    }
   end
   def get_query text="", options={}
     klass = options[:klass]
     sort_by = options[:sort_by]
-    fields = klass.nil? ? (fields_from_models searchable_models) : (fields_from_models [klass])
+    models = (klass.nil?) ? searchable_models : [klass]
-    query = query_method(text, fields)
+    query = query_method(text, models)
     query[:sort] = sort_by if sort_by
+
     query
   end
@@ -1,53 +0,0 @@
-module ElasticsearchIndexedModel
-
-  def self.included base
-    base.send :include, Elasticsearch::Model
-    base.send :include, Elasticsearch::Model::Callbacks
-
-    base.send :index_name, "#{Rails.env}_#{base.index_name}"
-    base.extend ClassMethods
-    base.class_eval do
-      settings index: { number_of_shards: 1 } do
-        mappings dynamic: 'false' do
-          base.indexed_fields.each do |field, value|
-            value = {} if value.nil?
-            type =  value[:type].presence
-            if type.nil?
-              indexes(field, fields: base.raw_field(field))
-            else
-              indexes field, type: type
-            end
-            print '.'
-          end
-        end
-
-        base.__elasticsearch__.client.indices.delete \
-          index: base.index_name rescue nil
-        base.__elasticsearch__.client.indices.create \
-          index: base.index_name,
-          body: {
-            settings: base.settings.to_hash,
-            mappings: base.mappings.to_hash
-          }
-      end
-    end
-   base.send :import
-  end
-
-  module ClassMethods
-    def raw_field name
-      {
-        raw: {
-          type: "string",
-          index: "not_analyzed"
-        }
-      }
-    end
-
-    def indexed_fields
-      self::SEARCHABLE_FIELDS.merge self.control_fields
-    end
-
-  end
-
-end
@@ -10,14 +10,18 @@ class ElasticsearchPlugin::API &lt; Grape::API
       target = process_results
       present target,
               :with => Elasticsearch::Entities::Result,
-              :types => ElasticsearchHelper.searchable_types.except(:all).keys.map { |key| key.to_s.classify }
+              :types => searchable_types.except(:all).keys.map { |key| key.to_s.classify }
     end
     get 'types' do
-      types = {types: ElasticsearchHelper::searchable_types.stringify_keys.keys}
+      types = {types: searchable_types.stringify_keys.keys }
       present types, with: Grape::Presenters::Presenter
     end
+    get 'sort_types' do
+      present sort_types, with: Grape::Presenters::Presenter
+    end
+
   end
 end
 require_dependency 'community'
-require_relative '../elasticsearch_indexed_model'
+require_relative '../searchable_model_helper'
 class Community
+
   def self.control_fields
     {
-      :created_at => {type: 'date'}
+      :secret           => { type: :boolean },
+      :visible          => { type: :boolean },
+      :activities_count => { type: :integer },
+      :members_count    => { type: :integer }
+    }
+  end
+
+  def self.should
+    [
+      { and:
+        [
+          {term: { :secret => false }},
+          {term: { :visible => true }}
+        ]
+      }
+    ]
+  end
+
+  def self.especific_sort
+    {
+      :more_active  => { label: _("More Active") },
+      :more_popular => { label: _("More Popular") }
     }
   end
-  include ElasticsearchIndexedModel
+
+  def self.get_sort_by  sort_by=""
+    case sort_by
+      when :more_active
+        { :activities_count => {order: :desc}}
+      when :more_popular
+        { :members_count => {order: :desc}}
+    end
+  end
+
+  include SearchableModelHelper
 end
 require_dependency 'event'
-require_relative '../elasticsearch_indexed_model'
+
+require_relative '../searchable_model_helper'
+require_relative '../nested_helper/profile'
 class Event
+  #TODO: o filtro é feito de forma diferente do artigo
+
   def self.control_fields
     {
-      :advertise => {},
-      :published => {},
-      :created_at => {type: 'date'}
+      :advertise => {type: :boolean},
+      :published => {type: :boolean},
+      :profile   => { type: :nested , hash: NestedProfile.hash }
     }
   end
-  include ElasticsearchIndexedModel
+
+  def self.should
+    [
+      { and: [
+          { term: { advertise: true }},
+          { term: { published: true }}
+        ]
+      }
+    ]
+  end
+
+  def self.nested_filter
+    [
+      NestedProfile::filter
+    ]
+  end
+
+  include SearchableModelHelper
 end
 require_dependency 'person'
-require_relative '../elasticsearch_indexed_model'
+
+require_relative '../searchable_model_helper'
 class Person
+
   def self.control_fields
     {
-      :visible => {type: 'boolean'},
-      :public_profile => {type: 'boolean'},
-      :created_at => {type: 'date'}
+      :visible        => {type: 'boolean'},
+      :secret         => { type: :boolean },
+      :activities_count => { type: :integer },
+      :friends_count    => { type: :integer }
     }
   end
-  include ElasticsearchIndexedModel
+
+  def self.should
+    [
+      { and:
+        [
+          {term: { :secret => false }},
+          {term: { :visible => true }}
+        ]
+      }
+    ]
+  end
+
+  def self.especific_sort
+    {
+      :more_active  => { label: _("More Active") },
+      :more_popular => { label: _("More Popular") }
+    }
+  end
+
+  def self.get_sort_by  sort_by=""
+    case sort_by
+      when :more_active
+        { :activities_count => {order: :desc}}
+      when :more_popular
+        { :friends_count => {order: :desc} }
+    end
+  end
+
+  include SearchableModelHelper
 end
 # REQUIRE TO LOAD DESCENDANTS FROM TEXT_ARTICLE
 require_dependency 'raw_html_article'
 require_dependency 'tiny_mce_article'
-
 require_dependency 'text_article'
-require_relative '../elasticsearch_indexed_model'
+
+require_relative '../searchable_model_helper'
+require_relative '../nested_helper/profile'
 class TextArticle
+
   def self.control_fields
     {
-      :advertise => {},
-      :published => {},
-      :created_at => {type: 'date'}
+      :advertise      => { type: :boolean },
+      :published      => { type: 'boolean'},
+      :comments_count => { type: :integer },
+      :hits           => { type: :integer },
+      :profile        => { type: :nested , hash: NestedProfile.hash }
+    }
+  end
+
+  def self.should
+    [
+      { and: [
+          { term: { advertise: true }},
+          { term: { published: true }}
+        ]
+      }
+    ]
+  end
+
+  def self.nested_filter
+    [
+      NestedProfile::filter
+    ]
+  end
+
+  def self.especific_sort
+    {
+      :more_popular   => { label: _("More Viewed") },
+      :more_comments  => { label: _("Most Commented") }
     }
   end
-  include ElasticsearchIndexedModel
+
+  def self.get_sort_by  sort_by=""
+    case sort_by
+      when :more_popular
+        { :hits => {order: :desc} }
+      when :more_comments
+        { :comments_count => {order: :desc}}
+    end
+  end
+
+  include SearchableModelHelper
 end
 require_dependency 'uploaded_file'
-require_relative '../elasticsearch_indexed_model'
+
+require_relative '../searchable_model_helper'
+require_relative '../nested_helper/profile'
 class UploadedFile
   def self.control_fields
     {
-      :advertise => {},
-      :published => {},
-      :created_at => {type: 'date'}
+      :advertise  => {type: :boolean},
+      :published  => {type: :boolean},
+      :profile   => { type: :nested , hash: NestedProfile.hash }
     }
   end
-  include ElasticsearchIndexedModel
+
+  def self.should
+    [
+      { and: [
+          { term: { advertise: true }},
+          { term: { published: true }}
+        ]
+      }
+    ]
+  end
+
+  def self.nested_filter
+    [
+      NestedProfile::filter
+    ]
+  end
+
+  include SearchableModelHelper
 end
@@ -0,0 +1,25 @@
+module NestedEnvironment
+
+  def self.hash
+    {
+      :id         => { type: :integer },
+      :is_default => {type: :boolean }
+    }
+  end
+
+  def self.filter environment=1
+    {
+      query: {
+        nested: {
+          path: "environment",
+          query: {
+            bool: {
+              must: { term: { "environment.id" => environment } },
+            }
+          }
+        }
+      }
+    }
+  end
+
+end
@@ -0,0 +1,29 @@
+module NestedProfile
+
+  def self.hash
+    {
+      :id             => { type: :integer },
+      :visible        => { type: :boolean },
+      :public_profile => { type: :boolean }
+    }
+  end
+
+  def self.filter
+    {
+      query: {
+        nested: {
+          path: "profile",
+          query: {
+            bool: {
+              must:[
+                { term: { "profile.visible" => true } },
+                { term: { "profile.public_profile" => true } }
+              ],
+            }
+          }
+        }
+      }
+    }
+  end
+
+end
@@ -0,0 +1,99 @@
+require_relative '../nested_helper/environment'
+
+module ElasticsearchIndexedModel
+
+  def self.included base
+    base.send :include, Elasticsearch::Model
+    base.send :include, Elasticsearch::Model::Callbacks
+
+    base.send :index_name, "#{Rails.env}_#{base.index_name}"
+
+    base.extend ClassMethods
+    base.send :include, InstanceMethods
+
+    base.class_eval do
+      settings index: { number_of_shards: 1 } do
+        mappings dynamic: 'false' do
+          base.indexed_fields.each do |field, value|
+            type = value[:type].presence
+
+            if type == :nested
+              indexes(field, type: type) do
+                value[:hash].each do |hash_field, hash_value|
+                  indexes(hash_field, base.indexes_as_hash(hash_field,hash_value[:type].presence))
+                end
+              end
+            else
+               indexes(field, base.indexes_as_hash(field,type))
+            end
+            print '.'
+          end
+        end
+
+        base.__elasticsearch__.client.indices.delete \
+          index: base.index_name rescue nil
+        base.__elasticsearch__.client.indices.create \
+          index: base.index_name,
+          body: {
+            settings: base.settings.to_hash,
+            mappings: base.mappings.to_hash
+          }
+      end
+    end
+   base.send :import
+  end
+
+  module ClassMethods
+
+    def indexes_as_hash(name, type)
+      hash = {}
+      if type.nil?
+        hash[:fields] = raw_field(name, type)
+      else
+        hash[:type] = type if not type.nil?
+      end
+      hash
+    end
+
+    def raw_field name, type
+      {
+        raw: {
+          type: "string",
+          index: "not_analyzed"
+        }
+      }
+    end
+
+    def indexed_fields
+      fields = {
+                :environment  => {type: :nested, hash: NestedEnvironment::hash },
+                :category_ids => {type: :integer },
+                :created_at   => {type: :date }
+      }
+      fields.update(self::SEARCHABLE_FIELDS)
+      fields.update(self.control_fields)
+      fields
+    end
+
+  end
+
+  module InstanceMethods
+    def as_indexed_json options={}
+        attrs = {}
+
+        self.class.indexed_fields.each do |field, value|
+          type = value[:type].presence
+          if type == :nested
+            attrs[field] = {}
+            value[:hash].each do |hash_field, hash_value|
+              attrs[field][hash_field] = self.send(field).send(hash_field)
+            end
+          else
+            attrs[field] = self.send(field)
+          end
+        end
+        attrs.as_json
+    end
+  end
+
+end
@@ -0,0 +1,41 @@
+require_relative '../nested_helper/environment'
+
+module Filter
+
+  def self.included base
+    base.extend ClassMethods
+    base.send :include, InstanceMethods
+  end
+
+  module ClassMethods
+
+    def filter options={}
+      environment = options[:environment].presence
+
+      result_filter = {}
+      result_filter[:indices] = {:index => self.index_name, :no_match_filter => "none" }
+      result_filter[:indices][:filter] = { :bool => self.filter_bool(environment)  }
+
+      result_filter
+    end
+
+    def filter_bool environment
+      result_filter = {}
+
+      result_filter[:must] = [ NestedEnvironment::filter(environment) ]
+
+      self.nested_filter.each {|filter| result_filter[:must].append(filter)}  if self.respond_to? :nested_filter
+      self.must.each          {|filter| result_filter[:must].append(filter) } if self.respond_to? :must
+
+      result_filter[:should]    = self.should    if self.respond_to? :should
+      result_filter[:must_not]  = self.must_not  if self.respond_to? :must_not
+
+      result_filter
+    end
+  end
+
+  module InstanceMethods
+
+  end
+
+end
@@ -0,0 +1,9 @@
+require_relative './searchable_model/elasticsearch_indexed_model'
+require_relative './searchable_model/filter'
+
+module SearchableModelHelper
+  def self.included base
+    base.send :include, ElasticsearchIndexedModel
+    base.send :include, Filter
+  end
+end
@@ -3,7 +3,7 @@
 }
 .controller-elasticsearch_plugin .sidebar {
-  width: 270px;
+  min-width: 240px;
 }
 .controller-elasticsearch_plugin .search_form {
@@ -38,7 +38,7 @@
 }
 .controller-elasticsearch_plugin .results {
-  flex: 2;
+  flex: 1;
   margin-top: 20px;
   border-radius: 5px;
   border: 1px solid #eee;
@@ -124,15 +124,13 @@
   margin: 15px;
 }
-.controller-elasticsearch_plugin .search-item .person-item {
-  display: flex;
-}
-
 .controller-elasticsearch_plugin .right-side {
-  flex: 2;
+  float: left;
+  width: calc(100% - 80px);
 }
 .controller-elasticsearch_plugin .left-side {
+  float: left;
   width: 80px;
 }
@@ -0,0 +1,113 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+require_relative '../../helpers/elasticsearch_helper'
+
+class ElasticsearchPluginApiTest < ActiveSupport::TestCase
+
+  include ElasticsearchTestHelper
+  include ElasticsearchHelper
+
+  def indexed_models
+    [Person,TextArticle,UploadedFile,Community,Event]
+  end
+
+  def create_instances
+    create_instances_environment
+    create_instances_environment2
+  end
+
+  def create_instances_environment2
+    create_user "Sample User Environment 2", environment:Environment.second
+    fast_create Community, name:"Sample Community Environment 2", created_at: Date.new, environment_id: Environment.second.id
+  end
+
+  def create_instances_environment
+    create_visible_models
+    create_private_models
+  end
+
+  def create_visible_models
+    7.times{ | index |  create_user "person #{index}" }
+    4.times{ | index |  fast_create Community, name: "community #{index}", created_at: Date.new }
+  end
+
+  def create_private_models
+    secret_user = create_user("Secret Person")
+    fast_update(secret_user.person, secret: true, visible: true)
+
+    invisible_user= create_user("Invisible Person")
+    fast_update(invisible_user.person, secret: false, visible: false, public_profile: false)
+
+    fast_create(Community, name: "secret community", secret: true, visible: true)
+    fast_create(Community, name: "invisible community", secret: false, visible: false)
+
+    create_private_article(TextArticle,public_person: User.first.person, private_person: invisible_user.person)
+    create_private_article(UploadedFile,public_person: User.first.person, private_person: invisible_user.person)
+    create_private_article(Event,public_person: User.first.person, private_person: invisible_user.person)
+
+  end
+
+  def create_private_article model,options = {}
+    public_person = options[:public_person]
+    private_person = options[:private_person]
+
+    fast_create(model, name: "#{model.to_s.underscore} not advertise", advertise: false, published: true, profile_id: public_person, created_at: Time.now)
+    fast_create(model, name: "#{model.to_s.underscore} not published", advertise: true, published: false, profile_id: public_person, created_at: Time.now)
+    fast_create(model, name: "#{model.to_s.underscore} with not visible profile", advertise: true, published: true, profile_id: private_person, created_at: Time.now)
+    fast_create(model, name: "#{model.to_s.underscore} with not public_profile", advertise: true, published: true, profile_id: private_person, created_at: Time.now)
+  end
+
+  def create_instances
+    7.times.each {|index| create_user "person #{index}"}
+    4.times.each {|index| fast_create Community, name: "community #{index}" }
+  end
+
+  should 'show all types avaliable in /search/types endpoint' do
+    get "/api/v1/search/types"
+    json = JSON.parse(last_response.body)
+    assert_equal 200, last_response.status
+    assert_equal searchable_types.stringify_keys.keys, json["types"]
+  end
+
+  should 'respond with endpoint /search with more than 10 results' do
+    get "/api/v1/search"
+    json = JSON.parse(last_response.body)
+    assert_equal 200, last_response.status
+    assert_equal 10, json["results"].count
+  end
+
+  should 'respond with query in downcase' do
+    get "/api/v1/search?query=person"
+    json = JSON.parse(last_response.body)
+    assert_equal 200, last_response.status
+    assert_equal 7, json["results"].count
+  end
+
+  should 'respond with query in uppercase' do
+    get "/api/v1/search?query=PERSON"
+    json = JSON.parse(last_response.body)
+    assert_equal 200, last_response.status
+    assert_equal 7, json["results"].count
+  end
+
+  should 'respond with selected_type' do
+    get "/api/v1/search?selected_type=community"
+    json = JSON.parse(last_response.body)
+    assert_equal 200, last_response.status
+    assert_equal 4, json["results"].count
+  end
+
+  should 'filter person by default environment' do
+    get "/api/v1/search?selected_type=person"
+    json = JSON.parse(last_response.body)
+    assert_equal 200, last_response.status
+    assert_equal 7, json["results"].count
+  end
+
+  should 'not show private text_article' do
+    get "/api/v1/search?selected_type=text_article"
+    json = JSON.parse(last_response.body)
+    assert_equal 200, last_response.status
+    assert_equal 7, json["results"].count
+  end
+
+end
@@ -0,0 +1,124 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class ElasticsearchPluginEntitiesTest < ActiveSupport::TestCase
+
+  include ElasticsearchTestHelper
+
+  def indexed_models
+    [Person,TextArticle,UploadedFile,Community,Event]
+  end
+
+  def create_instances
+    user = create_user "sample person", environment_id: 1
+
+    fast_create Community, name: "sample community", created_at: 10.days.ago,updated_at: 5.days.ago, environment_id: 1
+
+    fast_create UploadedFile, name: "sample uploadedfile", created_at: 3.days.ago, updated_at: 1.days.ago, author_id: user.person.id, abstract: "sample abstract", profile_id: user.person.id
+    fast_create Event, name: "sample event", created_at: 20.days.ago, updated_at: 5.days.ago, author_id: user.person.id, abstract: "sample abstract", profile_id: user.person.id
+    fast_create RawHTMLArticle, name: "sample raw html article", created_at: 15.days.ago ,updated_at: 5.days.ago, author_id: user.person.id, profile_id: user.person.id
+    fast_create TinyMceArticle, name: "sample tiny mce article", created_at: 5.days.ago, updated_at: 5.days.ago, author_id: user.person.id, profile_id: user.person.id
+  end
+
+  should 'show attributes from person' do
+    params = {:selected_type => "person" }
+    get "/api/v1/search?#{params.to_query}"
+    json= JSON.parse(last_response.body)
+
+    expected_person = Person.find_by name: "sample person"
+
+    assert_equal 200, last_response.status
+    assert_equal expected_person.id, json['results'][0]['id']
+    assert_equal expected_person.name, json['results'][0]['name']
+    assert_equal expected_person.type, json['results'][0]['type']
+    assert_equal "", json['results'][0]['description']
+    assert_equal expected_person.created_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][0]['created_at']
+    assert_equal expected_person.updated_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][0]['updated_at']
+  end
+
+
+  should 'show attributes from community' do
+    params = {:selected_type => "community" }
+    get "/api/v1/search?#{params.to_query}"
+    json= JSON.parse(last_response.body)
+
+    expected_community = Community.find_by name: "sample community"
+
+    assert_equal 200, last_response.status
+
+    assert_equal expected_community.id, json['results'][0]['id']
+    assert_equal expected_community.name, json['results'][0]['name']
+    assert_equal expected_community.type, json['results'][0]['type']
+    assert_equal "", json['results'][0]['description']
+    assert_equal expected_community.created_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][0]['created_at']
+    assert_equal expected_community.updated_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][0]['updated_at']
+  end
+
+  should 'show attributes from text_article' do
+    params = {:selected_type => "text_article" }
+    get "/api/v1/search?#{params.to_query}"
+
+    json= JSON.parse(last_response.body)
+
+    assert_equal 200, last_response.status
+
+    expected_text_articles = TextArticle.all
+
+    expected_text_articles.each_with_index {|object,index|
+      assert_equal object.id, json['results'][index]['id']
+      assert_equal object.name, json['results'][index]['name']
+      assert_equal "TextArticle", json['results'][index]['type']
+
+      expected_author = (object.author.nil?) ? "" : object.author.name
+
+      assert_equal expected_author, json['results'][index]['author']
+      assert_equal object.created_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['created_at']
+      assert_equal object.updated_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['updated_at']
+    }
+  end
+
+  should 'show attributes from uploaded_file'  do
+    params = {:selected_type => "uploaded_file"}
+    get "/api/v1/search?#{params.to_query}"
+
+    json= JSON.parse(last_response.body)
+
+    assert_equal 200, last_response.status
+
+    expected_uploaded_files = UploadedFile.all
+    expected_uploaded_files.each_with_index {|object,index|
+      assert_equal object.id, json['results'][index]['id']
+      assert_equal object.name, json['results'][index]['name']
+      assert_equal object.abstract, json['results'][index]['abstract']
+      assert_equal "UploadedFile", json['results'][index]['type']
+
+      expected_author = (object.author.nil?) ? "" : object.author.name
+      assert_equal expected_author, json['results'][index]['author']
+
+      assert_equal object.created_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['created_at']
+      assert_equal object.updated_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['updated_at']
+    }
+  end
+
+  should 'show attributes from event'  do
+    params = {:selected_type => "event"}
+    get "/api/v1/search?#{params.to_query}"
+
+    json= JSON.parse(last_response.body)
+
+    assert_equal 200, last_response.status
+    expected_events = Event.all
+    expected_events.each_with_index {|object,index|
+      assert_equal object.id, json['results'][index]['id']
+      assert_equal object.name, json['results'][index]['name']
+      assert_equal object.abstract, json['results'][index]['abstract']
+      assert_equal "Event", json['results'][index]['type']
+
+      expected_author = (object.author.nil?) ? "" : object.author.name
+      assert_equal expected_author, json['results'][index]['author']
+
+      assert_equal object.created_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['created_at']
+      assert_equal object.updated_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['updated_at']
+    }
+  end
+
+end
@@ -0,0 +1,176 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class ElasticsearchPluginControllerTest < ActionController::TestCase
+
+  include ElasticsearchTestHelper
+
+  def indexed_models
+    [Person,TextArticle,UploadedFile,Community,Event]
+  end
+
+  def create_instances
+    create_instances_environment
+    create_instances_environment2
+  end
+
+  def create_instances_environment2
+    create_user "Sample User Environment 2", environment:Environment.second
+    fast_create Community, name:"Sample Community Environment 2", created_at: Date.new, environment_id: Environment.second.id
+  end
+
+  def create_instances_environment
+    create_visible_models
+    create_private_models
+  end
+
+  def create_visible_models
+    5.times do | index |
+      create_user "person #{index}"
+    end
+    6.times do | index |
+      fast_create Community, name: "community #{index}", created_at: Date.new
+    end
+  end
+
+  def create_private_models
+    secret_user = create_user("Secret Person")
+    fast_update(secret_user.person, secret: true, visible: true)
+
+    invisible_user= create_user("Invisible Person")
+    fast_update(invisible_user.person, secret: false, visible: false, public_profile: false)
+
+    fast_create(Community, name: "secret community", secret: true, visible: true)
+    fast_create(Community, name: "invisible community", secret: false, visible: false)
+
+    create_private_article(TextArticle,public_person: User.first.person, private_person: invisible_user.person)
+    create_private_article(UploadedFile,public_person: User.first.person, private_person: invisible_user.person)
+    create_private_article(Event,public_person: User.first.person, private_person: invisible_user.person)
+
+  end
+
+  def create_private_article model,options = {}
+    public_person = options[:public_person]
+    private_person = options[:private_person]
+
+    fast_create(model, name: "#{model.to_s.underscore} not advertise", advertise: false, published: true, profile_id: public_person, created_at: Time.now)
+    fast_create(model, name: "#{model.to_s.underscore} not published", advertise: true, published: false, profile_id: public_person, created_at: Time.now)
+    fast_create(model, name: "#{model.to_s.underscore} with not visible profile", advertise: true, published: true, profile_id: private_person, created_at: Time.now)
+    fast_create(model, name: "#{model.to_s.underscore} with not public_profile", advertise: true, published: true, profile_id: private_person, created_at: Time.now)
+  end
+
+
+  should 'work and uses control filter variables' do
+    get :index
+    assert_response :success
+    assert_not_nil assigns(:searchable_types)
+    assert_not_nil assigns(:selected_type)
+    assert_not_nil assigns(:sort_types)
+    assert_not_nil assigns(:selected_sort)
+  end
+
+  should 'return 10 results if selected_type is nil and query is nil' do
+    get :index
+    assert_response :success
+    assert_select ".search-item" , 10
+  end
+
+  should 'render pagination if results has more than 10' do
+    get :index
+    assert_response :success
+    assert_select ".pagination", 1
+  end
+
+  should 'return results filtered by selected_type' do
+    get :index, { 'selected_type' => :community}
+    assert_response :success
+    assert_select ".search-item", 6
+    assert_template partial: '_community_display'
+  end
+
+  should 'return results filtered by query' do
+    get :index, { 'query' => "person"}
+    assert_response :success
+    assert_select ".search-item", 5
+    assert_template partial: '_person_display'
+  end
+
+  should 'return results filtered by query with uppercase' do
+    get :index, {'query' => "PERSON 1"}
+    assert_response :success
+    assert_template partial: '_person_display'
+    assert_tag(tag: "div", attributes: { class: "person-item" } , descendant: { tag: "a", child: "person 1"} )
+  end
+
+  should 'return results filtered by query with downcase' do
+    get :index, {'query' => "person 1"}
+    assert_response :success
+    assert_tag(tag: "div", attributes: { class: "person-item" } , descendant: { tag: "a", child: "person 1"} )
+  end
+
+  should 'return new community indexed' do
+    get :index, { "selected_type" => :community}
+    assert_response :success
+    assert_select ".search-item", 6
+
+    fast_create Community, name: "community #{7}", created_at: Date.new
+    Community.import
+    sleep 2
+
+    get :index, { "selected_type" => :community}
+    assert_response :success
+    assert_select ".search-item", 7
+  end
+
+  should 'not return community deleted' do
+    get :index, { "selected_type" => :community}
+    assert_response :success
+    assert_select ".search-item", 6
+
+    Community.first.delete
+    Community.import
+    sleep 2
+
+    get :index, { "selected_type" => :community}
+    assert_response :success
+    assert_select ".search-item", 5
+  end
+
+  should 'redirect to elasticsearch plugin when request are send to core' do
+    @controller = SearchController.new
+    get 'index'
+    params = {:action => 'index', :controller => 'search'}
+    assert_redirected_to controller: 'elasticsearch_plugin', action: 'search', params: params
+  end
+
+
+  should 'filter community by default environment' do
+    get :index, { "selected_type" => :community}
+    assert_response :success
+    assert_select ".search-item", 6
+  end
+
+  should 'filter person by default environment' do
+    get :index, { "selected_type" => :person}
+    assert_response :success
+    assert_select ".search-item", 5
+  end
+
+  should 'not show private text_article' do
+    get :index, { :selected_type => "text_article" }
+    assert_response :success
+    assert_select ".search-item", 6
+  end
+
+  should 'not show private uploaded_file' do
+    get :index, { :selected_type => "uploaded_file" }
+    assert_response :success
+    assert_select ".search-item", 0
+  end
+
+  should 'not show private event' do
+    get :index, { :selected_type => "event" }
+    assert_response :success
+    assert_select ".search-item", 0
+  end
+
+end
@@ -20,7 +20,7 @@ module ElasticsearchTestHelper
       model.__elasticsearch__.create_index! force: true
       model.import
     }
-    sleep 2
+    sleep 3
   end
   def setup_environment
@@ -1,50 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../test_helper"
-
-class ElasticsearchPluginApiTest < ActiveSupport::TestCase
-
-  include ElasticsearchTestHelper
-
-  def indexed_models
-    [Community, Person]
-  end
-
-  def create_instances
-    7.times.each {|index| create_user "person #{index}"}
-    4.times.each {|index| fast_create Community, name: "community #{index}" }
-  end
-
-  should 'show all types avaliable in /search/types endpoint' do
-    get "/api/v1/search/types"
-    json = JSON.parse(last_response.body)
-    assert_equal 200, last_response.status
-    assert_equal ElasticsearchHelper::searchable_types.stringify_keys.keys, json["types"]
-  end
-
-  should 'respond with endpoint /search with more than 10 results' do
-    get "/api/v1/search"
-    json = JSON.parse(last_response.body)
-    assert_equal 200, last_response.status
-    assert_equal 10, json["results"].count
-  end
-
-  should 'respond with query in downcase' do
-    get "/api/v1/search?query=person"
-    json = JSON.parse(last_response.body)
-    assert_equal 200, last_response.status
-    assert_equal 7, json["results"].count
-  end
-
-  should 'respond with query in uppercase' do
-    get "/api/v1/search?query=PERSON"
-    json = JSON.parse(last_response.body)
-    assert_equal 200, last_response.status
-    assert_equal 7, json["results"].count
-  end
-
-  should 'respond with selected_type' do
-    get "/api/v1/search?selected_type=community"
-    json = JSON.parse(last_response.body)
-    assert_equal 200, last_response.status
-    assert_equal 4, json["results"].count
-  end
-end
@@ -1,122 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../test_helper"
-
-class ElasticsearchPluginEntitiesTest < ActiveSupport::TestCase
-
-  include ElasticsearchTestHelper
-
-  def indexed_models
-    [Person,TextArticle,UploadedFile,Community,Event]
-  end
-
-  def create_instances
-    user = create_user "sample person"
-
-    fast_create Community, name: "sample community", created_at: 10.days.ago,updated_at: 5.days.ago
-    fast_create UploadedFile, name: "sample uploadedfile", created_at: 3.days.ago, updated_at: 1.days.ago, author_id: user.person.id, abstract: "sample abstract"
-    fast_create Event, name: "sample event", created_at: 20.days.ago, updated_at: 5.days.ago, author_id: user.person.id, abstract: "sample abstract"
-
-    fast_create RawHTMLArticle, name: "sample raw html article", created_at: 15.days.ago ,updated_at: 5.days.ago, author_id: user.person.id
-    fast_create TinyMceArticle, name: "sample tiny mce article", created_at: 5.days.ago, updated_at: 5.days.ago, author_id: user.person.id
-  end
-
-  should 'show attributes from person' do
-    params = {:selected_type => "person" }
-    get "/api/v1/search?#{params.to_query}"
-    json= JSON.parse(last_response.body)
-
-    expected_person = Person.find_by name: "sample person"
-
-    assert_equal 200, last_response.status
-    assert_equal expected_person.id, json['results'][0]['id']
-    assert_equal expected_person.name, json['results'][0]['name']
-    assert_equal expected_person.type, json['results'][0]['type']
-    assert_equal "", json['results'][0]['description']
-    assert_equal expected_person.created_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][0]['created_at']
-    assert_equal expected_person.updated_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][0]['updated_at']
-  end
-
-  should 'show attributes from community' do
-    params = {:selected_type => "community" }
-    get "/api/v1/search?#{params.to_query}"
-    json= JSON.parse(last_response.body)
-
-    expected_community = Community.find_by name: "sample community"
-
-    assert_equal 200, last_response.status
-    assert_equal expected_community.id, json['results'][0]['id']
-    assert_equal expected_community.name, json['results'][0]['name']
-    assert_equal expected_community.type, json['results'][0]['type']
-    assert_equal "", json['results'][0]['description']
-    assert_equal expected_community.created_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][0]['created_at']
-    assert_equal expected_community.updated_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][0]['updated_at']
-  end
-
-  should 'show attributes from text_article' do
-    params = {:selected_type => "text_article" }
-    get "/api/v1/search?#{params.to_query}"
-
-    json= JSON.parse(last_response.body)
-
-    assert_equal 200, last_response.status
-
-    expected_text_articles = TextArticle.all
-
-    expected_text_articles.each_with_index {|object,index|
-      assert_equal object.id, json['results'][index]['id']
-      assert_equal object.name, json['results'][index]['name']
-      assert_equal "TextArticle", json['results'][index]['type']
-
-      expected_author = (object.author.nil?) ? "" : object.author.name
-
-      assert_equal expected_author, json['results'][index]['author']
-      assert_equal object.created_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['created_at']
-      assert_equal object.updated_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['updated_at']
-    }
-  end
-
-  should 'show attributes from uploaded_file'  do
-    params = {:selected_type => "uploaded_file"}
-    get "/api/v1/search?#{params.to_query}"
-
-    json= JSON.parse(last_response.body)
-
-    assert_equal 200, last_response.status
-
-    expected_uploaded_files = UploadedFile.all
-    expected_uploaded_files.each_with_index {|object,index|
-      assert_equal object.id, json['results'][index]['id']
-      assert_equal object.name, json['results'][index]['name']
-      assert_equal object.abstract, json['results'][index]['abstract']
-      assert_equal "UploadedFile", json['results'][index]['type']
-
-      expected_author = (object.author.nil?) ? "" : object.author.name
-      assert_equal expected_author, json['results'][index]['author']
-
-      assert_equal object.created_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['created_at']
-      assert_equal object.updated_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['updated_at']
-    }
-  end
-
-  should 'show attributes from event'  do
-    params = {:selected_type => "event"}
-    get "/api/v1/search?#{params.to_query}"
-
-    json= JSON.parse(last_response.body)
-
-    assert_equal 200, last_response.status
-    expected_events = Event.all
-    expected_events.each_with_index {|object,index|
-      assert_equal object.id, json['results'][index]['id']
-      assert_equal object.name, json['results'][index]['name']
-      assert_equal object.abstract, json['results'][index]['abstract']
-      assert_equal "Event", json['results'][index]['type']
-
-      expected_author = (object.author.nil?) ? "" : object.author.name
-      assert_equal expected_author, json['results'][index]['author']
-
-      assert_equal object.created_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['created_at']
-      assert_equal object.updated_at.strftime("%Y/%m/%d %H:%M:%S"), json['results'][index]['updated_at']
-    }
-  end
-
-end
@@ -0,0 +1,46 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class CommunityTest < ActiveSupport::TestCase
+
+  include ElasticsearchTestHelper
+
+  def indexed_models
+    [Community]
+  end
+
+  should 'index searchable fields for Community model' do
+    Community::SEARCHABLE_FIELDS.each do |key, value|
+      assert_includes indexed_fields(Community), key
+    end
+  end
+
+  should 'index control fields for Community model' do
+    Community::control_fields.each do |key, value|
+      assert_includes indexed_fields(Community), key
+      assert_equal indexed_fields(Community)[key][:type], value[:type] || 'string'
+    end
+  end
+
+  should 'respond with should method to return public community' do
+    assert Community.respond_to? :should
+  end
+
+  should 'respond with especific sort' do
+    assert Community.respond_to? :especific_sort
+  end
+
+  should 'respond with get_sort_by to order especific sort' do
+    assert Community.respond_to? :get_sort_by
+  end
+
+  should 'return hash to sort by more_active' do
+    more_active_hash = {:activities_count => {order: :desc}}
+    assert_equal more_active_hash, Community.get_sort_by(:more_active)
+  end
+
+  should 'return hash to sort by more_popular' do
+    more_popular_hash = {:members_count => {order: :desc}}
+    assert_equal more_popular_hash, Community.get_sort_by(:more_popular)
+  end
+
+end
@@ -1,115 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../test_helper"
-
-class ElasticsearchPluginControllerTest < ActionController::TestCase
-
-  include ElasticsearchTestHelper
-
-  def indexed_models
-    [Community, Person]
-  end
-
-  def create_instances
-    create_people
-    create_communities
-  end
-
-  def create_people
-    5.times do | index |
-      create_user "person #{index}"
-    end
-  end
-
-  def create_communities
-    6.times do | index |
-      fast_create Community, name: "community #{index}", created_at: Date.new
-    end
-  end
-
-  should 'work and uses control filter variables' do
-    get :index
-    assert_response :success
-    assert_not_nil assigns(:searchable_types)
-    assert_not_nil assigns(:selected_type)
-    assert_not_nil assigns(:filter_types)
-    assert_not_nil assigns(:selected_filter)
-  end
-
-  should 'return 10 results if selected_type is nil and query is nil' do
-    get :index
-    assert_response :success
-    assert_select ".search-item" , 10
-  end
-
-  should 'render pagination if results has more than 10' do
-    get :index
-    assert_response :success
-    assert_select ".pagination", 1
-  end
-
-  should 'return results filtered by selected_type' do
-    get :index, { 'selected_type' => :community}
-    assert_response :success
-    assert_select ".search-item", 6
-    assert_template partial: '_community_display'
-  end
-
-  should 'return results filtered by query' do
-    get :index, { 'query' => "person"}
-    assert_response :success
-    assert_select ".search-item", 5
-    assert_template partial: '_person_display'
-  end
-
- should 'return results filtered by query with uppercase' do
-   get :index, {'query' => "PERSON 1"}
-   assert_response :success
-   assert_template partial: '_person_display'
-   assert_tag(tag: "div", attributes: { class: "person-item" } , descendant: { tag: "a", child: "person 1"} )
- end
-
- should 'return results filtered by query with downcase' do
-   get :index, {'query' => "person 1"}
-   assert_response :success
-   assert_tag(tag: "div", attributes: { class: "person-item" } , descendant: { tag: "a", child: "person 1"} )
- end
-
-  should 'return new person indexed' do
-    get :index, { "selected_type" => :community}
-    assert_response :success
-    assert_select ".search-item", 6
-
-    fast_create Community, name: "community #{7}", created_at: Date.new
-    Community.import
-    sleep 2
-
-    get :index, { "selected_type" => :community}
-    assert_response :success
-    assert_select ".search-item", 7
-  end
-
-  should 'not return person deleted' do
-    get :index, { "selected_type" => :community}
-    assert_response :success
-    assert_select ".search-item", 6
-
-    Community.first.delete
-    Community.import
-
-    get :index, { "selected_type" => :community}
-    assert_response :success
-    assert_select ".search-item", 5
-  end
-
-  should 'redirect to elasticsearch plugin when request are send to core' do
-    @controller = SearchController.new
-    get 'index'
-    params = {:action => 'index', :controller => 'search'}
-    assert_redirected_to controller: 'elasticsearch_plugin', action: 'search', params: params
-  end
-
-  should 'pass params to elastic search controller' do
-    get 'index', { query: 'community' }
-    assert_not_nil assigns(:results)
-    assert_template partial: '_community_display'
-  end
-end
@@ -0,0 +1,80 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+require_relative '../../helpers/elasticsearch_helper.rb'
+
+class ElasticsearchHelperTest < ActiveSupport::TestCase
+
+  include ElasticsearchTestHelper
+  include ElasticsearchHelper
+
+  attr_accessor :params
+
+  def indexed_models
+    [Person,TextArticle,UploadedFile,Community,Event]
+  end
+
+  def create_instances
+    create_user "Jose Abreu"
+    create_user "Joana Abreu"
+    create_user "Joao Abreu"
+    create_user "Ana Abreu"
+  end
+
+  should 'return default_per_page when nil is passed' do
+    assert_not_nil default_per_page nil
+    assert_equal 10, default_per_page(nil)
+  end
+
+  should 'return default_per_page when per_page is passed' do
+    assert_equal 15, default_per_page(15)
+  end
+
+  should 'have indexed_models in searchable_models' do
+    assert_equivalent indexed_models, searchable_models
+  end
+
+  should 'return fields from models using weight' do
+    class StubClass
+      SEARCHABLE_FIELDS = {:name  => {:weight => 10},
+                           :login =>  {:weight => 20},
+                           :description => {:weight => 2}}
+    end
+
+    expected = ["name^10", "login^20", "description^2"]
+    assert_equivalent expected, fields_from_models([StubClass])
+  end
+
+  should 'search from model Person sorted by Alphabetic' do
+    self.params= {:selected_type => 'person',
+                  :filter => 'lexical',
+                  :query => "Abreu",
+                  :per_page => 4}
+
+    result = process_results
+    assert_equal ["Ana Abreu","Joana Abreu","Joao Abreu","Jose Abreu"], result.map(&:name)
+  end
+
+  should 'search from model Person sorted by More Recent' do
+    self.params= {:selected_type => 'person',
+                  :filter => 'more_recent',
+                  :query => 'ABREU',
+                  :per_page => 4}
+
+    result = process_results
+    assert_equal ["Ana Abreu","Joao Abreu","Joana Abreu","Jose Abreu"], result.map(&:name)
+  end
+
+  should 'search from model Person sorted by Relevance' do
+    self.params= {:selected_type => 'person',
+                  :query => 'JOA BREU',
+                  :per_page => 4}
+
+    result = process_results
+    assert_equal ["Joana Abreu", "Joao Abreu"], result.map(&:name)
+  end
+
+  should 'have sort in get_query return if has the option sort_by ' do
+    self.params= {}
+    assert get_query("", sort_by: :more_popular).keys.include?(:sort)
+  end
+
+end
@@ -0,0 +1,37 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+require_relative '../../lib/nested_helper/profile'
+
+class EventTest < ActionController::TestCase
+
+  include ElasticsearchTestHelper
+
+  def indexed_models
+    [Event]
+  end
+
+  should 'index searchable fields for Event model' do
+    Event::SEARCHABLE_FIELDS.each do |key, value|
+      assert_includes indexed_fields(Event), key
+    end
+  end
+
+  should 'index control fields for Event model' do
+    Event::control_fields.each do |key, value|
+      assert_includes indexed_fields(Event), key
+      assert_equal indexed_fields(Event)[key][:type], value[:type] || 'string'
+    end
+  end
+
+  should 'respond with should method to return public event' do
+    assert Event.respond_to? :should
+  end
+
+  should 'respond with nested_filter' do
+    assert Event.respond_to? :nested_filter
+  end
+
+  should 'have NestedProfile_filter in nested_filter' do
+    assert Event.nested_filter.include? NestedProfile.filter
+  end
+
+end
@@ -1,86 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../test_helper"
-require_relative '../../../helpers/elasticsearch_helper.rb'
-
-class ElasticsearchHelperTest < ActiveSupport::TestCase
-
-  include ElasticsearchTestHelper
-  include ElasticsearchHelper
-
-  attr_accessor :params
-
-  def indexed_models
-    [Person,TextArticle,UploadedFile,Community,Event]
-  end
-
-  def create_instances
-    create_user "Jose Abreu"
-    create_user "Joana Abreu"
-    create_user "Joao Abreu"
-    create_user "Ana Abreu"
-  end
-
-  should 'return default_per_page when nil is passed' do
-    assert_not_nil default_per_page nil
-    assert_equal 10, default_per_page(nil)
-  end
-
-  should 'return default_per_page when per_page is passed' do
-    assert_equal 15, default_per_page(15)
-  end
-
-  should 'have indexed_models in searchable_models' do
-    assert_equivalent indexed_models, searchable_models
-  end
-
-  should 'return query_string if expression is valid' do
-
-    query= "my_query"
-    fields = ['name','login']
-    result = query_method(query,fields)
-
-    assert_includes result[:query][:query_string][:query], query
-    assert_equivalent result[:query][:query_string][:fields], fields
-  end
-
-
-  should 'return fields from models using weight' do
-    class StubClass
-      SEARCHABLE_FIELDS = {:name  => {:weight => 10},
-                           :login =>  {:weight => 20},
-                           :description => {:weight => 2}}
-    end
-
-    expected = ["name^10", "login^20", "description^2"]
-    assert_equivalent expected, fields_from_models([StubClass])
-  end
-
-  should 'search from model Person sorted by Alphabetic' do
-    self.params= {:selected_type => 'person',
-                  :filter => 'lexical',
-                  :query => "Abreu",
-                  :per_page => 4}
-
-    result = process_results
-    assert_equal ["Ana Abreu","Joana Abreu","Joao Abreu","Jose Abreu"], result.map(&:name)
-  end
-
-  should 'search from model Person sorted by More Recent' do
-    self.params= {:selected_type => 'person',
-                  :filter => 'more_recent',
-                  :query => 'ABREU',
-                  :per_page => 4}
-
-    result = process_results
-    assert_equal ["Ana Abreu","Joao Abreu","Joana Abreu","Jose Abreu"], result.map(&:name)
-  end
-
-  should 'search from model Person sorted by Relevance' do
-    self.params= {:selected_type => 'person',
-                  :query => 'JOA BREU',
-                  :per_page => 4}
-
-    result = process_results
-    assert_equal ["Joana Abreu", "Joao Abreu"], result.map(&:name)
-  end
-
-end
@@ -1,24 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../test_helper"
-
-class CommunityTest < ActionController::TestCase
-
-  include ElasticsearchTestHelper
-
-  def indexed_models
-    [Community]
-  end
-
-  should 'index searchable fields for Community model' do
-    Community::SEARCHABLE_FIELDS.each do |key, value|
-      assert_includes indexed_fields(Community), key
-    end
-  end
-
-  should 'index control fields for Community model' do
-    Community::control_fields.each do |key, value|
-      assert_includes indexed_fields(Community), key
-      assert_includes indexed_fields(Community)[key][:type], value[:type] || 'string'
-    end
-  end
-
-end
@@ -1,24 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../test_helper"
-
-class EventTest < ActionController::TestCase
-
-  include ElasticsearchTestHelper
-
-  def indexed_models
-    [Event]
-  end
-
-  should 'index searchable fields for Event model' do
-    Event::SEARCHABLE_FIELDS.each do |key, value|
-      assert_includes indexed_fields(Event), key
-    end
-  end
-
-  should 'index control fields for Event model' do
-    Event::control_fields.each do |key, value|
-      assert_includes indexed_fields(Event), key
-      assert_includes indexed_fields(Event)[key][:type], value[:type] || 'string'
-    end
-  end
-
-end
@@ -1,23 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../test_helper"
-
-class PersonTest < ActionController::TestCase
-
-  include ElasticsearchTestHelper
-
-  def indexed_models
-    [Person]
-  end
-
-  should 'index searchable fields for Person model' do
-    Person::SEARCHABLE_FIELDS.each do |key, value|
-      assert_includes indexed_fields(Person), key
-    end
-  end
-
-  should 'index control fields for Person model' do
-    Person::control_fields.each do |key, value|
-      assert_includes indexed_fields(Person), key
-      assert_includes indexed_fields(Person)[key][:type], value[:type] || 'string'
-    end
-  end
-end
@@ -1,24 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../test_helper"
-
-class TextArticleTest < ActionController::TestCase
-
-  include ElasticsearchTestHelper
-
-  def indexed_models
-    [TextArticle]
-  end
-
-  should 'index searchable fields for TextArticle model' do
-    TextArticle::SEARCHABLE_FIELDS.each do |key, value|
-      assert_includes indexed_fields(TextArticle), key
-    end
-  end
-
-  should 'index control fields for TextArticle model' do
-    TextArticle::control_fields.each do |key, value|
-      assert_includes indexed_fields(TextArticle), key
-      assert_includes indexed_fields(TextArticle)[key][:type], value[:type] || 'string'
-    end
-  end
-
-end
@@ -1,24 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../test_helper"
-
-class UploadedFileTest < ActionController::TestCase
-
-  include ElasticsearchTestHelper
-
-  def indexed_models
-    [UploadedFile]
-  end
-
-  should 'index searchable fields for UploadedFile model' do
-    UploadedFile::SEARCHABLE_FIELDS.each do |key, value|
-      assert_includes indexed_fields(UploadedFile), key
-    end
-  end
-
-  should 'index control fields for UploadedFile model' do
-    UploadedFile::control_fields.each do |key, value|
-      assert_includes indexed_fields(UploadedFile), key
-      assert_includes indexed_fields(UploadedFile)[key][:type], value[:type].presence || 'string'
-    end
-  end
-
-end
@@ -0,0 +1,45 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class PersonTest < ActionController::TestCase
+
+  include ElasticsearchTestHelper
+
+  def indexed_models
+    [Person]
+  end
+
+  should 'index searchable fields for Person model' do
+    Person::SEARCHABLE_FIELDS.each do |key, value|
+      assert_includes indexed_fields(Person), key
+    end
+  end
+
+  should 'index control fields for Person model' do
+    Person::control_fields.each do |key, value|
+      assert_includes indexed_fields(Person), key
+      assert_equal indexed_fields(Person)[key][:type], value[:type] || 'string'
+    end
+  end
+
+  should 'respond with should method to return public person' do
+    assert Person.respond_to? :should
+  end
+
+  should 'respond with especific sort' do
+    assert Person.respond_to? :especific_sort
+  end
+
+  should 'respond with get_sort_by to order especific sort' do
+    assert Person.respond_to? :get_sort_by
+  end
+
+  should 'return hash to sort by more_active' do
+    more_active_hash = {:activities_count => {order: :desc}}
+    assert_equal more_active_hash, Person.get_sort_by(:more_active)
+  end
+
+  should 'return hash to sort by more_popular' do
+    more_popular_hash = {:friends_count => {order: :desc}}
+    assert_equal more_popular_hash, Person.get_sort_by(:more_popular)
+  end
+end
@@ -0,0 +1,55 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+require_relative '../../lib/nested_helper/profile'
+
+class TextArticleTest < ActionController::TestCase
+
+  include ElasticsearchTestHelper
+
+  def indexed_models
+    [TextArticle]
+  end
+
+  should 'index searchable fields for TextArticle model' do
+    TextArticle::SEARCHABLE_FIELDS.each do |key, value|
+      assert_includes indexed_fields(TextArticle), key
+    end
+  end
+
+  should 'index control fields for TextArticle model' do
+    TextArticle::control_fields.each do |key, value|
+      assert_includes indexed_fields(TextArticle), key
+      assert_equal indexed_fields(TextArticle)[key][:type], value[:type] || 'string'
+    end
+  end
+
+  should 'respond with should method to return public text_article' do
+    assert TextArticle.respond_to? :should
+  end
+
+  should 'respond with especific sort' do
+    assert TextArticle.respond_to? :especific_sort
+  end
+
+  should 'respond with get_sort_by to order especific sort' do
+    assert TextArticle.respond_to? :get_sort_by
+  end
+
+  should 'return hash to sort by most commented' do
+    more_active_hash = {:comments_count => {order: :desc}}
+    assert_equal more_active_hash, TextArticle.get_sort_by(:more_comments)
+  end
+
+  should 'return hash to sort by more popular' do
+    more_popular_hash = {:hits => {order: :desc}}
+    assert_equal more_popular_hash, TextArticle.get_sort_by(:more_popular)
+  end
+
+  should 'respond with nested_filter' do
+    assert TextArticle.respond_to? :nested_filter
+  end
+
+  should 'have NestedProfile_filter in nested_filter' do
+    assert TextArticle.nested_filter.include? NestedProfile.filter
+  end
+
+end
@@ -0,0 +1,36 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class UploadedFileTest < ActionController::TestCase
+
+  include ElasticsearchTestHelper
+
+  def indexed_models
+    [UploadedFile]
+  end
+
+  should 'index searchable fields for UploadedFile model' do
+    UploadedFile::SEARCHABLE_FIELDS.each do |key, value|
+      assert_includes indexed_fields(UploadedFile), key
+    end
+  end
+
+  should 'index control fields for UploadedFile model' do
+    UploadedFile::control_fields.each do |key, value|
+      assert_includes indexed_fields(UploadedFile), key
+      assert_equal indexed_fields(UploadedFile)[key][:type], value[:type].presence || 'string'
+    end
+  end
+
+  should 'respond with should method to return public text_article' do
+    assert TextArticle.respond_to? :should
+  end
+
+  should 'respond with nested_filter' do
+    assert TextArticle.respond_to? :nested_filter
+  end
+
+  should 'have NestedProfile_filter in nested_filter' do
+    assert TextArticle.nested_filter.include? NestedProfile.filter
+  end
+
+end
@@ -9,4 +9,6 @@
       <p><%= person.description %></p>
     </div>
   </div>
+  <div style="clear: both">
+  </div>
 </div>
@@ -26,18 +26,18 @@
     <div class="sidebar">
       <ul class="search-options">
         <% for type,value in @searchable_types %>
-        <li class="select-search-type <%= "active" if type == @selected_type %>">
-          <%= link_to  value[:label], "?selected_type=#{type}&query=#{@query}&filter=#{@selected_filter}"%>
-        </li>
+          <li class="select-search-type <%= "active" if type == @selected_type %>">
+            <%= link_to value[:label], "?selected_type=#{type}&query=#{@query}"%>
+          </li>
         <% end %>
       </ul>
       <div class="search-filter">
         <h3 class="box-title"><%= _("Sort by") %></h3>
         <ul>
-          <% for type, value in @filter_types %>
-          <li class="select-search-type <%= "active" if type == @selected_filter %>">
-            <%= link_to value[:label], "?selected_type=#{@selected_type}&query=#{@query}&filter=#{type}" %>
-          </li>
+          <% for type, value in @sort_types %>
+            <li class="select-search-type <%= "active" if type == @selected_sort %>">
+              <%= link_to value[:label], "?selected_type=#{@selected_type}&query=#{@query}&filter=#{type}" %>
+            </li>
           <% end %>
         </ul>
       </div>
	@@ -1,53 +0,0 @@	@@ -1,53 +0,0 @@
1	-module ElasticsearchIndexedModel
2	-
3	- def self.included base
4	- base.send :include, Elasticsearch::Model
5	- base.send :include, Elasticsearch::Model::Callbacks
6	-
7	- base.send :index_name, "#{Rails.env}_#{base.index_name}"
8	- base.extend ClassMethods
9	- base.class_eval do
10	- settings index: { number_of_shards: 1 } do
11	- mappings dynamic: 'false' do
12	- base.indexed_fields.each do \|field, value\|
13	- value = {} if value.nil?
14	- type = value[:type].presence
15	- if type.nil?
16	- indexes(field, fields: base.raw_field(field))
17	- else
18	- indexes field, type: type
19	- end
20	- print '.'
21	- end
22	- end
23	-
24	- base.__elasticsearch__.client.indices.delete \
25	- index: base.index_name rescue nil
26	- base.__elasticsearch__.client.indices.create \
27	- index: base.index_name,
28	- body: {
29	- settings: base.settings.to_hash,
30	- mappings: base.mappings.to_hash
31	- }
32	- end
33	- end
34	- base.send :import
35	- end
36	-
37	- module ClassMethods
38	- def raw_field name
39	- {
40	- raw: {
41	- type: "string",
42	- index: "not_analyzed"
43	- }
44	- }
45	- end
46	-
47	- def indexed_fields
48	- self::SEARCHABLE_FIELDS.merge self.control_fields
49	- end
50	-
51	- end
52	-
53	-end
1	require_dependency 'community'	1	require_dependency 'community'
2	-require_relative '../elasticsearch_indexed_model'	2	+require_relative '../searchable_model_helper'
3		3
4	class Community	4	class Community
		5	+
5	def self.control_fields	6	def self.control_fields
6	{	7	{
7	- :created_at => {type: 'date'}	8	+ :secret => { type: :boolean },
		9	+ :visible => { type: :boolean },
		10	+ :activities_count => { type: :integer },
		11	+ :members_count => { type: :integer }
		12	+ }
		13	+ end
		14	+
		15	+ def self.should
		16	+ [
		17	+ { and:
		18	+ [
		19	+ {term: { :secret => false }},
		20	+ {term: { :visible => true }}
		21	+ ]
		22	+ }
		23	+ ]
		24	+ end
		25	+
		26	+ def self.especific_sort
		27	+ {
		28	+ :more_active => { label: _("More Active") },
		29	+ :more_popular => { label: _("More Popular") }
8	}	30	}
9	end	31	end
10	- include ElasticsearchIndexedModel	32	+
		33	+ def self.get_sort_by sort_by=""
		34	+ case sort_by
		35	+ when :more_active
		36	+ { :activities_count => {order: :desc}}
		37	+ when :more_popular
		38	+ { :members_count => {order: :desc}}
		39	+ end
		40	+ end
		41	+
		42	+ include SearchableModelHelper
11	end	43	end
1	require_dependency 'event'	1	require_dependency 'event'
2	-require_relative '../elasticsearch_indexed_model'	2	+
		3	+require_relative '../searchable_model_helper'
		4	+require_relative '../nested_helper/profile'
3		5
4	class Event	6	class Event
		7	+ #TODO: o filtro é feito de forma diferente do artigo
		8	+
5	def self.control_fields	9	def self.control_fields
6	{	10	{
7	- :advertise => {},
8	- :published => {},
9	- :created_at => {type: 'date'}	11	+ :advertise => {type: :boolean},
		12	+ :published => {type: :boolean},
		13	+ :profile => { type: :nested , hash: NestedProfile.hash }
10	}	14	}
11	end	15	end
12	- include ElasticsearchIndexedModel	16	+
		17	+ def self.should
		18	+ [
		19	+ { and: [
		20	+ { term: { advertise: true }},
		21	+ { term: { published: true }}
		22	+ ]
		23	+ }
		24	+ ]
		25	+ end
		26	+
		27	+ def self.nested_filter
		28	+ [
		29	+ NestedProfile::filter
		30	+ ]
		31	+ end
		32	+
		33	+ include SearchableModelHelper
13	end	34	end
1	require_dependency 'person'	1	require_dependency 'person'
2	-require_relative '../elasticsearch_indexed_model'	2	+
		3	+require_relative '../searchable_model_helper'
3		4
4	class Person	5	class Person
		6	+
5	def self.control_fields	7	def self.control_fields
6	{	8	{
7	- :visible => {type: 'boolean'},
8	- :public_profile => {type: 'boolean'},
9	- :created_at => {type: 'date'}	9	+ :visible => {type: 'boolean'},
		10	+ :secret => { type: :boolean },
		11	+ :activities_count => { type: :integer },
		12	+ :friends_count => { type: :integer }
10	}	13	}
11	end	14	end
12	- include ElasticsearchIndexedModel	15	+
		16	+ def self.should
		17	+ [
		18	+ { and:
		19	+ [
		20	+ {term: { :secret => false }},
		21	+ {term: { :visible => true }}
		22	+ ]
		23	+ }
		24	+ ]
		25	+ end
		26	+
		27	+ def self.especific_sort
		28	+ {
		29	+ :more_active => { label: _("More Active") },
		30	+ :more_popular => { label: _("More Popular") }
		31	+ }
		32	+ end
		33	+
		34	+ def self.get_sort_by sort_by=""
		35	+ case sort_by
		36	+ when :more_active
		37	+ { :activities_count => {order: :desc}}
		38	+ when :more_popular
		39	+ { :friends_count => {order: :desc} }
		40	+ end
		41	+ end
		42	+
		43	+ include SearchableModelHelper
13	end	44	end
1	# REQUIRE TO LOAD DESCENDANTS FROM TEXT_ARTICLE	1	# REQUIRE TO LOAD DESCENDANTS FROM TEXT_ARTICLE
2	require_dependency 'raw_html_article'	2	require_dependency 'raw_html_article'
3	require_dependency 'tiny_mce_article'	3	require_dependency 'tiny_mce_article'
4	-
5	require_dependency 'text_article'	4	require_dependency 'text_article'
6	-require_relative '../elasticsearch_indexed_model'	5	+
		6	+require_relative '../searchable_model_helper'
		7	+require_relative '../nested_helper/profile'
7		8
8	class TextArticle	9	class TextArticle
		10	+
9	def self.control_fields	11	def self.control_fields
10	{	12	{
11	- :advertise => {},
12	- :published => {},
13	- :created_at => {type: 'date'}	13	+ :advertise => { type: :boolean },
		14	+ :published => { type: 'boolean'},
		15	+ :comments_count => { type: :integer },
		16	+ :hits => { type: :integer },
		17	+ :profile => { type: :nested , hash: NestedProfile.hash }
		18	+ }
		19	+ end
		20	+
		21	+ def self.should
		22	+ [
		23	+ { and: [
		24	+ { term: { advertise: true }},
		25	+ { term: { published: true }}
		26	+ ]
		27	+ }
		28	+ ]
		29	+ end
		30	+
		31	+ def self.nested_filter
		32	+ [
		33	+ NestedProfile::filter
		34	+ ]
		35	+ end
		36	+
		37	+ def self.especific_sort
		38	+ {
		39	+ :more_popular => { label: _("More Viewed") },
		40	+ :more_comments => { label: _("Most Commented") }
14	}	41	}
15	end	42	end
16	- include ElasticsearchIndexedModel	43	+
		44	+ def self.get_sort_by sort_by=""
		45	+ case sort_by
		46	+ when :more_popular
		47	+ { :hits => {order: :desc} }
		48	+ when :more_comments
		49	+ { :comments_count => {order: :desc}}
		50	+ end
		51	+ end
		52	+
		53	+ include SearchableModelHelper
17	end	54	end
1	require_dependency 'uploaded_file'	1	require_dependency 'uploaded_file'
2	-require_relative '../elasticsearch_indexed_model'	2	+
		3	+require_relative '../searchable_model_helper'
		4	+require_relative '../nested_helper/profile'
3		5
4	class UploadedFile	6	class UploadedFile
5	def self.control_fields	7	def self.control_fields
6	{	8	{
7	- :advertise => {},
8	- :published => {},
9	- :created_at => {type: 'date'}	9	+ :advertise => {type: :boolean},
		10	+ :published => {type: :boolean},
		11	+ :profile => { type: :nested , hash: NestedProfile.hash }
10	}	12	}
11	end	13	end
12	- include ElasticsearchIndexedModel	14	+
		15	+ def self.should
		16	+ [
		17	+ { and: [
		18	+ { term: { advertise: true }},
		19	+ { term: { published: true }}
		20	+ ]
		21	+ }
		22	+ ]
		23	+ end
		24	+
		25	+ def self.nested_filter
		26	+ [
		27	+ NestedProfile::filter
		28	+ ]
		29	+ end
		30	+
		31	+ include SearchableModelHelper
13	end	32	end
@@ -0,0 +1,25 @@		@@ -0,0 +1,25 @@
	1	+module NestedEnvironment
	2	+
	3	+ def self.hash
	4	+ {
	5	+ :id => { type: :integer },
	6	+ :is_default => {type: :boolean }
	7	+ }
	8	+ end
	9	+
	10	+ def self.filter environment=1
	11	+ {
	12	+ query: {
	13	+ nested: {
	14	+ path: "environment",
	15	+ query: {
	16	+ bool: {
	17	+ must: { term: { "environment.id" => environment } },
	18	+ }
	19	+ }
	20	+ }
	21	+ }
	22	+ }
	23	+ end
	24	+
	25	+end
@@ -0,0 +1,29 @@		@@ -0,0 +1,29 @@
	1	+module NestedProfile
	2	+
	3	+ def self.hash
	4	+ {
	5	+ :id => { type: :integer },
	6	+ :visible => { type: :boolean },
	7	+ :public_profile => { type: :boolean }
	8	+ }
	9	+ end
	10	+
	11	+ def self.filter
	12	+ {
	13	+ query: {
	14	+ nested: {
	15	+ path: "profile",
	16	+ query: {
	17	+ bool: {
	18	+ must:[
	19	+ { term: { "profile.visible" => true } },
	20	+ { term: { "profile.public_profile" => true } }
	21	+ ],
	22	+ }
	23	+ }
	24	+ }
	25	+ }
	26	+ }
	27	+ end
	28	+
	29	+end
@@ -0,0 +1,99 @@		@@ -0,0 +1,99 @@
	1	+require_relative '../nested_helper/environment'
	2	+
	3	+module ElasticsearchIndexedModel
	4	+
	5	+ def self.included base
	6	+ base.send :include, Elasticsearch::Model
	7	+ base.send :include, Elasticsearch::Model::Callbacks
	8	+
	9	+ base.send :index_name, "#{Rails.env}_#{base.index_name}"
	10	+
	11	+ base.extend ClassMethods
	12	+ base.send :include, InstanceMethods
	13	+
	14	+ base.class_eval do
	15	+ settings index: { number_of_shards: 1 } do
	16	+ mappings dynamic: 'false' do
	17	+ base.indexed_fields.each do \|field, value\|
	18	+ type = value[:type].presence
	19	+
	20	+ if type == :nested
	21	+ indexes(field, type: type) do
	22	+ value[:hash].each do \|hash_field, hash_value\|
	23	+ indexes(hash_field, base.indexes_as_hash(hash_field,hash_value[:type].presence))
	24	+ end
	25	+ end
	26	+ else
	27	+ indexes(field, base.indexes_as_hash(field,type))
	28	+ end
	29	+ print '.'
	30	+ end
	31	+ end
	32	+
	33	+ base.__elasticsearch__.client.indices.delete \
	34	+ index: base.index_name rescue nil
	35	+ base.__elasticsearch__.client.indices.create \
	36	+ index: base.index_name,
	37	+ body: {
	38	+ settings: base.settings.to_hash,
	39	+ mappings: base.mappings.to_hash
	40	+ }
	41	+ end
	42	+ end
	43	+ base.send :import
	44	+ end
	45	+
	46	+ module ClassMethods
	47	+
	48	+ def indexes_as_hash(name, type)
	49	+ hash = {}
	50	+ if type.nil?
	51	+ hash[:fields] = raw_field(name, type)
	52	+ else
	53	+ hash[:type] = type if not type.nil?
	54	+ end
	55	+ hash
	56	+ end
	57	+
	58	+ def raw_field name, type
	59	+ {
	60	+ raw: {
	61	+ type: "string",
	62	+ index: "not_analyzed"
	63	+ }
	64	+ }
	65	+ end
	66	+
	67	+ def indexed_fields
	68	+ fields = {
	69	+ :environment => {type: :nested, hash: NestedEnvironment::hash },
	70	+ :category_ids => {type: :integer },
	71	+ :created_at => {type: :date }
	72	+ }
	73	+ fields.update(self::SEARCHABLE_FIELDS)
	74	+ fields.update(self.control_fields)
	75	+ fields
	76	+ end
	77	+
	78	+ end
	79	+
	80	+ module InstanceMethods
	81	+ def as_indexed_json options={}
	82	+ attrs = {}
	83	+
	84	+ self.class.indexed_fields.each do \|field, value\|
	85	+ type = value[:type].presence
	86	+ if type == :nested
	87	+ attrs[field] = {}
	88	+ value[:hash].each do \|hash_field, hash_value\|
	89	+ attrs[field][hash_field] = self.send(field).send(hash_field)
	90	+ end
	91	+ else
	92	+ attrs[field] = self.send(field)
	93	+ end
	94	+ end
	95	+ attrs.as_json
	96	+ end
	97	+ end
	98	+
	99	+end
@@ -0,0 +1,41 @@		@@ -0,0 +1,41 @@
	1	+require_relative '../nested_helper/environment'
	2	+
	3	+module Filter
	4	+
	5	+ def self.included base
	6	+ base.extend ClassMethods
	7	+ base.send :include, InstanceMethods
	8	+ end
	9	+
	10	+ module ClassMethods
	11	+
	12	+ def filter options={}
	13	+ environment = options[:environment].presence
	14	+
	15	+ result_filter = {}
	16	+ result_filter[:indices] = {:index => self.index_name, :no_match_filter => "none" }
	17	+ result_filter[:indices][:filter] = { :bool => self.filter_bool(environment) }
	18	+
	19	+ result_filter
	20	+ end
	21	+
	22	+ def filter_bool environment
	23	+ result_filter = {}
	24	+
	25	+ result_filter[:must] = [ NestedEnvironment::filter(environment) ]
	26	+
	27	+ self.nested_filter.each {\|filter\| result_filter[:must].append(filter)} if self.respond_to? :nested_filter
	28	+ self.must.each {\|filter\| result_filter[:must].append(filter) } if self.respond_to? :must
	29	+
	30	+ result_filter[:should] = self.should if self.respond_to? :should
	31	+ result_filter[:must_not] = self.must_not if self.respond_to? :must_not
	32	+
	33	+ result_filter
	34	+ end
	35	+ end
	36	+
	37	+ module InstanceMethods
	38	+
	39	+ end
	40	+
	41	+end