Laravel pertenece a muchos ejemplos

Hablemos de la relación belongToMany. Recientemente creamos una introducción genial para crear un sitio web para compartir enlaces en Laravel. El tutorial cubre muchos conceptos, incluidos enrutamiento, modelos, controladores y creación de vistas. Incluso cubrimos algunas relaciones básicas en Eloquent. Una cosa que no cubrimos fue la aplicación de muchas a muchas relaciones usando el método pertenece a muchos . Veamos cómo podríamos hacer esto ahora.

# Agregue el pertenece a muchos a su primer modelo.
#Cree el modelo elocuente asociado .
# Crear una migración para la tabla de etiquetas y la tabla dinámica.
# Migrar la base de datos.
#Configure El inverso pertenece a muchos en el modelo de etiqueta.
# Pon a prueba nuestra relación con Tinker .
#Update El método create () Método para el soporte de etiquetas con lists().
#Actualice la vista Crear formulario para compatibilidad con etiquetas.
#Update El método store () para Tag Support con attach().
#Update El método edit () para Tag Support con lists().
#Actualice la vista Editar formulario para compatibilidad con etiquetas.
#Update El método update () para Tag Support con sync().
# Actualice la vista Mostrar para el soporte de etiquetas.
# Haga que el cuadro de selección de etiquetas sea bonito .

# Paso 1: Agregue el belongToMany a su primer modelo

En este ejemplo pertenece a muchos , estamos tratando con un Link.phpmodelo elocuente y queremos poder asociar ese modelo con muchas etiquetas según sea necesario. Simplemente abrimos nuestro modelo Link.php y agregamos el siguiente fragmento.

1
2
3
4
5
6
7
8
    /**
     * Each link can have many tags.
     *
     */
    public function tags()
    {
        return $this->belongsToMany('App\Tag')->withTimeStamps();
    }

# Paso 2: Crear el modelo elocuente asociado

Acabamos de agregar una relación ApplicaToMany en el modelo Link que hace referencia al modelo Tag. Ese modelo de etiqueta aún no existe, así que creémoslo ahora.

vagabundo @ homestead: ~ / Code / laravel $ php artisan make:model Tag

# Paso 3: Cree una migración para la tabla de etiquetas y la tabla dinámica.

Sabemos que las relaciones de muchos a muchos requieren una tabla dinámica. Es decir, necesitamos una tabla arbitraria para realizar búsquedas para ver qué enlace está relacionado con qué etiqueta y viceversa.

vagabundo @ homestead: ~ / Code / laravel $ php artisan make:migration create_tags_table --create=tags

Descargo de responsabilidad: las nuevas migraciones son fáciles, sin embargo, agregar migraciones a proyectos existentes me asusta. Ejecutar migraciones en una base de datos poblada puede ser un poco arriesgado cuando no está seguro de cuál será el resultado. La comida para llevar? ¡Haga una copia de seguridad de su base de datos temprano y con frecuencia!

De todos modos, el archivo de migración se crea para nosotros, pero aún no se completa con el esquema correcto. Necesitamos hacer esto por nuestra cuenta, así que hagámoslo ahora. Lo haremos:

agregue un tipo de cadena para el nombre de la etiqueta
Añadir esquema para permitir la tabla dinámica
siga la convención de nomenclatura para tablas dinámicas
configurar dos columnas, una para link_id y otra para tag_id
agregar marcas de tiempo a la tabla dinámica
agregue la capacidad de eliminar en cascada si un enlace se elimina a través de una clave externa

Nota: La convención para una tabla dinámica es usar la versión singular de las dos tablas que estamos tratando de conectar, y están en orden alfabético. En nuestro caso, tenemos una tabla de enlaces y una tabla de etiquetas a las que nos gustaría unirnos. Entonces, si aplicamos las versiones singulares en orden alfabético unidas con un guión bajo, eso nos dalink_tag. Aquí está el resultado de nuestros objetivos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class CreateTagsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('tags', function (Blueprint $table) {
            $table->increments('id');
            $table->string('name');
            $table->timestamps();
        });
 
        Schema::create('link_tag', function (Blueprint $table) {
            $table->integer('link_id')->unsigned()->index();
            $table->foreign('link_id')->references('id')->on('links')->onDelete('cascade');
 
            $table->integer('tag_id')->unsigned()->index();
            $table->foreign('tag_id')->references('id')->on('tags')->onDelete('cascade');
 
            $table->timestamps();
        });
    }
 
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::drop('tags');
        Schema::drop('link_tag');
    }
}

