So I have a subscription table in my database.
I would like to have a state column which will have any one of the following values
Valid
Invalid
Cancelled
In Trial
Non Renewing
Future
Can someone explain how to use these values as enum values in rails 4?
Credit to: https://hackhands.com/ruby-on-enums-queries-and-rails-4-1/
Declare an enum attribute where the values map to integers in the database, but can be queried by name. Example:
class Conversation < ActiveRecord::Base
enum status: [ :active, :archived ]
end
# conversation.update! status: 0
conversation.active!
conversation.active? # => true
conversation.status # => "active"
# conversation.update! status: 1
conversation.archived!
conversation.archived? # => true
conversation.status # => "archived"
# conversation.update! status: 1
conversation.status = "archived"
# conversation.update! status: nil
conversation.status = nil
conversation.status.nil? # => true
conversation.status # => nil
Scopes based on the allowed values of the enum field will be provided as well. With the above example, it will create an active and archived scope.
You can set the default value from the database declaration, like:
create_table :conversations do |t|
t.column :status, :integer, default: 0
end
Good practice is to let the first declared status be the default.
Finally, it's also possible to explicitly map the relation between attribute and database integer with a Hash:
class Conversation < ActiveRecord::Base
enum status: { active: 0, archived: 1 }
end
Note that when an Array is used, the implicit mapping from the values to database integers is derived from the order the values appear in the array. In the example, :active is mapped to 0 as it's the first element, and :archived is mapped to 1. In general, the i-th element is mapped to i-1 in the database.
Therefore, once a value is added to the enum array, its position in the array must be maintained, and new values should only be added to the end of the array. To remove unused values, the explicit Hash syntax should be used.
In rare circumstances you might need to access the mapping directly. The mappings are exposed through a class method with the pluralized attribute name:
Conversation.statuses # => { "active" => 0, "archived" => 1 }
Use that class method when you need to know the ordinal value of an enum:
Conversation.where("status <> ?", Conversation.statuses[:archived])
Where conditions on an enum attribute must use the ordinal value of an enum.
More info: http://api.rubyonrails.org/v4.1.0/classes/ActiveRecord/Enum.html
You can use gem called Workflow. It enables you to use custom statuses and gracefully handle transitions between states. I've used it on many Rails3 and Rails 4 apps.
Example from the documentation.
class Article
include Workflow
workflow do
state :new do
event :submit, :transitions_to => :awaiting_review
end
state :awaiting_review do
event :review, :transitions_to => :being_reviewed
end
state :being_reviewed do
event :accept, :transitions_to => :accepted
event :reject, :transitions_to => :rejected
end
state :accepted
state :rejected
end
end
And later:
article = Article.new
article.accepted? # => false
article.new? # => true
Edit: My answer here does not use ActiveRecord magic enums. What I suggest below works for any DB library (like Sequel), and I happen to think it slightly more robust. For example, it does not rely on automatic ordering of values, and it uses foreign key constraints in the RDBMS to ensure that your value is valid (unlike the ActiveRecord solution). However, it is not the Rails idiomatic methodology. See Giri's answer (a copy/paste of the documentation page) for the idiomatic answer.
Create a states table in your database with these string values populated along with a unique ID, e.g.
states
id | name
---+--------------
1 | Valid
2 | Invalid
3 | Cancelled
4 | In Trial
5 | Non Renewing
6 | Future
Use a standard foreign-key association in your subscription table referencing an entry from states.
In your models, create a State class with constants matching the IDs, e.g.:
class State < ActiveRecord::Base
VALID = 1
INVALID = 2
# etc.
end
Now you are a) guaranteed that your table data is valid, and b) you can use convenient references such as asking for subscriptions
Subscription.where( state_id: State::VALID )
