Post Top Ad

Your Ad Spot

jueves, 8 de octubre de 2020

Tutorial PHP Laravel 7/6: Ejemplo de aplicación CRUD con Bootstrap 4 y base de datos MySQL

 A lo largo de este tutorial para principiantes, aprenderá a usar Laravel 7/6, la última versión de uno de los frameworks PHP más populares, para crear una aplicación web CRUD con una base de datos MySQL y estilos Bootstrap 4 desde cero y paso a paso comenzando con la instalación de Composer (administrador de paquetes PHP) para implementar y servir su aplicación.

Nota : Laravel 7 se lanzó recientemente y este tutorial se actualizó a la última versión.

Consulte también el tutorial de PHP Laravel 7 por ejemplo: cree su aplicación CRUD con MySQL y CSS Bootstrap

¿Qué es Bootstrap 4?

Bootstrap 4 es la última versión de Twitter Bootstrap, que es un marco CSS que permite a los desarrolladores web diseñar profesionalmente sus interfaces web sin ser expertos en CSS.

Bootstrap 4 se basa en Flexbox y le permite crear diseños receptivos con clases y utilidades fáciles.

Lea también Cómo instalar Bootstrap 4 en el tutorial y ejemplo de Laravel 7/6

¿Qué es CRUD?

CRUD significa Crear, Leer, Actualizar y Eliminar, que son operaciones necesarias en la mayoría de las aplicaciones basadas en datos que acceden y trabajan con datos de una base de datos.

En este ejemplo, veremos cómo impulsar las operaciones CRUD en Laravel 7/6 contra una base de datos MySQL.

Lea también: Laravel 7/6 REST CRUD API - Eloquent Models and Relationships

Nuevas características de Laravel 7

Laravel 7 trae muchas características nuevas como:

  • Laravel Airlock: un paquete oficial para la autenticación de API,
  • Casts elocuentes personalizados: te permiten agregar tus lances personalizados ganados,
  • Soporte CORS por defecto, es decir, sin complementos de terceros,
  • Etiquetas y mejoras de componentes de la hoja: le permite crear componentes sin clase,
  • Cliente HTTP: una API para realizar solicitudes HTTP,
  • Mejoras de velocidad de almacenamiento en caché de ruta, etc.

Lea también el tutorial de autenticación de Laravel 7/6: ejemplo de inicio de sesión / registro / restablecimiento de contraseña

Las nuevas características de Laravel 6

Entonces, ¿qué hay de nuevo con Laravel 6?

Como se mencionó, Laravel 6 viene con un montón de nuevas características y mejoras como:

  • El soporte del control de versiones semántico ,
  • Compatibilidad con Vapor , una plataforma de implementación sin servidor para Laravel,
  • Respuestas de autorización mejoradas,
  • Middleware de trabajos: una nueva función que le permite ajustar la lógica personalizada en torno a la ejecución de trabajos en cola,
  • Colecciones perezosas: una nueva característica que aprovecha los generadores de PHP para permitirle trabajar de manera eficiente con conjuntos de datos muy grandes,
  • Mejoras de subconsultas elocuentes,
  • Interfaz de usuario de Laravel: la lógica de andamio de la interfaz de usuario, como Bootstrap o Vue, se extrae en su propio laravel/uipaquete.
  • Ignition: una página de error nueva e inteligente.

Consulte los documentos para obtener más detalles.

Nuevas características de Laravel 5.8

Comencemos nuestro tutorial repasando las características más importantes introducidas en esta versión.

  • La hasOneThroughrelación elocuente.
  • Mejor validación de correo electrónico,
  • Descubrimiento automático de políticas modelo siempre que el modelo y la política sigan las convenciones de nomenclatura estándar de Laravel
  • Controladores de sesión y caché de DynamoDB,
  • Se agregó soporte para PHPUnit 8.0 para pruebas unitarias,
  • Se agregó soporte para Carbon 2.0 , una extensión de API PHP fácil de usar para DateTime,
  • Se agregó soporte Pheanstalk 4.0 : un cliente PHP 5.3+ puro para la cola de trabajo beanstalkd , etc.

La versión de Laravel 6 también ha corregido numerosos errores e introducido muchas mejoras de la ArtisanCLI.

