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>
...	...	@@ -11,7 +11,7 @@ class ElasticsearchPluginController < ApplicationController
11	11
12	12	def search
13	13	define_searchable_types
14		- define_search_fields_types
	14	+ define_sort_types
15	15	define_results
16	16	end
17	17
...	...	@@ -22,13 +22,13 @@ class ElasticsearchPluginController < ApplicationController
22	22	end
23	23
24	24	def define_searchable_types
25		- @searchable_types = ElasticsearchHelper::searchable_types
	25	+ @searchable_types = searchable_types
26	26	@selected_type = (params[:selected_type]\|\| :all ).to_sym
27	27	end
28	28
29		- def define_search_fields_types
30		- @filter_types = ElasticsearchHelper::filters
31		- @selected_filter = (params[:filter] \|\| :relevance).to_sym
	29	+ def define_sort_types
	30	+ @sort_types = sort_types
	31	+ @selected_sort = (params[:filter] \|\| :relevance).to_sym
32	32	end
33	33
34	34	end
...	...
1	1	module ElasticsearchHelper
2	2
3		- def self.searchable_types
	3	+ def searchable_types
4	4	{
5	5	:all => { label: _("All Results")},
6	6	:text_article => { label: _("Articles")},
...	...	@@ -11,12 +11,20 @@ module ElasticsearchHelper
11	11	}
12	12	end
13	13
14		- def self.filters
15		- {
	14	+ def sort_types
	15	+ sorts = {
16	16	:relevance => { label: _("Relevance")},
17	17	:lexical => { label: _("Alphabetical")},
18	18	:more_recent => { label: _("More Recent")},
19	19	}
	20	+
	21	+ selected_type = params[:selected_type] \|\| nil
	22	+
	23	+ if selected_type and selected_type.to_sym != :all
	24	+ klass = selected_type.to_s.classify.constantize
	25	+ sorts.update klass.especific_sort if klass.respond_to? :especific_sort
	26	+ end
	27	+ sorts
20	28	end
21	29
22	30	def process_results
...	...	@@ -27,15 +35,20 @@ module ElasticsearchHelper
27	35	private
28	36
29	37	def search_from_all_models
30		- query = get_query params[:query], sort_by: get_sort_by(params[:filter])
31		- Elasticsearch::Model.search(query,searchable_models, size: default_per_page(params[:per_page])).page(params[:page]).records
	38	+ begin
	39	+ filter = (params[:filter] \|\| "" ).to_sym
	40	+ query = get_query params[:query], sort_by: get_sort_by(filter)
	41	+ Elasticsearch::Model.search(query,searchable_models, size: default_per_page(params[:per_page])).page(params[:page]).records
	42	+ rescue
	43	+ []
	44	+ end
32	45	end
33	46
34	47	def search_from_model model
35	48	begin
36	49	klass = model.to_s.classify.constantize
37		-
38		- query = get_query params[:query], klass: klass, sort_by: get_sort_by(params[:filter])
	50	+ filter = (params[:filter] \|\| "" ).to_sym
	51	+ query = get_query params[:query], klass: klass, sort_by: get_sort_by(filter,klass)
39	52	klass.search(query, size: default_per_page(params[:per_page])).page(params[:page]).records
40	53	rescue
41	54	[]
...	...	@@ -46,49 +59,58 @@ module ElasticsearchHelper
46	59	per_page \|\|= 10
47	60	end
48	61
49		- def get_sort_by sort_by
	62	+ def get_sort_by sort_by, klass=nil
50	63	case sort_by
51		- when "lexical"
	64	+ when :lexical
52	65	{ "name.raw" => {"order" => "asc" }}
53		- when "more_recent"
	66	+ when :more_recent
54	67	{ "created_at" => {"order" => "desc"}}
	68	+ else
	69	+ ( klass and klass.respond_to?(:get_sort_by) ) ? klass.get_sort_by(sort_by) : nil
55	70	end
56	71	end
57	72
58	73	def searchable_models
59		- begin
60		- ElasticsearchHelper::searchable_types.except(:all).keys.map { \| model \| model.to_s.classify.constantize }
61		- rescue
62		- []
63		- end
	74	+ searchable_types.except(:all).keys.map { \| model \| model.to_s.classify.constantize }
	75	+ end
	76	+
	77	+ def query_string expression="", models=[]
	78	+ return { match_all: {} } if not expression
	79	+ {
	80	+ query_string: {
	81	+ query: ""+expression.downcase.split.join(' ')+"",
	82	+ fields: fields_from_models(models),
	83	+ tie_breaker: 0.4,
	84	+ minimum_should_match: "100%"
	85	+ }
	86	+ }
64	87	end
65	88
66		- def query_method expression="", fields=[]
67		- query_exp = {}
68		- if expression.blank?
69		- else
70		- query_exp = {
71		- query: {
72		- query_string: {
73		- query: ""+expression.downcase.split.join(' ')+"",
74		- fields: fields,
75		- tie_breaker: 0.4,
76		- minimum_should_match: "100%"
77		- },
	89	+
	90	+ def query_method expression="", models=[]
	91	+ {
	92	+ query: {
	93	+ filtered: {
	94	+ query: query_string(expression,models),
	95	+ filter: {
	96	+ bool: {
	97	+ should: models.map {\|model\| model.filter(environment: @environment.id) }
	98	+ }
	99	+ }
78	100	}
79	101	}
80		- end
81		- query_exp
	102	+ }
82	103	end
83	104
84	105	def get_query text="", options={}
85	106	klass = options[:klass]
86	107	sort_by = options[:sort_by]
87	108
88		- fields = klass.nil? ? (fields_from_models searchable_models) : (fields_from_models [klass])
	109	+ models = (klass.nil?) ? searchable_models : [klass]
89	110
90		- query = query_method(text, fields)
	111	+ query = query_method(text, models)
91	112	query[:sort] = sort_by if sort_by
	113	+
92	114	query
93	115	end
94	116
...	...
...	...	@@ -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
...	...	@@ -10,14 +10,18 @@ class ElasticsearchPlugin::API < Grape::API
10	10	target = process_results
11	11	present target,
12	12	:with => Elasticsearch::Entities::Result,
13		- :types => ElasticsearchHelper.searchable_types.except(:all).keys.map { \|key\| key.to_s.classify }
	13	+ :types => searchable_types.except(:all).keys.map { \|key\| key.to_s.classify }
14	14	end
15	15
16	16	get 'types' do
17		- types = {types: ElasticsearchHelper::searchable_types.stringify_keys.keys}
	17	+ types = {types: searchable_types.stringify_keys.keys }
18	18	present types, with: Grape::Presenters::Presenter
19	19	end
20	20
	21	+ get 'sort_types' do
	22	+ present sort_types, with: Grape::Presenters::Presenter
	23	+ end
	24	+
21	25	end
22	26
23	27	end
...	...
1	1	require_dependency 'community'
2		-require_relative '../elasticsearch_indexed_model'
	2	+require_relative '../searchable_model_helper'
3	3
4	4	class Community
	5	+
5	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	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	43	end
...	...
1	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	6	class Event
	7	+ #TODO: o filtro é feito de forma diferente do artigo
	8	+
5	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	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	34	end
...	...
1	1	require_dependency 'person'
2		-require_relative '../elasticsearch_indexed_model'
	2	+
	3	+require_relative '../searchable_model_helper'
3	4
4	5	class Person
	6	+
5	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	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	44	end
...	...
1	1	# REQUIRE TO LOAD DESCENDANTS FROM TEXT_ARTICLE
2	2	require_dependency 'raw_html_article'
3	3	require_dependency 'tiny_mce_article'
4		-
5	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	9	class TextArticle
	10	+
9	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	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	54	end
...	...
1	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	6	class UploadedFile
5	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	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	32	end
...	...
...	...	@@ -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
...	...