post thumbnail

Ruby on Rails desde Cero: ActionController Parte 1

Publicado Por: Alberto Grespan, El 19/12/2013


Detalles del Curso:

Dificultad: Aprendiz

Duración: 20 min


Las series de cursos Ruby on Rails en CodeHero buscan otorgarte los conocimientos necesarios, para que puedas desarrollar tus propias aplicaciones Web. En el capítulo anterior aprendimos como hacer pruebas unitarias, porque las debemos usar, como se preparan y como se usan.

En este nuevo capítulo aprenderemos un poco más sobre la estructura de una aplicación en Rails y configurar nuestra base de datos.


¿Qué es ActionController?

Action Controller como su nombre lo indica es la clase principal relacionada a los Controladores de nuestra aplicación, y componente fundamental en el patrón de arquitectura de software MVC. También es responsable de que las solicitudes hechas por el usuario tengan sentido cuando muestran la información.

Cuando hablamos que ActionController es la clase principal relacionada a los controladores queremos decir que los controladores que nosotros creamos van a heredar de ella y de esta manera nos facilitará el trabajo ya que esta clase tiene una implementación muy pero muy completa.

Convención de nombre.

Ya hemos visto ActiveModel y si recuerdan cuando creábamos un Modelo lo hacíamos utilizando nombres singulares. A diferencia de los modelos el Controlador aboga por una terminología plural, algo como: UsuariosController. Apegándonos a esta terminología estaremos seguros que vamos a poder utilizar las rutas generadas por defecto con los generadores.


Generando controladores

Si no se recuerdan del capítulo de estructura de proyecto de como crear un controlador únicamente, haciendolo mediante scaffold o de manera manual. Aquí te lo recordaremos y ampliaremos un poco las diferentes maneras de lograrlo.

Para crear únicamente un controlador lo podemos realizar de la siguiente manera:

$ rails g controller Publicacion index
      create  app/controllers/publicacion_controller.rb
       route  get "publicacion/index"
      invoke  erb
      create    app/views/publicacion
      create    app/views/publicacion/index.html.erb
      invoke  test_unit
      create    test/controllers/publicacion_controller_test.rb
      invoke  helper
      create    app/helpers/publicacion_helper.rb
      invoke    test_unit
      create      test/helpers/publicacion_helper_test.rb
      invoke  assets
      invoke    coffee
      create      app/assets/javascripts/publicacion.js.coffee
      invoke    scss
      create      app/assets/stylesheets/publicacion.css.scss

Particularmente podemos crear el controlador completo, con vistas, "suite" de pruebas, "assets" y "helpers" cómo también podemos simplemente crear lo que deseemos, mediante el paso de parámetros.

Sin "suite" de pruebas:

$ rails g controller Publicacions index --no-test-framework

Sin vistas:

$ rails g controller Publicacions index --no-template-engine

Sin nada:

$ rails g controller Publicacions index --no-template-engine --no-test-framework --no-assets --no-helper

Si quieren observar cualquier otra opción particular simplemente utilicen el comando -h:

$ rails g controller -h

Métodos y acciones

Debemos recordar del capítulo de vistas dinámicas que para acceder a las vistas de la publicación que creamos, tuvimos que utilizar el controlador publicación y tener tres (3) funciones que hacen juego con el nombre de las vistas. En pocas palabras cuando se realiza una petición a nuestra aplicación el enrutador decide a que método del controlador se le delegará dicha petición y ese método en teoría contiene unas acciones que se ejecutarán para regresarle al usuario una vista particular con la información que solicitó.

Cuando vemos como está conformado un Controlador apreciamos lo siguen:

class PublicacionsController < ApplicationController
  def index
    @publicacion = Publicacion.all
  end
end

Existe una clase llamada PublicacionsController que hereda de la clase ApplicationController y dentro de esta se encuentra (en este caso) un método llamado índex que contiene una acción particular, dicha acción es ir a la base de datos y buscar todas las publicaciones, generando el objeto @publicacion que está disponible en la vista index.html.erb.

Parámetros

Los parámetros son la forma de comunicación entre el usuario y la aplicación. Esto se realiza mediante verbos HTTP, y existen dos tipos de parámetros: Los que pueden ser enviados por el URL en forma de query y el segundo que puede ser referido a los enviados por un POST donde la información puede venir de un formulario de datos.

Los parámetros en Rails se pueden leer de la siguiente manera:

Si queremos buscar por el estado actual un tipo de publicación y utilizando el siguiente parámetro en el URL: /publicacions?estado=publica, realizamos lo siguiente:

def index
  if params[:draft] == "privada"
    @publicacions = Publicacion.where("estado = 'privada'")
  else
    @publicacions = Publicacion.where("estado = 'publica'")
  end
end

Por otro lado si estamos aceptando el contenido de un formulario de publicación generado por Rails, que viene del URL /publicacions/new y será procesado por el método create del controlador PublicacionsController, realizamos lo siguiente:

def new
  @publicacion = Publicacion.new
end

def create
  @Publicacion = Publicacion.new(params[:publicacion])
  if @Publicacion.save
    redirect_to @Publicacion
  else
    render "new"
  end
end

Como Rails trabaja de manera RESTful hay muchos elementos que engranar a la hora de entender como funciona el formulario, ya que puede parecer muy mágica la implementación si no se conoce. El formulario tiene un valor interno en el elemento input del HTML llamado name que contiene una referencia al objeto @publicacion que fue inicializado cuando accedimos por la Ruta /publicacions/new que hace referencia al método new del Controlador Publicacions. Cuando apretamos el botón de enviar formulario se utiliza el método create que lee la información proveniente del objeto @publicacion para luego crearlo en la base de datos o si por algún motivo tiene problemas se reenvía al usuario de vuelta a la página publicacions/new


Conclusión.

En esta lección comenzamos a adentrarnos en los detalles de los controladores de Rails, más específicamente en como se generan, cuales son unas de las opciones que podemos asignarles, como están conformados y como leer cierto tipo de parámetros. El próximo capítulo seguiremos ampliando conocimiento dentro de los demás tipos y formatos de parámetros que podemos enviar y veremos nuevos aspectos de seguridad en cuanto a la prohibición de asignación masiva. Siéntanse libres en consultar cualquier duda a través de los comentarios.

¡Hasta el próximo capítulo!


¿Te ha gustado esta publicación?

Compártela:

Por Alberto Grespan

Conoce más sobre este autor aquí


comments powered by Disqus