Rails 2: has_many: grâce à la validation?

Question

Rails 2.1.0 (Ne peut pas mettre à jour pour l'instant en raison de plusieurs contraintes) Je suis en train d'y parvenir. Tous les conseils?

1. Un projet a de nombreux utilisateurs se joignent par modèle
2. Un utilisateur a de nombreux projets rejoignent par modèle
3. class Admin hérite classe User. Il a aussi des choses spécifiques d'administration.
4. Admin comme héritage pour superviseur et opérateur
5. Projet a un administrateur, un superviseur et de nombreux opérateurs.

Maintenant, je veux 1. soumettre des données pour le projet, administrateur, superviseur et opérateur en une seule forme de projet 2. valider tous et montrer des erreurs sur la forme du projet.

Project has_many :projects_users ; has_many :users, :through => :projects_users
User has_many :projects_users ; has_many :projects, :through => :projects_users
ProjectsUser = :id integer, :user_id :integer, :project_id :integer
ProjectUser belongs_to :project, belongs_to :user
Admin < User # User has 'type:string' column for STI
Supervisor < User
Operator < User

est la bonne approche? Et toutes les suggestions sont les bienvenus.

Answer 1

J'ai fini en utilisant des attributs virtuels pour admin, superviseur et opérateurs tout le reste est passé par les associations ORM

Answer 2

Je suppose que seul le tableau Inberitance et les formes imbriquées peuvent vous aider. Vous pouvez wanna lire à ce sujet à la documentation. http://api.rubyonrails.org/classes/ActiveRecord/Base.html

Answer 3

Je me suis dit la réponse réside dans l'héritage de table unique avec has_many: par

class Project < ActiveRecord::Base
  has_many :projects_users, :dependent => :destroy
  has_many :users, :through => :projects_users, :dependent => :destroy
  has_one :admin, :through => :projects_users, :source => :user, :conditions => {:type => "Admin"}
  has_one :supervisor, :through => :projects_users, :source => :user, :conditions => {:type => "Supervisor"}
  has_many :operators, :through => :projects_users, :source => :user, :conditions => {:type => "Operator"}
  validates_presence_of :name
  validates_associated :admin

  def admin_attributes=(attributes)
    # build an admin object and apply to this relation
  end

  def supervisor_attributes=(attributes)
    # build a supervisor object and apply to this relation
  end

  def operator_attributes=(operator_attributes)
    operator_attributes.each do |attributes|
      # build an operator object for each set of attributes and apply to this relation
    end
  end
end

class User < ActiveRecord::Base
  has_many :projects_users, :dependent => :destroy
  has_many :projects, :through => :projects_users, :dependent => :destroy
  validates_presence_of :name
  validates_associated :projects
end

class ProjectsUser < ActiveRecord::Base
  belongs_to :project
  belongs_to :user
end

class Admin < User
end

class Supervisor < User
end

class Operator < User
end

Maintenant, nous pouvons avoir les éléments suivants

project1.users # User objects for admin, supervisor and operators
project1.admin # User object for Admin
project1.supervisor # User object for Supervisor
project1.operators # User objects for Operator

Une forme complexe, y compris tous ceux-ci peuvent avoir

<% form_for :project ...
    <% fields_for "project[admin_attributes]", @project.admin do |admin_form|
    ...
    <% @project.operators.each do |operator| %>
        <% fields_for "project[operator_attributes][]", operator do |operator_form| %>

et ainsi de suite ...