# Paso 4: migrar la base de datos

Este es un paso bastante fácil, solo escribe php artisan migrateen la terminal.

# Paso 5: Configurar el reverso pertenece a muchos en el modelo de etiqueta

Ya configuramos nuestro Links.phpmodelo para permitir una relación belongToMany . Esto significa que un enlace puede tener muchas etiquetas. Lo mismo es cierto para una etiqueta. Una etiqueta puede tener muchos enlaces. Ahora configuremos nuestro Tag.phpmodelo para permitir esto.

1
2
3
4
5
6
7
8
9
10
11
class Tag extends Model
{
    /**
     * Each tag can have many links.
     *
     */
    public function links()
    {
        return $this->belongsToMany('App\Link');
    }
}

# Paso 6: Pruebe nuestra relación con Tinker

Con Laravel, es muy fácil probar cosas en la línea de comandos usando php artisan tinker. Usemos tinker para probar nuestra nueva funcionalidad ahora. Preste atención a los métodos audaces, ya que son importantes cuando se trata de la relación pertenece a muchos.

vagrant @ homestead: ~ / Code / laravel $ php artisan tinker
Crea una nueva etiqueta.

>>> $ tag = nueva aplicación \ Tag;

Asígnele un nombre.
>>> $ etiqueta-> nombre = 'jQuery';
=> "jQuery"

Guarde esa etiqueta.

>>> $ etiqueta-> guardar ();
=> verdadero
>>> Aplicación \ Etiqueta :: all () -> toArray ();
=> [
       [
           "id" => 1,
           "name" => "jQuery",
           "created_at" => "2015-06-23 14:28:55",
           "updated_at" => "2015-06-23 14:28:55"
       ]
   ]
>>>

Enumere las etiquetas.

>>> Aplicación \ Etiqueta :: listas ( 'nombre' ) ;
=>  [
       "jQuery"
   ]
>>>

Cree otra etiqueta, nombre y guárdelo.

>>> $ tag = nueva aplicación \ Tag;
=>  {}
>>> $ etiqueta-> nombre = 'php';
=> "php"
>>> $ etiqueta-> guardar ();
=> verdadero
>>>

Enumere nuestras etiquetas nuevamente. Tenga en cuenta que ahora tenemos dos.

>>> Aplicación \ Etiqueta :: listas ( 'nombre' ) ;
=>  [
       "jQuery",
       "php"
   ]
>>>

Obtenga el primer enlace de nuestra base de datos. (Nota: ya teníamos este enlace en nuestra base de datos; cree el suyo propio para seguirlo).

>>> $ enlace = Aplicación \ Enlace :: primer ()
=>  {
       id: 6,
       category_id: 1,
       nombre: "Laravel PHP Framework",
       url: "http://laravel.com",
       created_at: "2015-06-06 21:41:33",
       updated_at: "2015-06-12 00:52:05",
       user_id: 1,
       slug: "laravel-php-framework",
       outbound_count: 3,
       descripción: "Laravel es un marco PHP moderno y poderoso con una elegante sintaxis para el desarrollo rápido de aplicaciones y la creación de prototipos. Laravel hace uso de los mejores paquetes disponibles en la comunidad PHP para proporcionar un entorno de desarrollo fantástico para usuarios de todos los niveles".
   }
>>>

Asocia una etiqueta a ese enlace.

>>> $ enlace-> etiquetas () -> adjuntar ( '2' ) ;
=> nulo
>>>

Obtenga todas las entradas en nuestra tabla dinámica (funcionó).

>>> DB :: select ('seleccionar * de link_tag');
=> [
        {
           link_id: 6,
           tag_id: 2,
           created_at: "2015-06-23 14:48:29",
           updated_at: "2015-06-23 14:48:29"
       }
   ]
>>>

Mostrar las etiquetas asociadas a este enlace.

>>> $ enlace-> etiquetas-> toArray ();
=> [
       [
           "id" => 2,
           "nombre" => "php",
           "created_at" => "2015-06-23 14:41:10",
           "updated_at" => "2015-06-23 14:41:10",
           "pivote" => [
               "link_id" => 6,
               "tag_id" => 2,
               "created_at" => "2015-06-23 14:48:29",
               "updated_at" => "2015-06-23 14:48:29"
           ]
       ]
   ]
