Simolification de code

Community FR
1

Bonjour je voudrais savoir si je peux simplifier mon code.
J’ai les modèles suivants :
user (has_many :roles)
room (has_many :roles)
role has_many :users, :rooms
La table role contenant, en plus des clés étrangères, le code role
(admin, simple utilisateur, …)

Pour rechercher tous les administrateurs d’une salle, j’ai écrit une
methode dans le modèle utilisateur qui va chercher dans la table role
les enregistrements pour lesquels le code_role est admin pour la salle
spécifiée en paramètre.
et ensuite je boucle sur ces roles pour aller récupérer les users
correspondant.
Cela donne le code suivant mais je me demande s’il n’y a pas plus
simple comme code

def self.find_admins_of(room)
roles = Role.find_admins_by(room.id)
admins = []
for role in @roles
admins << find(role.user_id)
end
admins
end

2

Peut-être faire :

class Room < AR::B
…
has_many :roles
has_many :admins, :through => :roles, :conditions => [“code_role = ?”,
“admin”]
…
end

Après tu devrais pouvoir faire directement
Room.find(room_id).admins

–
Michel B.

3

Merci pour ta réponse Michel.
C’est une bonne idée car ça me remplace la méthode
Role.find_admins_by(room.id) que j’ai écrite, par contre est ce que je
peux simplifier la boucle qui me permet ensuite de récupérer les
utilisateurs à partir des roles.

Nicolas

On Aug 26, 2:38 pm, “Michel B.” [email protected]

4

Déjà pour commencer une petite correction de ce que j’ai envoyé hier
soir,
il en manquait un bout :
class Room < AR::B
…
has_many :roles
has_many :admins, :through => :roles, :source => :user, :conditions =>
[“code_role = ?”, “admin”]
…
end

En assumant bien entendu que le modèle Role ressemble à :

class Role < AR::B
…
belongs_to :room
belongs_to :user
…
end

Ensuite tu fais donc :
Room.find(room_id).admins
Et tu obtiens en réponse la liste des users admin (et non pas des rôles
admin).

Sinon, si tu tiens vraiment à passer par la liste des rôles de la salle,
tu
peux faire aussi :

class Role < AR::B
…
named_scope :admin, :conditions => [“code_role = ?”, “admin”]
named_scope :with_user, :include => :user
…
end

Ce qui permet ensuite de faire :

Role.admin.with_user.find_by_room_id(room_id).collect { |role| role.user
}

Ca peut avoir l’avantage d’être plus modulable si tu commence à faire du
polymorphisme (mettons que tu attaches autre chose que des salles aux
rôles)
:

class Role < AR::B
…
belongs_to :rolable, :polymorphic => true
named_scope :admin, :conditions => [“code_role = ?”, “admin”]
named_scope :with_user, :include => :user
…
end

class Room < AR::B
…
has_many :roles, :as => :rolable
…
end

class Computer < AR::B
…
has_many :roles, :as => :rolable
…
end

Tu pourrais ensuite faire des choses comme ça :
Role.admin.with_user.find_by_rolable(rolable).collect { |role| role.user
}

–
Michel B.

5

Super!

Merci pour cette réponse détaillée.

Nicolas