Manipular el patrón MVC

Manipular el patrón MVC

Para generar o abordar cierto tipo de información de forma rápida, escribimos el comando:

rails g *model Nombre atributo1:string atributo2:string*

💎 El comando rails g nos permitirá generar estructuras prediseñadas y le vamos a pasar qué tipo estructura queremos generar y el nombre de la estructura. Luego vamos a introducir los atributos junto a su tipo de dato.

Cuando ejecutemos este comando se van a generar dos archivos, uno es un archivo de la tabla que creamos para la DB y el otro es del modelo.

Este es el archivo que creo en el modelo, como podemos ver está heredando de una clase que se llama ApplicationRecord, la cual se encarga de indicarle a Rails que la clase hija se trata de un modelo.

# pet.rb
class Pet < ApplicationRecord
end

En la carpeta db → migrate se encuentra el archivo que contiene la tabla que creamos para la base de datos.

# 7274580843_create_pets.rb

class CreatePets < ActiveRecord::Migration[6.0]
  def change
    create_table :pets do |t|
      t.string :name
      t.string :breed

      t.timestamps
    end
  end
end

Para pasar información desde Rails a las vistas, para esto debemos cambiar la extensión de nuestro archivo html a uno que le indique que dentro se va renderizar código Ruby.

# hello.html.erb

Si quieres añadir el contenido de una variable de ruby debemos utilizar:

Hola <%= @nombre %>

Recuerda que después de generar el modelo debemos escribir este comando para que termine el proceso.

rails db:migrate

Con el siguiente comando vamos a poder entrar a un contexto de interacción dinámica con la cual podemos crear una instancia nueva y que está se guarde en la DB.

rails console

Para introducir un nuevo registro en la DB vamos a poner lo siguiente:

Pet.create name: 'Arnold', bread: 'poodle'

Mi solución:

Introducción de Model

En este caso se usarán objetos que representen una mascota, con los atributos nombre y raza. Los objetos creados serán guardados en una base de datos, donde las columnas son los atributos y las filas los registros.

Para generar información de forma rápida Rails nos provee del comando rails g (rails generate), este comando permite utilizar estructuras prediseñadas para generar el model.

rails g <estructura> <nombre>:<tipo> <atributos>:<tipo>
rails g model Pet name breed:string breed:string

Cuando se ejecuta este comando se crean dos archivos, uno dentro de la carpeta db>migrate que en su nombre tiene una marca de tiempo seguido de create y el nombre del model que se creó. Y el otro archivo dentro de la carpeta app>models llamado como el modelo (pet.rb).

Al abrir el archivo pet.rb, se observa que se creo una clase llamada Pet, que hereda de ApplicationRecord, de esta forma se le indica a Rails que se trata de un model.

Por otro lado, el archivo creado en db>migrate contiene una clase llamada CreatePets, que le indica al sistema que se esta creando una tabla llamada Pets que interactúa directamente con la base de datos

Se podría decir que el concepto de Model está dentro del mundo de Ruby, y por otra parte se encuentra la base de datos. Dentro del archivo pet.rb se aprecia el concepto de model y dentro del archivo en db>migrate se aprecia el concepto de la base de datos.

Lo que se está haciendo con estos archivos es una equivalencia del mundo de Ruby, con un mapeo de la clase pet, a el mundo de la base de datos, creando una tabla llamada pets.

Acceder a la información

Para pasar información desde un model hacía una vista se utiliza un nuevo concepto, llamado variable de instancia.

Para definir una variable de instancia se utiliza el @ seguido del nombre.

@variable = 'Hello world'

Para pasar esta variable creada en el controlador, hacía una vista se debe utilizar una convención específica para poder pasar la información desde el controlador a la vista.

Esta convención es que la vista debe tener la extensión erb pero añadiéndolo despues de la extensión HTML, de esta forma se le indica a Rails que dentro se va a renderizar código Ruby.

hello.html.erb

De esta forma se le indica al sistema que antes de renderizar el html se tiene que renderizar código Ruby.

Para acceder a la variable de instancia desde la vista ya con la extensión erb se utiliza la siguiente convención:

<%= @variable %>

Pero al hacer esto Rails nos lanza un error al abrir la aplicación en el navegador, este error es a causa de la equivalencia entre el objeto Pet y la tabla de la base de datos. Para resolverlo hay que ejecutar el comando rails db:migrate.

Una vez hecha la migración, ya se podrán visualizar las variables de instancia en la vista.

Crear registros con Rails console

Rails nos provee con un ORM llamado Active Recorder para manipular la base de datos. Para hacer uso de este ORM y crear registros en la tabla (o hacer otra operación en la BD) hay que entrar a la consola de Rails desde la terminal con el comando rails console.

Después se utiliza el siguiente comando para crear registros en la tabla que definimos:

=> Pet.create name: "doggy", breed: "poodle"

Cuando se ejecuta automáticamente se crea y se ejecuta la sentencia SQL correspondiente para el registro que se indicó.

El registro que crea tiene los campos que le asignamos en el modelo y además el campo created_at, con la fecha y hora en que fue creado el registro y el campo updated_at, con la fecha y hora de la ultima vez que se actualizó el registro.

Consultar un registro

Utilizando la clase Pet y el método first podemos consultar el primer registro de la tabla.

=> Pet.first

Usando este método podemos presentar la información en la vista, dandole el valor a una variable de instancia.

Active Recorder

Este ORM usado por Rails tiene otros métodos que considero importantes mencionar. En los ejemplos se usa el model User con los atributos name y ocuppation.

Create:

• User.create name:"David", occupation: "Code Artist": El método create, crea y guarda un nuevo registro en la base de datos
• User.new: Se instancia un nuevo objeto pero sin guardarse en la base de datos. Los valores a los atributos se pueden asignar luego de crearlo. P.E. user.name = "David" , user.occupation = "Code Artist". Para guardar este registro en la base de datos ejecuta el comando user.save.

Read:

• User.all: Devuelve todos los usuarios.
• User.first: Devuelve el primer usuario.
• User.find_by(name: 'David'): Devuelve el primer usuario con el valor buscado. Dentro de los paréntesis puede ir cualquier atributo del objeto.
• User.where(name: 'David', occupation: 'Code Artist'): Devuelve todos los usuarios con los valores buscados.

Update:

Cuando Active Recorder devuelve un objeto, los atributos de este pueden ser modificados y guardados en la base de datos. P.E:

user = User.find_by(name: 'David')
user.name = 'Luis'
user.save

Una forma más corta de hacerlo es con el métod update:

user = User.find_by(name: 'David')
user.update(name: 'Luis')

Si se quieren cambiar los valores de todos los registros de la tabla:

User.update_all "name = 'Luis', occupation = 'Code Artist'"

Delete

Para eliminar un registro de la base de datos:

user = User.find_by(name: 'David)
user.destroy

Eliminar varios registros a la vez:

# elimina todos los usuarios con el valor dado
User.destroy_by(name: 'David) 

• User.destroy_all: Elimina todos los registros de usuarios.

Si no se indica el tipo de dato en la consola cuando se está ejecutando la generación del modelo, por defecto su tipo de dato es “string”

Escribi una forma de mostrar una tabla con la información de las mascotas que tenemos y si no hay mascotas mostrar un mensaje. Para esto en el controlador deben agregar:

<class HolaController < ApplicationController

    def welcome

        @Pets = Pet.all

    end
end
>

Y en la vista de welcome:

<<br> </br>

<%if @Pets.blank? %>
    <strong> THERE ARE NO PETS </strong>
<%else%>
    <storng> Your peths ! </strong><br></br>
    <table>
            <tr>
                <th>Name</th>
                <th>Breed</th>
            </tr>
            <% @Pets.each do |pet| %>
            <tr>
                <td><%= pet.name %></td>
                <td><%= pet.breed %></td>
            </tr>
        <% end %>
    </table>
<%end%>>

Así quedó mi codigo.

class WelcomeController < ApplicationController
    def hello
        @pet_name = Pet.first.name
        @pet_breed = Pet.first.breed
    end
end

Hola, mi nombre es: <%= @pet_name %> y soy de raza: <%= @pet_breed %>```

La diferencia entre <%= %> y <% %> es que la primera despliega la información dentro de esta mientras que la segunda solo ejecuta el código incrustado.

Hola a todos.

Un tip de algo que vi, para tener en cuenta:

• En caso de que deseen generar un modelo cuyos atributos sean solo de tipo string, pueden obviar el formato nombre:tipo y solo indicar el nombre del atributo:

rails g model Pet name breed

Para confirmar, pueden digitar ‘rails console’ y les va a cambiar el diseño del terminal tipo IRB (Interactive Ruby, en el caso de Windows como lo he manejado) y escriben Pets.columns; les aparecerá la estructura de los campos creados y el tipo de cada uno.

• En Rails, una forma de guiarse fácilmente al crear controladores y modelos asociados es que el controlador tiene nombre declarado en plural, mientras que el modelo está nombrado en singular (aunque para el tutorial se hizo una excepción particular con WelcomeController; no digo que sea obligatorio, pero es una convención general)

Son mis consideraciones al respecto según he visto. Espero puedan ser de utilidad.

Existe alguna gema que me permita usar templates de generadores para modelos típicos o comúnmente usados?

Mi forma de hacer la solución.

En el controlador

class WelcomeController < ApplicationController
def hello
name = Pet.first.name
breed = Pet.first.breed
@variable = "Hola soy #{name}, y soy un #{breed}"
end
end

En el .html.erb

<%= @variable %>

Creación de un objeto
El comando rails g permite utlilizar ciertas estructras de codigo prediseñadas para empezar a abordar cierto tipo de información más rápido. Le agregamos un parámetro que en este caso será model. El nombre del modelo será Pet (mascota). También le agregamos sus atributos junto con el tipo de dato: name, breed. Ambos son strings.

rails g model Pet name:string breed:string

Esto generará dos archivos: db/migrate y pet.rb.
El archivo pet.rb será una clase (Pet) heredada de ApplicationRecord. Este es el modelo.
_
La carpeta db/migrate contendrá un archivo create_pets. También será una clase que crea una clase llamada pet que interactúa con la base de datos. Este es el concepto de base de datos.
_
La convención de nombres debe ser la misma
_
Variable de instancia
Sirven para pasar información de Rails a las vistas. Se inicializan con @ seguido de su nombre y contenido a asignar.

@variable = 'Hello world'

Para renderizar código Ruby en un archivo HTML debemos cambiar su extensión a name.html.erb. erb denota que antes de renderizar HTML renderiza código Ruby.
_
En este archivo ahora podremos usar las etiquetas <%= %> para renderizar el contenido de la variable antes creada.
_
En caso de presentarse un error de migración solo hay que correr el comando rails db:migrate en el cmd.
_
Crear registro en la base de datos
Vamos a la consola y ejecutamos rails console que nos permitirá una interacción dinámica con todos los registros creados en Rails, incluyendo modelos.
Para crear un registro en la DB usamos el nombre de la clase seguido del método .create, luego los atributos separados por comas.

Pet.create name:'Jack', breed:'Schnauzer'

Podemos acceder al registro en nuestra variable asignandole el nombre de la clase, seguido de .first. También podemos añadir el sufijo de algún atributo si se quiere ser más especifico.

@variable = Pet.first.name # Imprime Jack

Buen día compañeros y docente, espero me pueden ayudar, trate de googler mi problema pero no doy o no entiendo como solucionar esto:
en el min 10 el profe habla de entrar a console para ingresar datos, ingreso los mismos que menciona y me marca lo siguiente.

Traceback (most recent call last):
        1: from (irb):1
NameError (uninitialized constant Pet)
Did you mean?  Net
               Set

Agradeceria su ayuda.

MVC, MVC unos de los mas usado

mi controlador

Hola! Me llamo <%= @pet.name %> y soy un <%= @pet.breed %>

Yo cambié la extensión del archivo por hello.erb, y sin el .html me funciona igual…

---  welcome_controller.rb ---
class WelcomeController < ApplicationController
  def hello
    @name = Pet.first.name
    @breed =  Pet.first.breed
  end
end

--- hello.html.erb ---
<%= "¡Hola soy #{@name} y soy un #{@breed}!" %>

Controller

class WelcomeController < ApplicationController
    
    def hello
        @variable = Pet.first();
    end
    
end

View

<p>Hola soy <%= @variable.name %> y soy un <%= @variable.breed %></p>

En la clase Pet

class Pet < ApplicationRecord

	def self.introduce
        name = %Q(Hello!! I'm #{Pet.name} and I'm a #{Pet.breed})
  end
end

En el controlador

class WelcomeController < ApplicationController
    def hello
        @credentials = Rails.application.credentials.hello
        @variable = Pet.first.introduce
    end
end

En la vista

<%= @variable %>

Así busco e imprimo otros registros que son distintos al primero.

class WelcomeController < ApplicationController
  def hello
    pet = Pet.find { |r| r.id == 3 }
    @variable = pet.name
  end
end

mi solucion al reto:

class WelcomeController < ApplicationController
  def hello
    @variable = "Hola soy #{ Pet.first.name } y soy de raza #{ Pet.first.breed }"
  end
end

class WelcomeController < ApplicationController
  def hello
    @name_pet = Pet.first.name
    @breed_pet = Pet.first.breed
  end
end

<h2>Hola soy <%= @name_pet %> y soy de raza <%= @breed_pet %></h2>  

class WelcomeController < ApplicationController
  def hello
    @pet_name = Pet.first.name
    @pet_breed = Pet.first.breed
  end
end

<p>Hola soy <%= @pet_name%> y soy de raza <%= @pet_breed%></p>

Creo que todos pudimos, este fue mi proceso

Esta sería mi propuesta para saludar

<
class WelcomeController < ApplicationController 
  def hello 
    @saludar  = 'Hola, soy ',Pet.second.name,' y soy una gata ',Pet.second.breed
  end
end
> 

Para resolver el ejerció en el archivo welcome_controller use dos variables de instancia:

class WelcomeController < ApplicationController
    def hello
        @name = Pet.first.name
        @breed =Pet.first.breed
    end
end

y en el archivo Hello :

hola soy : <%= @name%>  y mi raza es : <%= @breed%>

Mi aporte:

class WelcomeController < ApplicationController
    #Los nombre con mayuscular
    def hello
        #Crear una variable distancia
        # @variable = '¿Como estas?'
        @name = Pet.first.name
        @breed = Pet.first.breed
    end
    
end

Y en el html

<h1>BIENBENIDO</h1>
    <p>Soy <%= @name%> y soy un gato <%= @breed%> </p>

Mi solución al reto:

class WelcomeController < ApplicationController

  def hello
    @name = Pet.first.name
    @breed = Pet.first.breed
  end

end

<h2>¡Hola! Me llamo <%= @name %> y soy un <%= @breed %> </h2>

<h1> Hola mi nombre es <%= @variable.name %> y soy un <%= @variable.breed %> </h1>

Super bien explicado!

que buen curso 😃
<h1>como estas?<h1/>
<h1><%= @nombre %> tu eres un <%= @raza %><h1/>

Mi controller es:

def hello#porque en el controlador esta welcome#hello
    @nombre_mascota = Pet.first.name
    @raza_mascota = Pet.first.breed   
end

Mi vista es:

<br>
Hola soy
<%= @nombre_mascota %>
de raza
<%= @raza_mascota %>

class WelcomeController < ApplicationController
    def hello 
        pet= Pet.first
        @name=pet.name
        @breed=pet.breed
    end
end```

<h1>Hola mi nombre es <%=@name%> y soy un <%=@breed%></h1>```

Controller

class WelcomeController < ApplicationController
    def hello
        @pet = Pet.first
    end
end```

**View**

<p>Hola soy <%= @pet.name%> y soy un <%= @pet.breed %></p>```

Mi solución:

class WelcomeController < ApplicationController
    def hello
        @variable = Pet.first
    end
end

<p>
    Hola soy <%= @variable.name %> y soy un <%= @variable.breed %>  
</p>

Aqui mi cambio 😃

https://web-crunch.com/posts/how-to-create-custom-scaffold-templates-in-ruby-on-rails

Interesante repl de Rails

Una alternativa, pasar solo la variable y utilizar sus atributos en la vista

class PetController < ApplicationController
	def hello
		$pet = Pet.first
	end
end

Hola, soy <%= $pet.name %> y soy un <%= $pet.breed %>

Mi solución:

class WelcomeController < ApplicationController
  def hello
    pet = Pet.first
    @name = pet.name
    @breed = pet.breed
  end
end

Y

<h3>Hola, soy <%= @name %> y soy un <%= @breed %> </h3>```

1. Cambié el nombre de la variable según correspondía a name.

2. Creé una nueva variable para almacenar la información de la raza.

3. Coloqué las variables dentro de una etiqueta de párrafo, agregando el texto solicitado en el ejercicio.

4. Este sería el resultado en la vista:

Hola este es mi código:

Mi controlador:

class WelcomeController < ApplicationController
  def hello
    @variable_name = Pet.first.name
    @variable_breed = Pet.first.breed
  end
end

Mi vista:

<h3>Hola, soy un <%= @variable_name %> y soy un <%= @variable_breed %> </h3>

La tarea puede ser delegada tanto en la vista como en el controlador, en este sentido @variable contiene el objeto completo Pet, y desde la vista se puede acceder a sus atributos de igual forma que se puede hacer en el controlador, esta es otra posible solución:

welcome_controller.rb

class WelcomeController < ApplicationController
  def hello
    @varible = Pet.first
  end
end

hello.html.erb

Hola, mi nombre es <%= @varible.name %> y soy de raza <%= @varible.breed %>

Sin embargo se debe tener en cuenta que no siempre se encuentra un registro en la base de datos y por ende el valor podría ser nil, si esto llegase a ocurrir, el acceso mediante notación de puntos no seria válido ya que el objeto NIL no tiene como atributo .name, ni tampoco .breed, esto generaría un error en el reenderizado del archivo hello.html.erb

Aquí esta mi solución:

.html.erb

<p>
  Hola! soy 
  <%= @firstPet.name %>
  y soy un <%= @firstPet.breed %>
</p>

controller.rb

class WelcomeController < ApplicationController
  def hello
    # comments
    @firstPet = Pet.first
  end
end

Saludos

Mi solución es la siguiente:

# welcome_controller.rb
class WelcomeController < ApplicationController
  def hello
    @pet = Pet.first
  end
end

<!-- hello.html.erb -->
Hola, soy <%= @pet.name %> y soy un <%= @pet.breed %>

Cabe destacar que cuando se quiere mostrar información renderizado en ruby se utiliza la etiqueta <%= %> . Ahora si no lo quisiera mostrar, como por ejemplo si fuese a usar ciclos en ruby, no le agrego el signo de igualdad ‘=’

Acá está mi aporte…

Welcome Controller

class WelcomeController < ApplicationController
  def Home
    @saludo = "Hola amigos"
    my_pet = Pet.first
    @name = my_pet.name
    @breed = my_pet.breed
  end
end

Vista Home

<h1> <%= @saludo %> </h1>

<p> Hola soy <%= @name %> y mi raza es <%= @breed %> </p>

def hello
	@pet = Pet.last
end

<p> Hola soy <%= @pet.name%> y soy un <%= @pet.breed %>

En el controlador defino dos variables.
def hello @nombreMascota = Pet.first.name @razaMascota = Pet.first.breed end

en mi archivo html las invoco:
Hola, soy <%= @nombreMascota %> y son de la raza <%= @razaMascota %>

Unos de los profesores que mejor explican al momento de introducir codigo. que bueno encontrar instructores asi, gracias Johan Tique.

No sé que está pasando con la migración. He seguido paso a paso y cuando quiero insertar un registro me que la variable Pet no ha sido inicializada. Estoy haciéndolo con postgresql

Mi controlador:

class WelcomeController < ApplicationController
  def hello
    @hello_pet =  "hello I'm #{Pet.first.name} and this is my breed: #{Pet.first.breed}"
  end
end

Hello.html.erb

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <%= @hello_pet%>
  </body>
</html>