Serializing models
By default, all model attributes are indexed.
You can control what you index with the attribute
method
The attribute
method
The attribute
method defines which model attributes to index.
- If you pass one or more symbols, it calls the methods with the same name.
- If you pass it a block, you can only use one symbol to define the attribute name. The block defines the value.
To keep your code as readable as possible:
attributes
is an alias forattribute
- You can call both methods multiple times
For example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Contact < ActiveRecord::Base
include AlgoliaSearch
algoliasearch do
# Sending 3 model attributes
attributes :first_name, :last_name, :email
# Sending a dynamic attribute defined by instance method
attribute :full_name
# Aliasing birth_date attribute to dob with shorthand block syntax
attribute (:dob) { birth_date }
# Nesting the company information for organization-sake
attribute :company do
{ name: company_name, website: company_website }
end
end
def full_name
"#{first_name} #{last_name}"
end
end
If you’re using dynamic attributes, you need to handle updates to those attributes manually. For more information, see Automatic updates.
The add_attribute
method
You can use the add_attribute(s)
method for indexing.
It’s useful if you want to index all attributes from an item,
but also add new attributes.
1
2
3
4
5
6
7
8
9
10
11
12
class Contact < ActiveRecord::Base
include AlgoliaSearch
algoliasearch do
# Since no +attribute+ were defined, all model attributes will be sent.
# Plus the full_name attribute
add_attribute :full_name do
"#{first_name} #{last_name}"
end
end
end
Custom object IDs
Every Algolia record needs an objectID
.
By default, this gem uses Rails id
as the Algolia objectID
.
To use a custom ID, use the id
option.
Each objectID
must be unique in the index, or your records might be overwritten or deleted by other models.
The id
can be a model attribute or you can define your own attribute.
1
2
3
4
5
6
class UniqUser < ActiveRecord::Base
include AlgoliaSearch
algoliasearch id: :uniq_email do
end
end
1
2
3
4
5
6
7
8
9
10
class UniqUser < ActiveRecord::Base
include AlgoliaSearch
algoliasearch id: :algolia_id do
end
def algolia_id
"user_#{id}"
end
end
Helpers
This gem comes with helpers for special Algolia attributes.
To detect changes for these helpers, see tags
and geoloc
helpers.
Coordinates for geo search
Adding coordinates to your records lets you search by location.
1
2
3
4
5
6
7
class Contact < ActiveRecord::Base
include AlgoliaSearch
algoliasearch do
geoloc :latitude, :longitude
end
end
Tags
The _tags
attributes is required for filtering by tags.
You use any attribute for filtering if you configure it in the settings.
1
2
3
4
5
6
7
class Contact < ActiveRecord::Base
include AlgoliaSearch
algoliasearch do
tags ['trusted']
end
end
To create tags dynamically, use a block:
1
2
3
4
5
6
7
8
9
10
class Contact < ActiveRecord::Base
include AlgoliaSearch
algoliasearch do
tags do
[first_name.blank? || last_name.blank? ? 'partial' : 'full',
has_valid_email? ? 'valid_email' : 'invalid_email']
end
end
end
Sanitize HTML
To remove all HTML tags from your attributes,
use the sanitize
options.
1
2
3
4
5
6
7
class Contact < ActiveRecord::Base
include AlgoliaSearch
algoliasearch sanitize: true do
attributes :name, :email, :company
end
end
UTF-8 encoding
To make all your attributes UTF-8 encoded, use the force_utf8_encoding
option.
1
2
3
4
5
6
7
class Contact < ActiveRecord::Base
include AlgoliaSearch
algoliasearch force_utf8_encoding: true do
attributes :name, :email, :company
end
end
Serialization with ActiveModelSerializers
You can use ActiveModelSerializers to extract all logic for creating your records into a separate class.
In the algoliasearch
block, specify what class to use with use_serializer
.
If specified, all attribute(s)
methods are ignored.
You can still use add_attribute(s)
and the tags
or geoloc
helpers.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# post_serializer.rb
class PostSerializer < ActiveModel::Serializer
attributes :id, :title, :text
has_one :author
has_many :comments
end
# author_serializer.rb
class AuthorSerializer < ActiveModel::Serializer
attributes :id, :name
end
# comment_serializer.rb
class CommentSerializer < ActiveModel::Serializer
attributes :text
has_one :author
end
# post.rb
class Post
has_one :author
has_many :comments
algoliasearch do
use_serializer PostSerializer
# Also combine the serialize result with
# `add_attribute`, `tags` or `geoloc` if necessary
end
end