I have :
class UserItem < ActiveRecord::Base
belongs_to :user
belongs_to :item
scope :equipped, -> { where(equipped: true) }
end
class Item < ActiveRecord::Base
has_many :user_items
has_many :users, through: :user_items
scope :armor, -> { where(type: 'Armor') }
delegate :equipped, to: :user_items
end
EDIT:
If i try
User.first.items.equipped => undefined method 'equipped' for #<ActiveRecord::Associations::CollectionProxy []>
User.first.items.armor.equipped => undefined method 'equipped' for #<ActiveRecord::AssociationRelation []>
How can I delegate to scope?
You can't easily delegate to scopes, nor would you want to since it would return objects from the targeted class (UserItem), not the child.
Instead, you can merge scopes very simply:
class UserItem < ActiveRecord::Base
scope :equipped, -> { where(equipped: true) }
end
class Item < ActiveRecord::Base
scope :equipped, -> {joins(:user_items).merge(UserItem.equipped)}
end
=> Item.equipped
=> collection of items for which they have a user_item association that is equipped
Edit: some documentation on this feature.
Using Named Scopes Across Models with ActiveRecord#Merge
http://apidock.com/rails/ActiveRecord/SpawnMethods/merge
Edit again:
If you REALLY want to return a collection of UserItems from a method you call on Item, then you can do as follows:
class Item
class << self
delegate :equipped, to: :UserItem
end
...
But this will return UserItems in a collection, not Items. Which begs the question of why delegate this at all?
If you want a collection of Items, and you want to limit those items by a collection of equipped UserItems, then use merge.
Related
In Rails 4 I am using:
class Ticket < ActiveRecord::Base
has_many :request_attendances, dependent: :destroy
has_many :attending_request_attendances, -> {
where("data->>'rsvp_completed' = 'true'")
.where("data->>'is_coming' = 'true'")
}, class_name: 'RequestAttendance'
end
In my Tickets model
And
class RequestAttendance < ActiveRecord::Base
belongs_to :tickets, inverse_of: :request_attendances
scope :is_coming, -> { where("data->>'is_coming' = 'true'")}
scope :rsvp_completed, -> { where("data->>'rsvp_completed' = 'true'")}
end
In my RequestAttendance model
I would like to do something like this
has_many :attending_request_attendances, -> {
:is_coming
:rsvp_completed
}, class_name: 'RequestAttendance'
To reuse the scope I have created in my RequestAttendance model.
Is something like this possible, at the moment it does not work, giving me the following error:
undefined method `except' for :rsvp_completed:Symbol
If I add a where to the has_many block like this:
has_many :attending_request_attendances, -> {
:is_coming
:rsvp_completed
where("data->>'rsvp_completed' = 'true'")
}, class_name: 'RequestAttendance'
It does not error, however it also does not use the scope clauses either.
You can chain scopes together inside an association like this:
has_many :attending_request_attendances, -> {
is_coming.rsvp_completed
}, class_name: 'RequestAttendance'
You have added the below code in RequestAttendance model
scope :is_coming, -> { where("data->>'is_coming' = 'true'")}
scope :rsvp_completed, -> { where("data->>'rsvp_completed' = 'true'")}
if you use the below code in Tickets Model
class Tickets < ActiveRecord::Base
has_many :RequestAttendance
end
scopes are available to has_many associations so it will fetch all the records with is_coming' = 'true' and "data->>'rsvp_completed' = 'true'"
You can fetch it using object tickets.requestAttendance.is_coming.rsvp_completed
Is it your expectation or If I misunderstood pls explain
I have a model called "activos", I need to show only the records that are not associated with another model called "relactivo".
I've been trying this in the model: scope :ts, -> { includes(:relactivo).where(relactivo: { activo: nil}) }
this is my model "activos"
class Activo < ActiveRecord::Base
self.primary_key = "IdActivos"
scope :ts, -> { includes(:relactivo).where(relactivo: { activo: nil}) }
has_one :relactivo, class_name: "Relactivo", foreign_key: "Activo"
end
and my model "relactivo"
class Relactivo < ActiveRecord::Base
self.primary_key = "IdRow"
belongs_to :activo, class_name:"Activo", foreign_key: "Activo"
end
Try doing this for your scope:
class Activo < ActiveRecord::Base
self.primary_key = "IdActivos"
scope :ts, -> { joins('LEFT OUTER JOIN relactivos ON relactivos.IdActivos = activos.IdActivos WHERE relactivos.IdActivos IS null'))) }
has_one :relactivo, class_name: "Relactivo", foreign_key: "IdActivos"
end
See if this works, The custom primary/foreign key makes it a little strange but try this.
I would like to filter stories on my index based on 2 different conditions where one is for the Current Country and the other one is for All Countries. Is it possible to create a scope where it could fetch stories for both this condition ?
All Countries is boolean field where in my Story table. The logic is if the Story is created for all countries the field, all_countries = 1
Featured Item model, is where the stories could be featured on the index page if the writer would like to do so.
This is how my model looks like for now with the scopes
class Country < ActiveRecord::Base
has_many :stories
end
class Story < ActiveRecord::Base
belongs_to :countries
has_many :featured_items, dependent: :destroy
scope :by_country, lambda { |id| where(:country_id => id)}
scope :for_all_countries, where(:all_countries => true)
end
class FeaturedItem < ActiveRecord::Base
belongs_to :story
scope :by_country, -> (country) {joins(:story).where('`stories`.country_id = ?', Country.find(country) )}
scope :for_all_countries, -> { joins(:story).where('`stories`.all_countries = ?',true) }
end
p/s the scope for all countries on the featured Items also returns an error.
You can do this sort of thing:
scope :by_country, -> (country) { country == :all ? where(:all_countries => true) : where(:country_id => country) }
You may need to add a little more logic to handle bad params.
And for the join table, you can join and filter on the stories.
class FeaturedItem < ActiveRecord::Base
scope :by_country, -> (country) { (country == :all ? where( :stories => { :all_countries => true } ) : where( :stories => { :country_id => country } ) ).joins(:story) }
end
Your scope syntax is currently wrong, as is your pluralization of the belongs_to association.
You'll need to use the following (#swards answer is right, this is just an addition):
#app/models/story.rb
class Story < ActiveRecord::Base
belongs_to :country
scope :countries, ->(ids = :all) { ids == :all ? where(all_countries: true) : find(ids) }
end
This will allow you to call Story.countries to return all countries, and Story.countries(1,2,4,5) to return individual ones.
filter stories on my index based on 2 different conditions where one is for the Current Country and the other one is for All Countries.
Have you considered using the following in your Country model:
#stories = #country ? #country.stories : Country.stories
#app/models/country.rb
class Country < ActiveRecord::Base
has_many :stories
scope :stories, -> { joins(:stories).where(story: {all_countries: true}) }
end
I have a class for a child
class Child < BaseModel
attr_protected
has_many :child_parent_relationships, :dependent => :destroy
has_many :child_daycare_relationships, :dependent => :destroy
has_many :child_class_relationships, :dependent => :destroy
has_many :parent_users, :through => :child_parent_relationships
has_many :attendance_records
has_many :moods
has_many :behaviors
validates :first_name, :presence => true
end
When I get the child Child.find(id) it returns all of the has_many relations. How do I return the child but then limit the relations of say the mood table by a field value like date?
You can do this a couple ways.
If you have a child variable
#child = Child.find(id)
You can add scopes to Mood and Behaviors, or where clauses. So you ask for something like
#child.moods.where(field: "value")
or
class Behavior < ActiveRecord::Base
scope :filtered, -> { where(field: "value") }
end
# Use scopes like so
#child.behaviors.filterd
To use a date in a scope, it would be something like this
scope :on_date, -> (date) { where field: date }
scope :before_date, -> (date) { where("behaviors.field < ?", date) }
you can also set up has many relationships to prefilter
class Child < ActiveRecord::Base
has_many :specific_moods, -> { where(field: "value" }, class_name: "Mood"
has_many :certain_behaviors, -> { where(field: "value" }, class_name: "Behavior"
end
Then you can use this in your views:
#child.specific_moods
#child.certain_behaviors
Just append the conditions you need.
Child.find(id).moods.where(field: "value")
I have a search page that narrows down the list of a specific class, and I want an OR condition that can grab two different conditions and add the together, for example, I have classes
model/party.rb
class Party < ActiveRecord::Base
has_many :invitations
end
mode/invitation.rb
class Invitation < ActiveRecord::Base
belongs_to :party
end
invitation has a status attribute, which will be "decline", "accept", or "unanswered"
What I want to do is grab all the parties that do not have any invitations, or any that have all of the invitations "unanswered".
I currently do
scope :not_confirmed, lambda { find_by_sql( "SELECT * FROM `parties` INNER JOIN `invitations` ON `invitations`.`party_id` = `parties`.`id` WHERE (invitations.status = 'unanswered') OR (parties.id NOT IN (SELECT DISTINCT(party_id) FROM invitations))" ) }
which works, but since it does not lazy load I can't add them in a facet like query.
I did something like
no_invitations.or(no_one_has_answered)
but it did not work.
I especially do not get the concept of using OR on AREL, could someone please help out?
edited:
For a very ugly yet functional work around until I get this down, here is what I have done
party.rb
scope :not_confirmed, lambda { joins(:invitations).where( "invitations.status NOT IN (?)", ["accepted", "declined" ] ) }
scope :with_no_invitations, lambda { includes(:invitaions).where( :invitations => { :party_id => nil } ) }
search_controller.rb
#parties = Party.all_the_shared_queries
#parties = ( #parties.not_confirmed + #parties.with_no_invitations).uniq
The query:
scope :not_confirmed, lambda { find_by_sql( "SELECT * FROM `parties` INNER JOIN `invitations` ON `invitations`.`party_id` = `parties`.`id` WHERE (invitations.status = 'unanswered') OR (parties.id NOT IN (SELECT DISTINCT(party_id) FROM invitations))" ) }
can be converted to arel with some transformation using boolean algebra too. But since it is only theoretical conversion, you have to verify it manually. So:
class Invitation < ActiveRecord::Base
belongs_to :party
scope :non_answered, -> { where(arel_table[:status].not_eq('unanswered')) }
end
class Party < ActiveRecord::Base
has_many :invitations
scope :not_confirmed, -> { not.join(:invitaions).merge(Invitation.non_answered)) }
end
Please test it and comment here.
Firstly, from the question tags, I have assumed that you are using Rails3 (had it been Rails4, there were more easy ways of doing things :))
For your requirement above (ie grab all the parties that do not have any invitations, or any that have all of the invitations "unanswered"), here is a way of doing it (using scope :unattended):
Party Model:
class Party < ActiveRecord::Base
has_many :invitations
scope :invitations_answered, -> { joins(:invitations).merge(Invitation.answered) }
scope :unattended, -> { where(arel_table[:id].not_in invitations_answered.pluck(:id)) }
end
Invitation Model:
class Invitation < ActiveRecord::Base
belongs_to :party
scope :answered, -> { where(status: ["decline", "accept"])}
end
In Rails 4, you can use where.not and simplify it further like this:
Party Model:
class Party < ActiveRecord::Base
has_many :invitations
scope :invitations_answered, -> { joins(:invitations).merge(Invitation.answered) }
scope :unattended, -> { where.not(id: invitations_answered.pluck(:id)) }
end
Invitation Model:
class Invitation < ActiveRecord::Base
belongs_to :party
scope :answered, -> { where.not(status: 'unanswered') }
end