>>>

Enumere los nombres de las etiquetas en este enlace.

>>> $ enlace-> etiquetas-> listas ( 'nombre' ) ;
=>  [
       "php"
   ]
>>>

Encuentra la etiqueta php en la base de datos.

>>> $ tag = App \ Tag :: find ('2');
=>  {
       id: 2
       nombre: "php",
       created_at: "2015-06-23 14:41:10",
       updated_at: "2015-06-23 14:41:10"
   }
>>>

Muestra qué enlaces están asociados con esta etiqueta.

>>> $ etiqueta-> enlaces-> toArray ();
=> [
       [
           "id" => 6,
           "category_id" => 1,
           "name" => "Laravel PHP Framework",
           "url" => "http://laravel.com",
           "created_at" => "2015-06-06 21:41:33",
           "updated_at" => "2015-06-12 00:52:05",
           "user_id" => 1,
           "slug" => "laravel-php-framework",
           "outbound_count" => 3,
           "description" => "Laravel es un marco PHP moderno y potente con una elegante sintaxis para el desarrollo rápido de aplicaciones y la creación de prototipos.
 Laravel utiliza los mejores paquetes disponibles en la comunidad PHP para proporcionar un entorno de desarrollo fantástico para usuarios de todos los niveles de habilidad ".

           "pivote" => [
               "tag_id" => 2,
               "link_id" => 6
           ]
       ]
   ]
>>>

Muy dulce. Al usar tinker, podemos ver que todas las nuevas funcionalidades que agregamos para la relación belongToMany en losmodelosLink.phpyTag.phpestán funcionando.

# Paso 7: Actualice el método Crear controlador para compatibilidad con etiquetas

En el paso anterior, tenemos una pequeña prueba de concepto, ya que parece funcionar correctamente cuando se usa Tinker. Nuestra vista, que muestra el formulario para crear un nuevo enlace, estará esperando una $tagsvariable que podemos usar como segundo argumento para Form :: select . Asegurémonos de proporcionarles el código en este método.

1
2
3
4
5
6
    public function create()
    {
        $tags = \App\Tag::lists('name', 'id');
        $categories = \DB::table('categories')->lists('name', 'id');
        return view('link.create', compact(['tags', 'categories']));
    }

Este paso asegura que seleccionamos todas las etiquetas disponibles para seleccionar cuando visitamos la vista para crear un nuevo enlace.

# Paso 8: actualice el formulario de creación para compatibilidad con etiquetas

Ahora podemos permitir el soporte de etiquetas belongToMany en la interfaz de usuario. En el formulario que usamos para crear un nuevo enlace, agreguemos el siguiente fragmento.

1
2
3
4
<div class="form-group">
     {!! Form::label('tags', 'Select associated tags (hold ctrl for multiple):') !!}
     {!! Form::select('tags[]', $tags, null, ['class' => 'form-control input-lg', 'multiple', 'id' => 'prettify', 'data-placeholder' => 'Choose at least one tag']) !!}
</div>

Preste atención a la lista de argumentos Form :: select . El primer argumento es el nombre del elemento seleccionado. Le agregamos la notación de matriz para permitir que este elemento de selección maneje el paso de múltiples valores a la vez a través de una matriz. El segundo argumento son los valores predeterminados que llenarán la lista. Establecimos esto en $tags, y mostramos cómo llenar esa variable en el paso anterior. El tercer argumento especifica los elementos seleccionados en la lista. Para una nueva entrada, podemos dejar esto en nulo. Para un formulario de estilo de actualización, este deberá tener los valores de las etiquetas actualmente seleccionadas. El cuartoEl argumento es el método familiar de pasar una matriz que contiene atributos y valores adicionales que deben asignarse al elemento.

Con tanto nuestro formulario como nuestro controlador ahora actualizados para admitir etiquetas a través de nuestro trabajo paymentsToMany, podemos verificar en el navegador para asegurarnos de que todo esté funcionando.

Laravel pertenece a muchos ejemplos

# Paso 9: Actualice el método store () para el soporte de etiquetas

