Rails 2: Has_Many: Através da validação?

Question

Rails 2.1.0 (não é possível atualizar por enquanto devido a várias restrições), estou tentando conseguir isso. Alguma dica?

1. Um projeto tem muitos usuários através do modelo de junção
2. Um usuário tem muitos projetos através do modelo de ingresso
3. A classe de administrador herda a classe de usuário. Ele também tem algumas coisas específicas do administrador.
4. Administrador como herança para supervisor e operador
5. O Project tem um administrador, um supervisor e muitos operadores.

Agora quero 1. Enviar dados para projeto, administrador, supervisor e operador em um único projeto de projeto 2. Validar tudo e mostrar erros no formulário do projeto.

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

A abordagem está correta? Todas e quaisquer sugestões são bem vindas.

Answer 1

Acabei usando atributos virtuais para administrador, supervisor e operadores, tudo o mais passou por associações ORM

Answer 2

Eu acho que a inberitância de mesa única e formas aninhadas podem ajudá -lo aqui. Você pode querer ler sobre isso na documentação. http://api.rubyonrails.org/classes/activerecord/base.html

Answer 3

Eu descobri que a resposta está em herança de mesa única com has_many: através

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

Agora podemos ter o seguinte

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

Uma forma complexa, incluindo tudo isso pode ter

<% 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 assim por diante...