Consulte los documentos oficiales para conocer las características detalladas de Laravel 5.8

Prerrequisitos

Este tutorial asume que tienes PHP y MySQL instalados en tu sistema. Siga las instrucciones de su sistema operativo para instalar ambos.

También debe estar familiarizado con Linux / macOS bash, donde ejecutaremos los comandos en este tutorial.

Se requiere estar familiarizado con PHP ya que Laravel 7 se basa en PHP.

For development I will be using a Ubuntu 16.04+ machine so the commands in this tutorial are targeting this system but you should be able to follow this tutorial in any operating system you use.

Laravel 6 requires PHP >= 7.2.0 Laravel 7 requires PHP >= 7.2.5

Installing PHP 7.2.5+

Laravel 7 requires PHP 7.2.5+ or above so you need the latest version of PHP installed on your system. The process is straightforward on most systems.

On Ubuntu, you can follow these instructions.

First add the ondrej/php PPA which contains the latest version of PHP:

$ sudo add-apt-repository ppa:ondrej/php
$ sudo apt-get update

Next, install PHP 7.2 using the following command:

$ sudo apt-get install php7.2

If you are using Ubuntu 18.04, PHP 7.2 is included in the default Ubuntu repository for 18.04 so you should be able to install it using the following command:

$ sudo apt-get install php

This tutorial is tested with PHP 7.2 but you can also use more recent versions like PHP 7.3

Instalación de los módulos PHP 7.2 necesarios

Laravel requiere varios módulos. Puede instalarlos usando el siguiente comando:

$ sudo apt-get install php7.2 php7.2-cli php7.2-common php7.2-json php7.2-opcache php7.2-mysql php7.2-mbstring php7.2-mcrypt php7.2-zip php7.2-fpm php7.2-xml

Instalación de PHP Composer

Comencemos nuestro viaje instalando Composer, el administrador de paquetes PHP.

Navegue en su directorio de inicio, luego descargue el instalador del sitio web oficial usando curl:

$ cd ~
$ curl -sS https://getcomposer.org/installer -o composer-setup.php

Luego puede instalarlo composerglobalmente en su sistema usando el siguiente comando:

$ sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

A partir de este escrito, Composer 1.8 se instalará en su sistema. Puede asegurarse de que su instalación funcione como se espera ejecutando composeren su terminal:

$ composer

Debería obtener el siguiente resultado:

   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 1.8.0 2018-12-03 10:31:16

Usage:
  command [options] [arguments]

Options:
  -h, --help                     Display this help message
  -q, --quiet                    Do not output any message
  -V, --version                  Display this application version
      --ansi                     Force ANSI output
      --no-ansi                  Disable ANSI output
  -n, --no-interaction           Do not ask any interactive question
      --profile                  Display timing and memory usage information
      --no-plugins               Whether to disable plugins.
  -d, --working-dir=WORKING-DIR  If specified, use the given directory as working directory.
  -v|vv|vvv, --verbose           Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Para obtener más información, consulte este tutorial .

Si ha instalado con éxito Composer en su sistema, está listo para crear un proyecto de Laravel 7.

Instalación y creación de un proyecto de Laravel 7

En esta sección presentaremos Laravel y luego procederemos a instalar y crear un proyecto de Laravel 7.

Sobre Laravel

Los documentos de Laravel lo describen como:

Laravel es un marco de aplicación web con una sintaxis elegante y expresiva. Creemos que el desarrollo debe ser una experiencia divertida y creativa para ser verdaderamente satisfactorio. Laravel intenta aliviar el dolor del desarrollo facilitando las tareas comunes que se utilizan en la mayoría de los proyectos web, como:

Laravel es accesible, pero potente, y proporciona las herramientas necesarias para aplicaciones grandes y robustas.

Generar un proyecto de Laravel 7 es fácil y sencillo. En su terminal, ejecute el siguiente comando:

$ composer create-project  --prefer-dist  laravel/laravel laravel-7-crud-app

Esto instalará laravel/laravel v7 .

Nota : asegúrese de tener PHP 7.2.5+ instalado en su sistema. De lo contrario, el compositor utilizará una versión anterior de Laravel para su proyecto.

Puede verificar la versión instalada en su proyecto usando:

$ cd laravel-7-crud-app
$ php artisan -V
Laravel Framework 7

Instalación de las dependencias de front-end

En su proyecto generado, puede ver que package.jsonse genera un archivo que incluye muchas bibliotecas de front-end que su proyecto puede usar:

  • axios,
  • oreja,
  • cross-env,
  • jquery,
  • laravel-mix,
  • lodash,
  • popper.js,
  • resolve-url-loader,
  • hablar con descaro a,
  • sass-loader,
  • vue.

Nota : Puede usar sus bibliotecas preferidas con Laravel, no específicamente las agregadas package.json.

El package.jsonarchivo en su proyecto Laravel incluye algunos paquetes como vueaxiospara ayudarlo a comenzar a construir su aplicación JavaScript.

También se incluye bootstrappara ayudarlo a comenzar con Bootstrap para diseñar su interfaz de usuario.

Incluye Laravel Mix para ayudarlo a compilar sus archivos SASS en CSS simple.

Necesita usar npmpara instalar las dependencias de front-end:

$ npm install

Después de ejecutar este comando node_modules, se creará una carpeta y las dependencias se instalarán en ella.

Nota : Debe tener Node.js y npm instalados en su sistema antes de poder instalar las dependencias de front-end.

Crear una base de datos MySQL

Creemos ahora una base de datos MySQL que usaremos para persistir en nuestra aplicación Laravel. En su terminal, ejecute el siguiente comando para ejecutar el mysqlcliente:

$ mysql -u root -p

Cuando se le solicite, ingrese la contraseña de su servidor MySQL cuando lo haya instalado.

A continuación, ejecute la siguiente declaración SQL para crear una dbbase de datos:

mysql> create database db;

Abra el .envarchivo y actualice las credenciales para acceder a su base de datos MySQL:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=db
DB_USERNAME=root
DB_PASSWORD=******

Debe ingresar el nombre de la base de datos, el nombre de usuario y la contraseña.

En este punto, puede ejecutar el migratecomando para crear su base de datos y un montón de tablas SQL que Laravel necesita:

$ php artisan migrate

Nota : Puede ejecutar el migratecomando en cualquier otro punto de su desarrollo para agregar otras tablas SQL en su base de datos o posteriormente en su base de datos si necesita agregar algún cambio más adelante.

Creando tu primer modelo de Laravel

Laravel usa el patrón arquitectónico MVC para organizar su aplicación en tres partes desacopladas:

  • El modelo que encapsula la capa de acceso a datos,
  • La vista que encapsula la capa de representación,
  • Controlador que encapsula el código para controlar la aplicación y se comunica con el modelo y las capas de vista.

Wikipedia define MVC como:

Modelo-vista-controlador es un patrón arquitectónico comúnmente utilizado para desarrollar interfaces de usuario que divide una aplicación en tres partes interconectadas. Esto se hace para separar las representaciones internas de información de las formas en que se presenta y acepta la información al usuario.

Vea el tutorial de migraciones de bases de datos de Laravel 7/6 con ejemplo de roles de administrador

Ahora, creemos nuestro primer modelo de Laravel. En su terminal, ejecute el siguiente comando:

$ php artisan make:model Contact --migration

Esto creará un modelo de contacto y un archivo de migración. En la terminal, obtenemos una salida similar a:

Model created successfully.
Created Migration: 2019_01_27_193840_create_contacts_table

Abra el database/migrations/xxxxxx_create_contacts_tablearchivo de migración y actualícelo en consecuencia:

<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateContactsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('contacts', function (Blueprint $table) {
            $table->increments('id');
            $table->timestamps();
            $table->string('first_name');
            $table->string('last_name');
            $table->string('email');
            $table->string('job_title');
            $table->string('city');   
            $table->string('country');            
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('contacts');
    }
}

Añadimos los first_namelast_nameemailjob_titlecitycountrylos campos de la contactstabla.

Vea también, Tutorial y ejemplo de verificación de correo electrónico de Laravel 7/6

Ahora puede crear la contactstabla en la base de datos usando el siguiente comando:

$ php artisan migrate

