Utenti e gruppi molti a molti, ma i gruppi hanno proprietari

Question

Ho difficoltà a cercare di capire/avvolgere il mio cervello intorno a questo. Sto cercando di creare un rapporto che permette questo: utente

• può appartenere a molti gruppi
• gruppo può avere molti utenti
• un gruppo ha un proprietario che è un utente di proprietà
• gruppo può essere trasferito

Ho la relazione molti-a-molti impostata, ma non riesco a capire come impostare la funzionalità di proprietà.

Ecco quello che ho finora nei miei modelli:

class Group < ActiveRecord::Base 
     has_and_belongs_to_many :users 
     attr_accessible :name, :description, :isPublic, :tag_list, :owner 
    end 

    class User < ActiveRecord::Base 
     has_and_belongs_to_many :groups 
     attr_accessible :name, :description, :owner_id 
    end 

Qualsiasi aiuto sarebbe molto apprezzato !!

Answer 1

È possibile impostare fino un paio di modi:

1) Utilizzare un modello di unirsi e mettere una bandiera sul modello di unirsi che specifica che il membro del gruppo è un proprietario.

class Group < ActiveRecord::Base 
    has_many :memberships 
    has_many :users, through: :memberships 
    attr_accessible :name, :description, :isPublic, :tag_list, :owner 
end 

class Membership < ActiveRecord::Base 
    belongs_to :group 
    belongs_to :user 

    #this table has a flag called owner and thus a method called owner? 
end 

class User < ActiveRecord::Base 
    has_many :memberships 
    has_many :groups, through: :memberships 
    attr_accessible :name, :description, :owner_id 
end 

2) Conserva il tuo HABTM esistente e aggiungi un altro modello di join per il monitoraggio della proprietà.

class Group < ActiveRecord::Base 
    has_and_belongs_to_many :users 
    has_many :group_ownerships 
    has_many :owners, through: :group_owernships, class_name: "User" 
    attr_accessible :name, :description, :isPublic, :tag_list, :owner 
end 

class GroupOwnership < ActiveRecord::Base 
    belongs_to :group 
    belongs_to :user 
end 

class User < ActiveRecord::Base 
    has_and_belongs_to_many :groups 
    has_many :group_ownerships 
    has_many :owned_groups, through: :group_owernships, class_name: "Group" 
    attr_accessible :name, :description, :owner_id 
end 

Answer 2

Penso che una soluzione potrebbe essere quella di definire una nuova relazione belongs_to dal gruppo al proprietario. Quindi è necessario aggiungere una nuova colonna user_id nella tabella groups.

class Group < ActiveRecord::Base 
    has_and_belongs_to_many :users 
    belongs_to :owner, class_name: 'User', foreign_key: 'user_id' 
    attr_accessible :name, :description, :isPublic, :tag_list, :owner 
end 

class User < ActiveRecord::Base 
    has_and_belongs_to_many :groups 
    has_many :owned_groups, class_name: 'Group', foreign_key: 'user_id' 
    attr_accessible :name, :description, :owner_id 
end 

Penso che sia quello che ti serve. con un utente, puoi avere tutti i gruppi con cui è membro con user.groups e puoi avere tutti i gruppi che possiede user.owned_groups. Con un gruppo, puoi avere il suo proprietario: group.owner e tutti i suoi membri: group.users.

Se si desidera cambiare il proprietario solo fare group.owner = new_user con new_user iniziare un User esempio

Si noti che ho subito raccolto chiamato per le chiavi di associazione e stranieri, si potrebbe naturalmente personalizzare questo.

Answer 3

E l'approccio tabella di collegamento?

Perché, se si dispone di una tabella di collegamento per utenti e gruppi come gruppi di utenti, è possibile memorizzare un altro nuovo attributo in quella tabella nel momento in cui un utente e un gruppo appartengono l'uno all'altro.

Come quando, l'utente John appartiene ai ragazzi del gruppo, è cattivo. Quando John l'utente appartiene agli ingegneri del gruppo, è intelligente. Quindi, nella tabella users_groups, posso memorizzare qualcosa come sotto.

Utenti

id | Name 
1 | John 
2 | Steve 

Gruppi

id | Name 
1| boys 
2| doctors 
3| beggars 

Users_Groups

user_id | group_id | info 
1  | 1  | "naughty" 
1  | 2  | "wearing white coat" 
1  | 3  | "broke" 
2  | 1  | "liar" 

non è questo divertente ?. Ma sì, dobbiamo lavorare sull'Ha e fare parte di molte relazioni. Ma solo un pensiero!

BASATO SOLO IL VANTAGGIO DI AVERE UNA TABELLA DI COLLEGAMENTO. IMPLEMENTAZIONE di che è curato da Sean Hill nella sua risposta.

Answer 4

Nel modello utente aggiungere un campo booleano come proprietario, quindi durante la creazione dell'utente è possibile assegnare se è il proprietario o meno.
Quindi, se vuoi controllare il gruppo, puoi farlo come di seguito.

group.users.each do | u |
u.owner?
// logica va qui
fine