Rails 2: has_many: durante la convalida?

Question

Rails 2.1.0 (Non è possibile aggiornare per il momento a causa di diversi vincoli) Sto cercando di raggiungere questo obiettivo. Eventuali suggerimenti?

1. Un progetto ha molti utenti attraverso uniscono modello
2. Un utente ha molti progetti attraverso uniscono modello
3. class Admin eredita Classe utente. Essa ha anche un po 'di cose specifiche Admin.
4. Admin come eredità per Supervisore e Operatore
5. Progetto ha un amministratore, un supervisore e molti operatori.

Ora voglio 1. inviare i dati per progetto, admin, supervisore e operatore in una singola forma di progetto 2. convalidare tutti e mostrare gli errori sul modulo del progetto.

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

è l'approccio corretto? Qualsiasi e tutti i suggerimenti sono i benvenuti.

Answer 1

Ho finito per usare gli attributi virtuali per admin, supervisore e gli operatori tutto il resto è andato attraverso le associazioni ORM

Answer 2

Credo Single Table Inberitance e forme annidate possono aiutarti qui. Si può desiderare di leggere su di esso la documentazione. http://api.rubyonrails.org/classes/ActiveRecord/Base.html

Answer 3

ho capito la risposta sta nella tabella di ereditarietà singola con has_many: attraverso

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

Ora possiamo avere la seguente

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

Una forma complessa compreso tutte queste cose possono avere

<% 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| %>

e così via ...