Ahora, veamos nuestro Contactmodelo, que se utilizará para interactuar con la contactstabla de la base de datos. Abra el app/Contact.phpy actualícelo:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Contact extends Model
{
    protected $fillable = [
        'first_name',
        'last_name',
        'email',
        'city',
        'country',
        'job_title'       
    ];
}

Crear el controlador y las rutas

Después de crear el modelo y migrar nuestra base de datos. Creemos ahora el controlador y las rutas para trabajar con el Contactmodelo. En su terminal, ejecute el siguiente comando:

$ php artisan make:controller ContactController --resource

El enrutamiento de recursos de Laravel asigna las típicas rutas "CRUD" a un controlador con una sola línea de código. Por ejemplo, es posible que desee crear un controlador que maneje todas las solicitudes HTTP de "fotos" almacenadas por su aplicación. Usando el make:controllercomando Artisan, podemos crear rápidamente dicho controlador:

Este comando generará un controlador en app/Http/Controllers/PhotoController.phpEl controlador contendrá un método para cada una de las operaciones de recursos disponibles.

Abra el app/Http/Controllers/ContactController.phparchivo. Este es el contenido inicial:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ContactController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        //
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        //
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        //
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function edit($id)
    {
        //
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
        //
    }
}

La ContactControllerclase extiende la Controllerclase disponible de Laravel y define un montón de métodos que se utilizarán para realizar las operaciones CRUD contra el Contactmodelo.

Puede leer el papel del método en el comentario que se encuentra arriba.

Ahora debemos proporcionar implementaciones para estos métodos.

Pero antes de eso, agreguemos el enrutamiento. Abra el routes/web.phparchivo y actualícelo en consecuencia:

<?php
Route::get('/', function () {
    return view('welcome');
});

Route::resource('contacts', 'ContactController');

Con el resource()método estático de Route, puede crear varias rutas para exponer varias acciones en el recurso.

Estas rutas se asignan a varios ContactControllermétodos que deberán implementarse en la siguiente sección:

  • GET /contacts, asignado al index()método,
  • GET /contacts/create, asignado al create()método,
  • POST /contacts, asignado al store()método,
  • GET /contacts/{contact}, asignado al show()método,
  • GET /contacts/{contact}/edit, asignado al edit()método,
  • PUT / PATCH /contacts/{contact}, asignado al update()método,
  • DELETE /contacts/{contact}, mapeado al destroy()método.

Estas rutas se utilizan para servir plantillas HTML y también como puntos finales de API para trabajar con el Contactmodelo.

Nota : Si desea crear un controlador que solo expondrá una API RESTful, puede usar el apiResourcemétodo para excluir las rutas que se usan para servir las plantillas HTML:

Route::apiResource('contacts', 'ContactController');

Implementación de las operaciones CRUD

Implementemos ahora los métodos del controlador junto con las vistas.

C: Implementar la operación Create y agregar un formulario

La ContactControllerincluye el store()método que se asigna al POST /contactspunto final de la API que se utiliza para crear un contacto en la base de datos y la create()que se asigna a la GET /contacts/createruta que será utilizada para servir el formulario HTML utilizado para enviar el contacto a POST /contactspunto final de la API.

Implementemos estos dos métodos.

Vuelva a abrir el app/Http/Controllers/ContactController.phparchivo y comience importando el Contactmodelo:

use App\Contact;

A continuación, ubique el store()método y actualícelo en consecuencia:

    public function store(Request $request)
    {
        $request->validate([
            'first_name'=>'required',
            'last_name'=>'required',
            'email'=>'required'
        ]);

        $contact = new Contact([
            'first_name' => $request->get('first_name'),
            'last_name' => $request->get('last_name'),
            'email' => $request->get('email'),
            'job_title' => $request->get('job_title'),
            'city' => $request->get('city'),
            'country' => $request->get('country')
        ]);
        $contact->save();
        return redirect('/contacts')->with('success', 'Contact saved!');
    }

A continuación, ubique el create()método y actualícelo:

    public function create()
    {
        return view('contacts.create');
    }

La create()función hace uso del view()método para devolver la create.blade.phpplantilla que debe estar presente en la resources/viewscarpeta.

Antes de crear la create.blade.phpplantilla, necesitamos crear una plantilla base que se ampliará con la plantilla de creación y todas las demás plantillas que se crearán más adelante en este tutorial.

