Utilisateurs et groupes de plusieurs à plusieurs, mais les groupes ont des propriétaires

Question

J'ai du mal à comprendre ce qui se passe. J'essaie de créer une relation qui le permette :

• l'utilisateur peut appartenir à plusieurs groupes
• le groupe peut avoir plusieurs utilisateurs
• un groupe a un propriétaire qui est un utilisateur
• la propriété du groupe peut être transférée

J'ai mis en place la relation de plusieurs à plusieurs, mais je n'arrive pas à comprendre comment mettre en place la fonctionnalité de propriété.

Voici ce que j'ai jusqu'à présent dans mes modèles :

    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

Toute aide serait grandement appréciée !

Answer 1

Vous pouvez le mettre en place de plusieurs façons :

1) Utiliser un modèle de jointure et placer un indicateur sur le modèle de jointure qui spécifie que le membre du groupe est un propriétaire.

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) Conservez votre HABTM existant et ajoutez un autre modèle de jointure pour le suivi de la propriété.

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

Je pense qu'une solution pourrait consister à définir un nouveau belongs_to du groupe au propriétaire. Vous devez donc ajouter un nouveau user_id dans la colonne groups table.

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

Je pense que c'est ce dont vous avez besoin. Avec un utilisateur, vous pouvez avoir tous les groupes dont il est membre avec user.groups et vous pouvez avoir tous les groupes qu'il possède user.owned_groups . Avec un groupe, vous pouvez avoir son propriétaire : group.owner et tous ses membres : group.users .

Si vous souhaitez changer de propriétaire, il vous suffit de faire group.owner = new_user con new_user commencer un User instance

Notez que j'ai rapidement choisi des noms pour les clés d'association et les clés étrangères, mais vous pouvez bien sûr les personnaliser.

Answer 3

Qu'en est-il de l'approche du tableau de correspondance ?

En effet, si vous disposez d'une table de liens vers les utilisateurs et les groupes (users_groups), vous pouvez stocker un nouvel attribut dans cette table au moment où un utilisateur et un groupe appartiennent l'un à l'autre.

Par exemple, lorsque l'utilisateur John appartient à un groupe de garçons, il est méchant. Lorsque l'utilisateur John appartient au groupe des ingénieurs, il est intelligent. Ainsi, dans la table users_groups, je peux stocker quelque chose comme ci-dessous.

Utilisateurs

id | Name
1 | John
2 | Steve

Groupes

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

Groupes d'utilisateurs

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

N'est-ce pas amusant ? Mais oui, nous devons travailler sur le Has et appartient à de nombreuses relations. Mais ce n'est qu'une idée !

VIENT DE MENTIONNER L'AVANTAGE D'AVOIR UN TABLEAU DE LIENS. La MISE EN ŒUVRE de est prise en charge par Sean Hill dans sa réponse.

Answer 4

Dans votre modèle d'utilisateur, ajoutez un champ booléen comme propriétaire, de sorte que lors de la création de l'utilisateur, vous puissiez déterminer s'il est le propriétaire ou non.
Ainsi, si vous souhaitez vérifier le groupe, vous pouvez procéder comme suit.

group.users.each do |u|
u.propriétaire ?
// la logique va ici
fin