post thumbnail

Ruby on Rails desde Cero: ActiveRecord Validaciones

Publicado Por: Ricardo Sampayo, El 20/09/2013


Detalles del Curso:

Dificultad: Aprendiz

Duración: 20 min


Hemos habilitado un repo en GitHub para que puedas descargar el código de esta entrada:

Échale un vistazo aquí.

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 estudiamos a detalle muchas de las funcionalidades que nos da ActiveRecord para manejar nuestra base de datos de forma eficiente en Rails, pero aún nos quedan las validaciones que éste nos ofrece.

En este nuevo capítulo estudiaremos las validaciones que nos ofrece Rails con ActiveRecord, tema importante que nos ayuda garantizar los datos que almacenamos en la base de datos de forma más segura.


¿Por qué utilizar validaciones?

Las validaciones se utilizan para garantizar que los datos que se están guardando en la base de datos sean los correctos con el formato que nosotros establezcamos desde un principio. Por ejemplo, puede ser importante para una aplicación guardar el correo electrónico de forma correcta, aunque con estos métodos no validamos que el correo le pertenezca a nuestro usuario, podemos por medio de un formulario exigir el campo obligatoriamente y que además éste cumpla con el formato de un correo electrónico.

Como probablemente ya sepan hay otras maneras de validar la información de los objetos que se almacenan en la base de datos, como lo son las validaciones del lado del cliente (JavaScript: Útiles pero poco fiables), validaciones a nivel de controlador (por lo general se vuelven difíciles de manejar, probar y mantener) o las validaciones nativas en base de datos (Se establece una fuerte dependencia del manejador de base de datos, haciendo difícil el mantenimiento y la adaptabilidad de nuestras aplicaciones)


Validaciones

Entrando de una vez en materia para nuestro curso desarrollaremos todo el ejemplo para ver la magia de los validadores de ActiveRecord.

Preparación de nuestro modelo

Lo primero que debemos hacer para que Rails reconozca nuestras validaciones, es adaptar nuestros modelos indicándoles a cada uno de los atributos el tipo de validación que necesita. Algunos de los tipos de validadores que nos ofrece Rails son:

Confirmación confirmation

Validación que utilizamos cuando queremos que el usuario confirme la información que nos este suministrando.

Formato format

Este tipo de validación verifica que la información del usuario concuerde con una expresión regular que se especifica con la función :with

Tamaño o longitud length

Este tipo de asistente juega con la longitud de los datos suministrados por el usuario, para que se verifique según nuestras necesidades.

Valor nulo o vacío presence

Este asistente de validación nos verifica si el atributo del modelo puede ser nulo.

Numérico numericality

Este asistente verifica que el atributo sólo sea numérico

Único uniqueness

Este último asistente que estudiaremos, por el momento, nos verifica justo antes de guardar en la base de datos que nuestro objeto no este repetido, es decir, que sea único.

Ahora, luego de haber descrito muy brevemente algunos de los validadores que nos ofrece Rails veamos un ejemplo donde usaremos algunos de estos atributos.

class Persona < ActiveRecord::Base
  # Confirmamos el email y validamos que no sean vacios con presence
  # mostramos el mensaje de error con message
  validates :email , presence: true , confirmation: true
  validates :email_confirmation, presence: { message: " es requerido"}

  # Validamos en una expresion regular nuestro email
  VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
  validates :email, format: { :with => VALID_EMAIL_REGEX , message: "El formato del correo es invalido" }

  # Validamos que el identificador tenga entre 8 a 12 caracteres
  validates :identificador, length: { in: 8..12 , message: "debe tener entre 8 y 12 caracteres"}

  # Validamos que el identificador solo sea numerico
  validates :identificador, numericality: { only_integer: true }

  # Validamos que el email sea unico
  validates :email, uniqueness: {case_sensitive: false ,message: "ya esta registrado"}
end

Como seguramente hemos visto en el ejemplo, una serie de opciones que le dan forma a las validaciones, como el mensaje: que nos da el error que queremos mostrar cuando no se cumpla la condición.

Preparación del controlador y vista

Una vez creado el modelo creamos nuestros controladores para generar, recibir y procesar la información ingresada por el usuario. El controlador que realizaremos para este ejemplo sólo consta de dos métodos: index que carga la lista de personas ya almacenadas y nos mostrará un formulario para cargar la información y create simplemente recibe la información del formulario y la procesa. Veamos esto en código.

def index
  # Crea una persona nueva para cargarla con informacion
  @nuevo_usuario = Persona.new
   # Carga todas las personas de base de datos
  @usuarios    = Persona.all
end

def create
  # Recibe y crea una persona con los datos del formulario
  @nuevo_usuario = Persona.new(params[:nuevo_usuario].permit(:nombre, :email,:identificador, :telefono,:sexo,:email_confirmation))
  @usuarios    = Persona.all

  # intenta guardar en base de datos
  if @nuevo_usuario.save
    #si tiene exito nos lleva al index
    redirect_to validation_path
  else
    # si no carga nuevamente la vista con los errores a corregir
     render action: 'index'
  end
end

Por último creamos nuestro formulario donde cargaremos la información.

<%=  form_for :nuevo_usuario, url: validation_create_path  do |f| %>
  <% if @nuevo_usuario.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(@nuevo_usuario.errors.count, "error") %> error antes de guardar:</h2>

      <ul>
      <% @nuevo_usuario.errors.full_messages.each do |msg| %>
        <li><%= msg %></li>
      <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= f.label :nombre %><br>
    <%= f.text_field :nombre %>
  </div>
  <div class="field">
    <%= f.label :email %><br>
    <%= f.text_field :email %>
  </div>
    <div class="field">
    <%= f.label :email_confirmation %><br>
    <%= f.text_field :email_confirmation %>
  </div>
    <div class="field">
    <%= f.label :identificador %><br>
    <%= f.text_field :identificador %>
  </div>
  <div class="field">
    <%= f.label :sexo %><br>
    <%= f.text_field :sexo %>
  </div>
  <div class="field">
    <%= f.label :telefono %><br>
    <%= f.text_field :telefono %>
  </div>
  <div class="actions">
    <%= f.submit %>
  </div>
<% end %>

Como ven en la imagen se puede dividir en dos partes: la parte superior consta del manejo de errores, es donde se obtiene el objeto, se verifica si contiene errores y los muestra en una lista; y por último la parte inferior es nuestro formulario.

Veamos cómo nos muestra Ruby on Rails los errores en el formulario que acabamos de crear (obviamente se pueden editar los estilos para mostrar una mejor presentación).

codigo


Conclusión

En esta lección aprendimos cómo crear un formulario y validarlo en el servidor antes de almacenarlo en nuestra base de datos. También vimos algunos de los tipos de validadores que ActiveRecord nos provee y estudiamos la importancia de este tema.

Una vez más te recomiendo echarle un vistazo a la serie completa de Ruby desde cero, así como a las otras series de CodeHero, agradeciendo de antemano todas sus dudas y comentarios en la sección de comentarios.

¡Hasta el próximo capítulo!


¿Te ha gustado esta publicación?

Compártela:

Por Ricardo Sampayo

Conoce más sobre este autor aquí


comments powered by Disqus