En la resources/viewscarpeta, cree un base.blade.phparchivo:

$ cd resources/views
$ touch base.blade.php

Abra el resources/views/base.blade.phparchivo y agregue la siguiente plantilla de hoja:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Laravel 7 & MySQL CRUD Tutorial</title>
  <link href="{{ asset('css/app.css') }}" rel="stylesheet" type="text/css" />
</head>
<body>
  <div class="container">
    @yield('main')
  </div>
  <script src="{{ asset('js/app.js') }}" type="text/js"></script>
</body>
</html>

Ahora, creemos la create.blade.phpplantilla. Primero, cree una carpeta de contactos en la carpeta de vistas:

$ mkdir contacts

A continuación, crea la plantilla

$ cd contacts
$ touch create.blade.php

Abra el resources/views/contacts/create.blade.phparchivo y agregue el siguiente código:

@extends('base')

@section('main')
<div class="row">
 <div class="col-sm-8 offset-sm-2">
    <h1 class="display-3">Add a contact</h1>
  <div>
    @if ($errors->any())
      <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
              <li>{{ $error }}</li>
            @endforeach
        </ul>
      </div><br />
    @endif
      <form method="post" action="{{ route('contacts.store') }}">
          @csrf
          <div class="form-group">    
              <label for="first_name">First Name:</label>
              <input type="text" class="form-control" name="first_name"/>
          </div>

          <div class="form-group">
              <label for="last_name">Last Name:</label>
              <input type="text" class="form-control" name="last_name"/>
          </div>

          <div class="form-group">
              <label for="email">Email:</label>
              <input type="text" class="form-control" name="email"/>
          </div>
          <div class="form-group">
              <label for="city">City:</label>
              <input type="text" class="form-control" name="city"/>
          </div>
          <div class="form-group">
              <label for="country">Country:</label>
              <input type="text" class="form-control" name="country"/>
          </div>
          <div class="form-group">
              <label for="job_title">Job Title:</label>
              <input type="text" class="form-control" name="job_title"/>
          </div>                         
          <button type="submit" class="btn btn-primary-outline">Add contact</button>
      </form>
  </div>
</div>
</div>
@endsection

¡Esta es una captura de pantalla de nuestro formulario de creación!

Tutorial de Laravel 7 CRUD

Complete el formulario y haga clic en el botón Agregar contacto para crear un contacto en la base de datos. Debería ser redirigido a la ruta / contactos que aún no tiene una vista asociada.

R: Implementación de la operación de lectura y obtención de datos

A continuación, implementemos la operación de lectura para obtener y mostrar datos de contactos de nuestra base de datos MySQL.

Vaya al app/Http/Controllers/ContactController.phparchivo, localice el index()método y actualícelo:

    public function index()
    {
        $contacts = Contact::all();

        return view('contacts.index', compact('contacts'));
    }

A continuación, debe crear la plantilla de índice. Crea un resources/views/contacts.index.blade.phparchivo:

$ touch index.blade.php

Abra el resources/views/contacts/index.blade.phparchivo y agregue el siguiente código:

@extends('base')

@section('main')
<div class="row">
<div class="col-sm-12">
    <h1 class="display-3">Contacts</h1>    
  <table class="table table-striped">
    <thead>
        <tr>
          <td>ID</td>
          <td>Name</td>
          <td>Email</td>
          <td>Job Title</td>
          <td>City</td>
          <td>Country</td>
          <td colspan = 2>Actions</td>
        </tr>
    </thead>
    <tbody>
        @foreach($contacts as $contact)
        <tr>
            <td>{{$contact->id}}</td>
            <td>{{$contact->first_name}} {{$contact->last_name}}</td>
            <td>{{$contact->email}}</td>
            <td>{{$contact->job_title}}</td>
            <td>{{$contact->city}}</td>
            <td>{{$contact->country}}</td>
            <td>
                <a href="{{ route('contacts.edit',$contact->id)}}" class="btn btn-primary">Edit</a>
            </td>
            <td>
                <form action="{{ route('contacts.destroy', $contact->id)}}" method="post">
                  @csrf
                  @method('DELETE')
                  <button class="btn btn-danger" type="submit">Delete</button>
                </form>
            </td>
        </tr>
        @endforeach
    </tbody>
  </table>