Ahora que tenemos nuestra base de datos lista para admitir etiquetas con muchas a muchas relaciones y una tabla dinámica, junto con un formulario que muestra las etiquetas para que las seleccionemos, debemos asegurarnos de que cuando enviemos el formulario para almacenar una nueva entrada en la base de datos que maneja procesa las etiquetas correctamente. Puede verse más o menos así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public function store(LinkCreateFormRequest $request)
{
 
	$link = new Link(array(
		'name' => $request->get('name'),
		'url' => $request->get('url'),
		'description' => $request->get('description')
	));
 
	$link->category()->associate(Category::find($request->get('category')));
 
	$link->user()->associate(User::find(\Auth::id()));
 
	$link->save();
 
	$link->tags()->attach($request->input('tags'));
 
	return \Redirect::route('link.show',
		array($link->slug))->with('message', 'Your link has been added!');
 
}

El método clave al que debe prestar atención es el attach()método. Esto es lo que se encarga de aceptar la entrada de etiquetas y asociarla al recurso dado. El método attach () es perfecto para crear el recurso inicial en la base de datos.

# Paso 10: Actualice el método edit () para Tag Support.

Esto podría manejarse con Route Model Binding, pero aún no lo tenemos configurado en nuestro proyecto. Aquí hay un ejemplo de cómo puede llenar las etiquetas seleccionadas actualmente para usarlas en un formulario de estilo de edición o actualización. O, por supuesto, podríamos refactorizar esto para mejorarlo mucho, pero por ahora, esto funcionará.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public function edit($id)
{
	$link = Link::findBySlug($id);
	$tags = \App\Tag::lists('name', 'id');
 
	foreach ($link->tags as $tag) {
		$currentTags[] = $tag->id;
	}
 
	if(empty($currentTags)){
		$currentTags = '';
	}
 
	$categories = \DB::table('categories')->lists('name', 'id');
 
	return view('link.edit', compact(['link','title','metadescription','categories','tags','currentTags']));
}

# Paso 11: Actualice la vista Editar formulario para compatibilidad con etiquetas.

En este paso, nos aseguramos de que el tercer argumento incluye todos los valores para las etiquetas seleccionadas, $currentTags. De esta manera, si tiene un recurso que ya tiene varias etiquetas seleccionadas, cuando vaya a editar ese recurso en un formulario, esto se reflejará en la interfaz de usuario y podrá agregar y eliminar etiquetas según sea necesario desde allí.

1
2
3
4
<div class="form-group">
  {!! Form::label('tags', 'Select associated tags (hold ctrl for multiple):') !!}
  {!! Form::select('tags[]', $tags, $currentTags, ['class' => 'form-control input-lg', 'multiple', 'id' => 'prettify']) !!}
</div>

# Paso 12: Actualice el método update () para la compatibilidad con etiquetas

Cuando se trata de una relación de varios a varios en el contexto de una actualización de recursos , es posible que adjuntar no sea la mejor solución. En este caso, queremos poder eliminar y agregar elementos a la tabla dinámica simultáneamente durante una actualización. En otras palabras, queremos sincronizar la base de datos con nuestra entrada. En este caso usamos el sync()método. Un ejemplo de esto podría ser algo como esto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public function update(LinkUpdateFormRequest $request, $id)
{
	$link = Link::findBySlug($id);
 
	$link->category()->associate(Category::find($request->get('category')));
 
	$link->save();
 
	$tags = $request->input('tags');
 
	$link->tags()->sync($tags);
 
	return \Redirect::route('link.show',
		array($link->slug))->with('message', 'Your link has been updated!');
}

# Paso 13: Actualice la vista Mostrar para compatibilidad con etiquetas

En un momento, presionaremos el botón de envío con dos etiquetas seleccionadas para probar nuestros nuevos superpoderes. Primero, actualice la vista que muestra un enlace para que también muestre las etiquetas que asignamos durante el proceso de creación. Simplemente agregamos el siguiente fragmento donde queremos que se muestren las etiquetas y estaremos listos.

1
2
3
4
5
6
7
@unless ($link->tags->isEmpty())
    <p>
       @foreach($link->tags as $tag)
          <span class="label label-danger">{{ $tag->name }}</span>
       @endforeach
    </p>
@endunless

¡Podemos ver que funciona como un encanto!

Pertenece a muchos con etiquetas

# Paso 14: Haga que el cuadro de selección de etiquetas sea bonito

