Serializing models
By default, all model attributes are indexed.
You can control what you index with the attribute
method
The attribute
method#
A
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#
A
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# A
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# A
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# A
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# A
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# A
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