ruby-on-rails - generate - ruby on rails tutorial

¿Tipos de modelos y clasificación en Rails?

Question

Esto es algo en lo que he estado estancado desde hace un tiempo, y tengo que disculparme por adelantado por entrar en tantos detalles para un problema tan simple. Solo quiero dejar en claro lo que estoy tratando de hacer aquí.

Guión

Entonces, hay un modelo Foo, cada Foo puede ser rojo, verde o azul. Tener URL como /reds para enumerar todos los objetos rojos, y /reds/some-red-object para mostrar un determinado objeto. En esa vista de "mostrar", debería haber enlaces próximos / anteriores, que esencialmente "encontrarían el siguiente RedFoo en orden alfabético, y una vez en el último RedFoo, el siguiente registro debería ser el primer GreenFoo, continuando en orden alfabético, y así en".

Intenté implementar esto de varias maneras y, en general, terminé en una barricada en alguna parte. Lo logré trabajando en su mayor parte con herencia de mesa única, teniendo algo como esto:

class Foo < ActiveRecord::Base
class RedFoo < Foo
class GreenFoo < Foo
class BlueFoo < Foo

Los modelos y controladores de cada subclase son idénticos, simplemente reemplace los nombres de los modelos. Entonces los controladores se ven algo así como:

class RedFoosController < ApplicationController
  def index
    @foos = RedFoo.find(:all, :order => "title ASC")

    respond_to do |format|
      format.html { render :template => ''foos/index''}
      format.xml  { render :xml => @foos }
    end
  end

  def show
    @foo = RedFoo.find(params[:id])

    respond_to do |format|
      format.html { render :template => ''foos/show''}
      format.xml  { render :xml => @foo }
    end
  end

  def new
    @foo = RedFoo.new

    respond_to do |format|
      format.html { render :template => ''foos/new''}
      format.xml  { render :xml => @foo }
    end
  end

  def edit
    @foo = RedFoo.find(params[:id])

    respond_to do |format|
      format.html { render :template => ''foos/edit''}
    end
  end

  def create
    @foo = RedFoo.new(params[:foo])

    respond_to do |format|
      if @foo.save
        flash[:notice] = ''Foo was successfully created.''
        format.html { redirect_to(@foo) }
        format.xml  { render :xml => @foo, :status => :created, :location => @foo }
      else
        format.html { render :action => "new" }
        format.xml  { render :xml => @foo.errors, :status => :unprocessable_entity }
      end
    end
  end

  def update
    @foo = RedFoo.find(params[:id])

    respond_to do |format|
      if @foo.update_attributes(params[:foo])
        flash[:notice] = ''Foo was successfully updated.''
        format.html { redirect_to(@foo) }
        format.xml  { head :ok }
      else
        format.html { render :action => "edit" }
        format.xml  { render :xml => @foo.errors, :status => :unprocessable_entity }
      end
    end
  end

  def destroy
    @foo = RedFoo.find(params[:id])
    @foo.destroy

    respond_to do |format|
      format.html { redirect_to(foos_url) }
      format.xml  { head :ok }
    end
  end
end

Los modelos solo contienen métodos para siguiente / anterior, que funcionan bien, sorprendentemente.

class RedFoo < Foo
  def next
    if self == RedFoo.find(:all, :order => "title ASC").last
      GreenFoo.find(:all, :order => "title ASC").first
    else
      RedFoo.find(:first, :conditions => ["title > ?", self.title], :order => "title ASC")
    end
  end

  def previous
    if self == RedFoo.find(:all, :order => "title ASC").first
      BlueFoo.find(:all, :order => "title ASC").last
    else
      RedFoo.find(:first, :conditions => ["title < ?", self.title], :order => "title DESC")
    end
  end
end

Problema

Por alguna razón, cuando intento crear y editar registros, ninguno de los atributos se guarda en la base de datos. Simplemente agrega un nuevo registro con columnas completamente vacías, independientemente de lo que haya rellenado el formulario. No se devuelve ningún error en la secuencia de comandos / salida del servidor o en los archivos de registro. Sin embargo, desde el script / consola, todo funciona perfectamente bien. Puedo crear nuevos registros y actualizar sus atributos sin problema.

También es un mal olor de código que tengo mucha duplicación de código en mis controladores / modelos (están usando las mismas vistas que el modelo base, así que está bien). Pero creo que eso es inevitable aquí a menos que use algo de meta-bondad.

Cualquier consejo o sugerencia para abordar este problema de grabación de registros sería genial, pero la razón por la que publiqué mi configuración en detalle es porque tengo la sensación de que probablemente estoy haciendo todo esto de la manera equivocada. Entonces, estoy abierto a otros enfoques si conoces algo más práctico que usar STI. Gracias.

Actualizar

Los parámetros hash se ven a la derecha:

{"commit"=>"Create", "authenticity_token"=>"+aOA6bBSrZP2B6jsDMnKTU+DIAIkhc8fqoSicVxRJls=", "red_foo"=>{"title"=>"Hello world!"}}

Pero @ foo.inspect devuelve el siguiente objeto RedFoo (todo nulo, excepto el tipo):

#<RedFoo id: nil, title: nil, type: "RedFoo", created_at: nil, updated_at: nil>

Answer 1

Correcto, entonces @ foo.inspect te da "nil" en el registro?

Lo que quiero decir (si no fuera lo suficientemente claro) fue:

def create
@foo = RedFoo.new(params[:foo])
logger.error "******************* foo: #{@foo.inspect} **************"
respond_to do |format|  
  if @foo.save
  ...

Si haces eso y rastreas tu registro, puedes averiguar fácilmente qué está pasando con foo y compararlo con el hash de params entrantes.

De hecho, esa también sería una información útil, ¿qué es hash params?

Answer 2

Debo admitir que la forma en que voy sobre STI es usar set_table_name dentro de un modelo.

p.ej

class RedFoo < AR::Base
  set_table_name "foos"
  include FooModule
  extend FooClassModule # for self methods

  def next; ...; end
end

Pero de todos modos, para esta situación, ¿qué dice tu registrador cuando haces un @ foo.inspect justo antes de guardar, y también qué es el SQL que se ejecuta en insert / update?

Answer 3

Por favor, eche un vistazo a la sección llamada "herencia de tabla única" en esta página y avísenos si resuelve su problema.

Answer 4

El problema es el params

:red_foo

es el nombre de los params en la vista, mientras que usted usa

params[:foo]

en el controlador, creo que la mejor manera sería usar: foo, en la vista usando text_field_tag ​​en lugar de cualquiera (lo que supongo que puede ser) form builders text_field.

Puedes salir del olor del controlador usando un módulo para hacer las cosas básicas, ya que supongo que la mayoría de las cosas nuevas / crear / editar / actualizar / destruir son las mismas

O

puede mapear todas las rutas a un controlador foo y usar algún tipo de parámetro, ya sea pasado desde la ruta, o mediante el análisis URI para obtener el foo rojo / verde / azul