Tenemos una solución de trabajo en este momento, pero el cuadro de selección como se ve en este momento no es realmente ideal. Hagamos uso de un fantástico complemento de jQuery llamado Select2 para que podamos embellecer el cuadro de selección y convertirlo en un elemento de interfaz de usuario de selección de etiqueta familiar. Es increíblemente fácil de hacer. Para este ejemplo, simplemente agregamos los siguientes fragmentos a nuestro diseño maestro.

Coloque este fragmento en la sección del encabezado:

1
2
<link href="//cdnjs.cloudflare.com/ajax/libs/select2/4.0.0/css/select2.min.css" rel="stylesheet" />
<script src="//cdnjs.cloudflare.com/ajax/libs/select2/4.0.0/js/select2.min.js"></script>

Luego, coloque esto en el pie de página:

1
2
3
<script type="text/javascript">
    jQuery('#prettify').select2();
</script>

Finalmente, actualice el elemento de selección particular que le interesa para tener una identificación a la que pueda apuntar el complemento select2. Usamos prettify como id, por lo que podemos aplicarlo a nuestra selección así:

1
2
3
4
<div class="form-group">
{!! Form::label('tags', 'Choose at least one tag') !!}
{!! Form::select('tags[]', $tags, null, ['class' => 'form-control input-lg', 'multiple', 'id' => 'prettify', 'data-placeholder' => 'Choose at least one tag']) !!}
</div>

Por supuesto, esta es simplemente una forma rápida y sucia de hacer que esto funcione con un mínimo esfuerzo. Puede ser mejor usar Gulp y Elixir al implementar esto en producción para manejar la compilación y minificación de activos.

Con esta simple adición, podemos ver que nuestras etiquetas ahora se ven ridículamente increíbles.
select2 etiquetas

pantalla de etiquetas select2

Más recursos útiles

Los siguientes enlaces se aplican directamente a este episodio y deberían ser muy útiles para usted.
http://laravel.com/-docs/master/eloquent-relationships#many-to-many
http://laravel.com/-docs/master/eloquent#defining-models
https://laracasts.com/-series / laravel-5-fundamentales

Además, puede ser útil echar un vistazo al código fuente de los métodos relevantes que utilizamos en este tutorial.

liza()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public function lists($column, $key = null)
{
	$results = $this->query->lists($column, $key);
 
	// If the model has a mutator for the requested column, we will spin through
	// the results and mutate the values so that the mutated version of these
	// columns are returned as you would expect from these Eloquent models.
	if ($this->model->hasGetMutator($column)) {
		foreach ($results as $key => &$value) {
			$fill = [$column => $value];
 
			$value = $this->model->newFromBuilder($fill)->$column;
		}
	}
 
	return collect($results);
}

adjuntar()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public function attach($id, array $attributes = [], $touch = true)
{
	if ($id instanceof Model) {
		$id = $id->getKey();
	}
 
	$query = $this->newPivotStatement();
 
	$query->insert($this->createAttachRecords((array) $id, $attributes));
 
	if ($touch) {
		$this->touchIfTouching();
	}
}

sincronizar ()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public function sync($ids, $detaching = true)
{
	$changes = [
		'attached' => [], 'detached' => [], 'updated' => [],
	];
 
	if ($ids instanceof Collection) {
		$ids = $ids->modelKeys();
	}
 
	// First we need to attach any of the associated models that are not currently
	// in this joining table. We'll spin through the given IDs, checking to see
	// if they exist in the array of current ones, and if not we will insert.
	$current = $this->newPivotQuery()->lists($this->otherKey);
 
	$records = $this->formatSyncList($ids);
 
	$detach = array_diff($current, array_keys($records));
 
	// Next, we will take the differences of the currents and given IDs and detach
	// all of the entities that exist in the "current" array but are not in the
	// the array of the IDs given to the method which will complete the sync.
	if ($detaching && count($detach) > 0) {
		$this->detach($detach);
 
		$changes['detached'] = (array) array_map(function ($v) { return (int) $v; }, $detach);
	}
 
	// Now we are finally ready to attach the new records. Note that we'll disable
	// touching until after the entire operation is complete so we don't fire a
	// ton of touch operations until we are totally done syncing the records.
	$changes = array_merge(
		$changes, $this->attachNew($records, $current, false)
	);
 
	if (count($changes['attached']) || count($changes['updated'])) {
		$this->touchIfTouching();
	}
 
	return $changes;
}