<div>
</div>
@endsection

U: Implementación de la operación de actualización

A continuación, necesitamos implementar la operación de actualización. Vaya al app/Http/Controllers/ContactController.phparchivo, localice el edit($id)método y actualícelo:

    public function edit($id)
    {
        $contact = Contact::find($id);
        return view('contacts.edit', compact('contact'));        
    }

A continuación, debe implementar el update()método:

    public function update(Request $request, $id)
    {
        $request->validate([
            'first_name'=>'required',
            'last_name'=>'required',
            'email'=>'required'
        ]);

        $contact = Contact::find($id);
        $contact->first_name =  $request->get('first_name');
        $contact->last_name = $request->get('last_name');
        $contact->email = $request->get('email');
        $contact->job_title = $request->get('job_title');
        $contact->city = $request->get('city');
        $contact->country = $request->get('country');
        $contact->save();

        return redirect('/contacts')->with('success', 'Contact updated!');
    }

Ahora, debe agregar la plantilla de edición. Dentro de resources/views/contacts/, crea un edit.blade.phparchivo:

$ touch edit.blade.php

Abra el resources/views/contacts/edit.blade.phparchivo y agregue este código:

@extends('base') 
@section('main')
<div class="row">
    <div class="col-sm-8 offset-sm-2">
        <h1 class="display-3">Update a contact</h1>

        @if ($errors->any())
        <div class="alert alert-danger">
            <ul>
                @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
                @endforeach
            </ul>
        </div>
        <br /> 
        @endif
        <form method="post" action="{{ route('contacts.update', $contact->id) }}">
            @method('PATCH') 
            @csrf
            <div class="form-group">

                <label for="first_name">First Name:</label>
                <input type="text" class="form-control" name="first_name" value={{ $contact->first_name }} />
            </div>

            <div class="form-group">
                <label for="last_name">Last Name:</label>
                <input type="text" class="form-control" name="last_name" value={{ $contact->last_name }} />
            </div>

            <div class="form-group">
                <label for="email">Email:</label>
                <input type="text" class="form-control" name="email" value={{ $contact->email }} />
            </div>
            <div class="form-group">
                <label for="city">City:</label>
                <input type="text" class="form-control" name="city" value={{ $contact->city }} />
            </div>
            <div class="form-group">
                <label for="country">Country:</label>
                <input type="text" class="form-control" name="country" value={{ $contact->country }} />
            </div>
            <div class="form-group">
                <label for="job_title">Job Title:</label>
                <input type="text" class="form-control" name="job_title" value={{ $contact->job_title }} />
            </div>
            <button type="submit" class="btn btn-primary">Update</button>
        </form>
    </div>
</div>
@endsection

U: Implementación de la operación de eliminación

Finalmente, procederemos a implementar la operación de eliminación. Vaya al app/Http/Controllers/ContactController.phparchivo, busque el destroy()método y actualícelo en consecuencia:

    public function destroy($id)
    {
        $contact = Contact::find($id);
        $contact->delete();

        return redirect('/contacts')->with('success', 'Contact deleted!');
    }

Puede notar que cuando redirigimos a la /contactsruta en nuestros métodos de API CRUD, también pasamos un mensaje de éxito pero no aparece en nuestra indexplantilla. ¡Cambiemos eso!

Vaya al resources/views/contacts/index.blade.phparchivo y agregue el siguiente código:

<div class="col-sm-12">

  @if(session()->get('success'))
    <div class="alert alert-success">
      {{ session()->get('success') }}  
    </div>
  @endif
</div>

También necesitamos agregar un botón que nos lleve al formulario de creación. Agregue este código debajo del encabezado:

    <div>
    <a style="margin: 19px;" href="{{ route('contacts.create')}}" class="btn btn-primary">New contact</a>
    </div>  

Esta es una captura de pantalla de la página después de que creamos un contacto:

Ejemplo CRUD de Laravel 7

Conclusión

Llegamos al final de este tutorial. Creamos una aplicación CRUD con Laravel 7/6, PHP 7 y MySQL.

Espero que hayas disfrutado del tutorial y nos vemos en el siguiente.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

outbrain

Páginas