Post Top Ad

Your Ad Spot

domingo, 19 de abril de 2020

Relación Laravel

Una relación elocuente es una característica muy importante en Laravel que le permite relacionar las tablas en un formato muy fácil.

Relación uno a uno

La relación uno a uno proporciona la relación uno a uno entre las columnas de diferentes tablas. Por ejemplo, cada usuario está asociado con una sola publicación o tal vez con múltiples publicaciones, pero en esta relación, recuperaremos la única publicación de un usuario. Para definir una relación, primero debemos definir el método post () en el modelo de usuario. En el método post (), necesitamos implementar el método hasOne () que devuelve el resultado.
Comprendamos la relación uno a uno a través de un ejemplo.
  • Primero, agregamos la nueva columna (user_id) en una tabla existente llamada posts . Aquí, user_id es la clave foránea.
Relación Laravel
  • Migre los cambios anteriores en una base de datos utilizando el comando que se proporciona a continuación:
    php artisan migrate .
  • Después de la migración, la estructura de la tabla de publicaciones se muestra en la siguiente captura de pantalla:
Relación Laravel
La captura de pantalla anterior muestra que la columna user_id se agregó correctamente.
  • Abra el archivo User.php y agregue el siguiente código en el archivo User.php .
  1.  función pública post ()  
  2. {  
  3.   return  $ this -> hasOne ( 'Aplicación \ Publicación );  
  4. }  
En el código anterior, hemos implementado el método hasOne () que contiene el argumento único, es decir, el nombre del modelo relacionado. Por defecto, la publicación considera el user_id como una clave foránea. El método post () busca en la tabla de publicaciones, ya que hemos mencionado el espacio de nombres ' Aplicación / Publicación ' y busca la columna user_id . Podemos anular esta convención proporcionando una clave externa como segundo argumento. Se puede reescribir como:
return $ this-> hasOne ('Aplicación \ Publicación', Foreign_key)
  • Ahora, agregaremos la ruta en el archivo web.php .
  1. <? php  
  2. use  App \ User;  
  3. Ruta :: get ( '/ user' function ()  
  4. {  
  5.    usuario de retorno :: find (1) -> post;  
  6. }  
  7. );  
El código anterior es encontrar al usuario con una identificación número 1 y luego implementar la publicación para encontrar la publicación del usuario que tiene user_id igual a 1.
Salida
Relación Laravel

Relación inversa

Relación inversa significa el inverso de la relación uno a uno. En lo anterior, hemos recuperado la publicación que pertenece a un usuario en particular. Ahora, recuperamos la información del usuario en función de la publicación. Vamos a entender esto a través de un ejemplo.
  • Primero, creamos la ruta en el archivo web.php .
  1. <? php  
  2. use  App \ Post;  
  3. Ruta :: get ( '/ post / user' function ()  
  4. {  
  5.  volver  Publicar :: buscar (1) -> usuario-> nombre;  
  6. });  
  • Abra el archivo Post.php (modelo) que creamos anteriormente.
  1. <? php  
  2. aplicación de espacio de nombres;  
  3. use  Illuminate \ Database \ Eloquent \ Model;  
  4. use  Illuminate \ Database \ Eloquent \ SoftDeletes;  
  5. clase  Post  extiende el  modelo  
  6. {  
  7.  usar  SoftDeletes;  
  8. protected $ table 'publicaciones' ;   
  9. protegido $ primaryKey 'id' ;   
  10. protegido $ rellenable =   
  11. [  
  12. 'título' ,  
  13. 'cuerpo'  
  14. ];  
  15. Protegido $ date = [ 'deleted_at' ];   
  16.  usuario de la función pública ()   
  17. {  
  18.   return $ this -> belongTo ( 'Aplicación \ Usuario' );   
  19. }  
  20.   
  21. }  
Salida
Relación Laravel

Relación uno a muchos

Laravel también proporciona una relación de uno a muchos.
  • Primero, definimos la ruta que descubre todas las publicaciones de un solo usuario.
  1. Ruta :: get ( '/ posts' function () {  
  2. $ usuario = Usuario :: find (1);  
  3. foreach $ usuario -> publicaciones  como $ publicación ) {   
  4. echo $ post -> título. "<br>" ;   
  5. }  
  6. });  
  • Agregue el siguiente código en el archivo User.php (modelo) .
  1.  publicaciones de funciones públicas ()  
  2. {  
  3.     return  $ this -> hasMany ( 'App \ Post' 'user_id' );  
  4. }  
Salida
Relación Laravel

Relación de muchos a muchos

Una relación de muchos a muchos es más complicada que una relación de uno a uno y una relación de uno a muchos. Para definir la relación de muchos a muchos, necesitamos crear una tabla dinámica. La tabla dinámica es básicamente una tabla de consulta que relaciona las dos tablas. Por ejemplo, un usuario puede tener roles diferentes donde los roles pueden ser compartidos por otros usuarios, como muchos usuarios pueden tener el rol de ' Admin '. Para definir la relación entre los usuarios y los roles, necesitamos crear las tres tablas, user, roles y role_user. En nuestra base de datos, la tabla de usuario ya está creada; necesitamos crear dos tablas, es decir, tabla de roles y tabla dinámica (roles_user).
  • En primer lugar, vamos a crear el papel modelo. Utilizamos el siguiente comando para crear el modelo:
    php artisan make: model Role -m
Relación Laravel
La pantalla anterior muestra que se ha creado la tabla de roles. El create_roles_table.php se ha creado en la base de datos / migración de directorio. La estructura de este archivo se da a continuación:
  1. <? php  
  2.  use  Illuminate \ Support \ Facades \ Schema;  
  3.  use  Illuminate \ Database \ Schema \ Blueprint;  
  4. use  Illuminate \ Database \ Migrations \ Migration;  
  5. La clase  CreateRolesTable  extiende la  migración  
  6. {  
  7.     / ** 
  8.      * Ejecuta las migraciones. 
  9.      * * 
  10.      * @return void 
  11.      * /  
  12.     función pública  up ()   
  13.     {  
  14.         Schema :: create ( 'roles' ,  function  (Blueprint  $ table ) {  
  15.             $ tabla -> bigIncrements ( 'id' );  
  16.             $ tabla -> cadena ( 'nombre' );  
  17.             $ tabla -> marcas de tiempo ();  
  18.         });  
  19.     }  
  20.   
  21.     / ** 
  22.      * Revertir las migraciones. 
  23.      * * 
  24.      * @return void 
  25.      * /  
  26.     función pública  abajo ()   
  27.     {  
  28.         Esquema :: dropIfExists ( 'roles' );  
  29.     }  
  30. }  
En el código anterior, hemos agregado la nueva columna denominada 'nombre'. La columna 'nombre' define el nombre del rol de un usuario.
  • Ahora, tenemos dos tablas, la tabla de roles y la tabla de usuarios. Para relacionar estas dos tablas, necesitamos crear la tabla dinámica, tabla roles_user .
Relación Laravel
La pantalla anterior muestra que se ha creado la tabla roles_user . La estructura de create_roles_user_table se da a continuación:
  1. <? php  
  2. use  Illuminate \ Support \ Facades \ Schema;  
  3. use  Illuminate \ Database \ Schema \ Blueprint;  
  4. use  Illuminate \ Database \ Migrations \ Migration;  
  5. La clase  CreateRolesUserTable  extiende la  migración  
  6. {  
  7.     / ** 
  8.      * Ejecuta las migraciones. 
  9.      * * 
  10.      * @return void 
  11.      * /  
  12.     función pública  up ()   
  13.     {  
  14.         Schema :: create ( 'roles_user' ,  function  (Blueprint  $ table ) {  
  15.             $ tabla -> bigIncrements ( 'id' );  
  16.             $ tabla -> entero ( 'user_id' );  
  17.             $ tabla -> entero ( 'role_id' );  
  18.             $ tabla -> marcas de tiempo ();  
  19.         });  
  20.     }  
  21.   
  22.     / ** 
  23.      * Revertir las migraciones. 
  24.      * * 
  25.      * @return void 
  26.      * /  
  27.     función pública  abajo ()   
  28.     {  
  29.         Esquema :: dropIfExists ( 'roles_user' );  
  30.     }  
  31. }  
En el código anterior, hemos agregado dos nuevas columnas, user_id y role_id.
  • Migre todos los cambios anteriores utilizando el comando que se proporciona a continuación:
    php artisan migrate
Relación Laravel
  • La pantalla a continuación muestra las tres tablas, es decir, roles, roles_user y usuarios creados.
Relación Laravel
Datos disponibles en la tabla de roles:
Relación Laravel
Datos disponibles en la tabla de usuarios:
Relación Laravel
Datos disponibles en la tabla roles_user:
Relación Laravel
  • Ahora, definimos la ruta.
web.php
  1. Ruta :: get ( '/ roles / {id}' function $ id ) {  
  2. $ user = User :: find ( $ id );  
  3. foreach $ usuario -> rol  como $ rol )   
  4. {  
  5.    return $ role -> nombre;   
  6. }  
  7. });  
  • Agregamos el siguiente código en el archivo User.php que relaciona ambas tablas.
  1.  función de función pública ()  
  2. {  
  3.    return  $ this -> belongToMany ( 'App \ Role' 'roles_user' );  
  4. }   
En el código anterior, el método belongToMany () contiene dos parámetros, ' App \ Role ', que es el espacio de nombres para usar el modelo Role, y 'roles_user' es el nombre de la tabla dinámica que relaciona dos tablas. El método belongToMany () también se puede escribir como:
belongToMany ('App \ Role', 'roles_user', 'user_id', 'role_id');
La línea anterior contiene dos parámetros más, user_id y role_id. User_id es la clave foránea para la tabla de usuarios, y role_id es la clave foránea para la tabla de roles.
Salida
Relación Laravel
Relación Laravel

Acceso a la mesa intermedia / pivote

En una relación de muchos a muchos, creamos la tabla dinámica o intermedia. Ahora, veremos cómo recuperar esta tabla dinámica.
  1. <? php  
  2. Usar aplicación \ usuario;  
  3. Ruta :: get ( '/ pivot' function () {  
  4. $ usuario = Usuario :: find (1);  
  5. foreach $ usuario -> rol  como $ rol )   
  6. {  
  7.    return $ role -> pivot;   
  8. }  
  9. });  
En el modelo anterior, estamos recuperando al usuario que tiene una identificación igual a 1. Luego, usando el bucle foreach , estamos recuperando el modelo a seguir y asignado en el atributo pivote.
Relación Laravel
Si queremos recuperar la columna específica de la tabla dinámica,
  1.  función de función pública ()  
  2. {  
  3. return  $ this -> belongToMany ( 'App \ Role' 'roles_user' ) -> withPivot ( 'created_at' );  
  4. }   
web.php
  1. Ruta :: get ( '/ pivot' function () {  
  2. $ usuario = Usuario :: find (1);  
  3. foreach $ usuario -> rol  como $ rol )   
  4. {  
  5.    return $ role -> pivot-> created_at;   
  6. }  
  7. });  
Salida
Relación Laravel

Tiene muchos a través

La relación 'tiene muchos a través' proporciona una forma conveniente de acceder a las relaciones distantes o intermedias. Por ejemplo, tenemos tres tablas, usuarios, publicaciones y tabla de países. Ahora, queremos encontrar las publicaciones que pertenecen a ese país a través del modelo de usuario.
Comprendamos a través de un ejemplo.
  • La tabla de países no está disponible en la base de datos. Primero creamos el modelo de país con la migración de la base de datos.
Relación Laravel
  • Agregue la columna nombre ' en la tabla del país.
  1. <? php  
  2. use  Illuminate \ Support \ Facades \ Schema;  
  3. use  Illuminate \ Database \ Schema \ Blueprint;  
  4. use  Illuminate \ Database \ Migrations \ Migration;  
  5. class  CreateCountriesTable  extiende la  migración  
  6. {  
  7.     / ** 
  8.      * Ejecuta las migraciones. 
  9.      * * 
  10.      * @return void 
  11.      * /  
  12.     función pública  up ()   
  13.     {  
  14.             Schema :: create ( 'países' ,  función  (Blueprint  $ table ) {  
  15.             $ tabla -> bigIncrements ( 'id' );  
  16.             $ tabla -> cadena ( 'nombre' );  
  17.             $ tabla -> marcas de tiempo ();  
  18.         });  
  19.     }  
  20. / ** 
  21.      * Revertir las migraciones. 
  22.      * * 
  23.      * @return void 
  24.      * /  
  25.     función pública  abajo ()   
  26.     {  
  27.         Esquema :: dropIfExists ( 'países' );  
  28.     }  
  29. }  
  • Migre los cambios anteriores utilizando el comando que se proporciona a continuación:
    php artisan migrate
  • Ahora, agregamos la nueva columna 'country_id' en la tabla de usuarios. Use el comando dado a continuación:
    php artisan make: migración add_new_column_column_id -table = users;
  • Después de la ejecución del comando anterior, el archivo add_new_column_column_id se crea en el directorio de base de datos / migraciones.
  1. <? php  
  2. use  Illuminate \ Support \ Facades \ Schema;  
  3. use  Illuminate \ Database \ Schema \ Blueprint;  
  4. use  Illuminate \ Database \ Migrations \ Migration;  
  5. La clase  AddNewColumnColumnId  extiende la  migración  
  6. {  
  7.     / ** 
  8.      * Ejecuta las migraciones. 
  9.      * * 
  10.      * @return void 
  11.      * /  
  12.     función pública  up ()   
  13.     {  
  14.         Schema :: table ( 'users' ,  function  (Blueprint  $ table ) {  
  15.             $ tabla -> entero ( 'country_id' ) -> unsigned;  
  16.         });  
  17.     }  
  18.  / ** 
  19.      * Revertir las migraciones. 
  20.      * * 
  21.      * @return void 
  22.      * /  
  23.     función pública  abajo ()   
  24.     {  
  25.         Schema :: table ( 'users' ,  function  (Blueprint  $ table ) {  
  26.             $ tabla -> dropColumn ( 'country_id' );  
  27.         });  
  28.     }  
  29. }  
En el código anterior, hemos agregado una nueva columna en la tabla de usuarios.
Para migrar los cambios anteriores en la base de datos,
php artesanal migrar
  • Abra el archivo country.php (modelo) . Vamos a retirar las publicaciones de un país específico utilizando el modelo de país.
    country.php
  1. <? php  
  2. aplicación de espacio de nombres;  
  3. use  Illuminate \ Database \ Eloquent \ Model;  
  4. clase  país  extiende  modelo  
  5. {  
  6.   publicaciones de funciones públicas () {      
  7.  return $ this -> hasManyThrough ( 'App \ Post' 'App \ User' 'country_id' 'user_id' );   
  8. }  
  9. }  
  • Ahora, agregamos la ruta que saca las publicaciones de un país específico.
  1. Ruta :: get ( '/ usuario / país' función ()  
  2. {  
  3.   
  4.    $ country = country :: find (1);  
  5.    foreach $ country -> mensajes  como $ post )   
  6.    {  
  7.      return $ post -> título;   
  8.    }  
  9. });  
Salida
Relación Laravel

Relación polimórfica

Uno a muchos (polimórfico)
La relación polimórfica es similar a la relación uno a muchos. Cuando un solo modelo pertenece a más de un tipo de modelo en una sola asociación se conoce como relación polimórfica uno a uno. Por ejemplo, si tenemos tres tablas, publicaciones, usuarios y tabla de fotos, donde la tabla de fotos representa la relación polimórfica con los usuarios y la tabla de publicaciones.
Comprendamos esta relación a través de un ejemplo.
  • Ya hemos creado los usuarios y la tabla de publicaciones en el tema anterior. Ahora, creamos una tabla de fotos.
Relación Laravel
Abra el archivo create_photos_table.php creado en la carpeta de migraciones.
  1. <? php  
  2. use  Illuminate \ Support \ Facades \ Schema;  
  3. use  Illuminate \ Database \ Schema \ Blueprint;  
  4. use  Illuminate \ Database \ Migrations \ Migration;  
  5. La clase  CreatePhotosTable  extiende la  migración  
  6. {  
  7.     / ** 
  8.      * Ejecuta las migraciones. 
  9.      * * 
  10.      * @return void 
  11.      * /  
  12.     función pública  up ()   
  13.     {  
  14.         Schema :: create ( 'fotos' ,  función  (Blueprint  $ table ) {  
  15.             $ tabla -> bigIncrements ( 'id' );  
  16.             $ tabla -> cadena ( 'ruta' );  
  17.             $ tabla -> entero ( 'imageable_id' );  
  18.             $ tabla -> cadena ( 'imageable_type' );  
  19.             $ tabla -> marcas de tiempo ();  
  20.         });  
  21.     }  
  22.   
  23.     / ** 
  24.      * Revertir las migraciones. 
  25.      * * 
  26.      * @return void 
  27.      * /  
  28.     función pública  abajo ()   
  29.     {  
  30.         Esquema :: dropIfExists ( 'fotos' );  
  31.     }  
  32. }  
En el código anterior, hemos agregado tres columnas, ruta, imageable_id e imageable_type . La ruta determina la ruta de la imagen, imageable_id es el valor de identificación del usuario o publicación, y imageable_type es el nombre de clase del modelo.
  • Eliminaremos la columna user_id de la tabla de publicaciones, que hemos creado anteriormente.
  • Mira las tablas de la base de datos.
Datos disponibles en una tabla de publicaciones
Relación Laravel
Datos disponibles en la tabla de usuarios:
Relación Laravel
Datos disponibles en la tabla de fotos:
Relación Laravel
  • Abra el archivo de modelo de foto .
  1. <? php  
  2. aplicación de espacio de nombres;  
  3. use  Illuminate \ Database \ Eloquent \ Model;  
  4.  foto de  clase se extiende  Modelo  
  5. {  
  6. //  
  7. función pública  con imagen ()   
  8. {  
  9.  devuelve $ this -> morphTo ();   
  10. }}  
  • Agregue el siguiente código en el archivo de modelo de usuario.
  1.  fotos de funciones públicas ()  
  2. {  
  3.   devuelve  $ this -> morphMany ( 'App \ Photo' 'imageable' );  
  4. }  
  • Agregue el siguiente código en el archivo de modelo de publicación.
  1.  fotos de funciones públicas ()   
  2. {  
  3.   devuelve $ this -> morphMany ( 'App \ Photo' 'imageable' );}   
  • Ahora, crearemos las rutas para usuarios y publicaciones.
  1. // Ruta para los usuarios.  
  2. Ruta :: get ( '/ user / photo' function () {  
  3. $ usuario = Usuario :: find (1);  
  4. foreach $ usuario -> fotos  como $ foto )   
  5. {  
  6.    devolver $ foto ;   
  7. }  
  8. });  
  9.   
  10. // Ruta definida para las publicaciones.  
  11. Ruta :: get ( '/ post / photo' function () {  
  12. $ post = Post :: find (1);  
  13. foreach $ post -> fotos  como $ foto )   
  14. {  
  15.    devolver $ foto ;   
  16. }  
  17.   
  18. });  
Salida
Relación Laravel
Relación Laravel
Inversa de la relación uno a muchos (polimórfica)
En este tema, realizaremos la operación inversa de la relación polimórfica de uno a muchos. Hasta ahora, encontramos la imagen de los usuarios y las publicaciones, ahora descubrimos al propietario de la imagen.
Comprendamos a través de un ejemplo.
Necesitamos crear la ruta en el archivo web.php.
  1.  Ruta :: get ( '/ photo / {id}' ,  función $ id )  
  2. {  
  3.    $ photo = Photo :: findOrFail ( $ id );  
  4.    volver $ foto -> imagen imprimible;   
  5. });  
En el código anterior, el método Photo :: findOrFail ($ id) determina si la foto de una identificación dada existe o no. Si existe, entonces devuelve los detalles de la imagen a través de la declaración ' $ photo-> imageable '.
Salida
Relación Laravel
La salida anterior muestra los detalles de la imagen.
Relación polimórfica de muchos a muchos
En una relación polimórfica de muchos a muchos, un modelo objetivo consiste en registros únicos que se comparten entre los distintos modelos. Por ejemplo, una tabla de etiquetas comparte la relación polimórfica entre los videos y la tabla de publicaciones. Una tabla de etiquetas consta de una lista única de etiquetas que comparten las tablas, los videos y la tabla de publicaciones.
Comprendamos a través de un ejemplo.
  • Primero, creamos los modelos con la migración de la base de datos denominada Audio, Tag y Taggable .
Relación Laravel
  • Después de crear los modelos, editaremos sus archivos migrados.
Abra el archivo de migración de la tabla de audio llamada ' create_audio_table '.
  1. <? php  
  2. use  Illuminate \ Support \ Facades \ Schema;  
  3. use  Illuminate \ Database \ Schema \ Blueprint;  
  4. use  Illuminate \ Database \ Migrations \ Migration;  
  5. La clase  CreateAudioTable  extiende la  migración  
  6. {  
  7.     / ** 
  8.      * Ejecuta las migraciones. 
  9.      * * 
  10.      * @return void 
  11.      * /  
  12.     función pública  up ()   
  13.     {  
  14.         Schema :: create ( 'audio' ,  function  (Blueprint  $ table ) {  
  15.             $ tabla -> bigIncrements ( 'id' );  
  16.             $ tabla -> cadena ( 'nombre' );  
  17.             $ tabla -> marcas de tiempo ();  
  18.         });  
  19.     }  
  20.   
  21.     / ** 
  22.      * Revertir las migraciones. 
  23.      * * 
  24.      * @return void 
  25.      * /  
  26.     función pública  abajo ()   
  27.     {  
  28.         Esquema :: dropIfExists ( 'audio' );  
  29.     }  
  30. }  
En el código anterior, hemos creado la columna de nombre en la tabla de audio usando el comando $ table-> string ('name'); .
Abra el archivo de migración del modelo de etiqueta denominado ' create_tag_table '.
  1. <? php  
  2. use  Illuminate \ Support \ Facades \ Schema;  
  3. use  Illuminate \ Database \ Schema \ Blueprint;  
  4. use  Illuminate \ Database \ Migrations \ Migration;  
  5. La clase  CreateTagsTable  extiende la  migración  
  6. {  
  7.     / ** 
  8.      * Ejecuta las migraciones. 
  9.      * * 
  10.      * @return void 
  11.      * /  
  12.     función pública  up ()   
  13.     {  
  14.         Schema :: create ( 'tags' ,  function  (Blueprint  $ table ) {  
  15.             $ tabla -> bigIncrements ( 'id' );  
  16.             $ tabla -> cadena ( 'nombre' );  
  17.             $ tabla -> marcas de tiempo ();  
  18.         });  
  19.     }  
  20.   
  21.     / ** 
  22.      * Revertir las migraciones. 
  23.      * * 
  24.      * @return void 
  25.      * /  
  26.     función pública  abajo ()   
  27.     {  
  28.         Esquema :: dropIfExists ( 'etiquetas' );  
  29.     }  
  30. }  
En el código anterior, hemos creado la columna de nombre en la tabla de etiquetas mediante el comando $ table-> string ('name'); .
Abra el archivo de migración del modelo etiquetable llamado ' create_taggables_table '.
  1. <? php  
  2. use  Illuminate \ Support \ Facades \ Schema;  
  3. use  Illuminate \ Database \ Schema \ Blueprint;  
  4. use  Illuminate \ Database \ Migrations \ Migration;  
  5. La clase  CreateTaggablesTable  extiende la  migración  
  6. {  
  7.     / ** 
  8.      * Ejecuta las migraciones. 
  9.      * * 
  10.      * @return void 
  11.      * /  
  12.     función pública  up ()   
  13.     {  
  14.         Schema :: create ( 'taggables' ,  function  (Blueprint  $ table ) {  
  15.             $ tabla -> bigIncrements ( 'id' );  
  16.             $ tabla -> entero ( 'tag_id' );  
  17.             $ tabla -> entero ( 'taggable_id' );  
  18.             $ tabla -> cadena ( 'taggable_type' );  
  19.             $ tabla -> marcas de tiempo ();  
  20.         });  
  21.     }  
  22.   
  23.     / ** 
  24.      * Revertir las migraciones. 
  25.      * * 
  26.      * @return void 
  27.      * /  
  28.     función pública  abajo ()   
  29.     {  
  30.         Esquema :: dropIfExists ( 'taggables' );  
  31.     }}  
En el código anterior, hemos agregado tres nuevas columnas en la tabla taggables , es decir, tag_id, taggable_id y taggable_type. El tag_id representa la identificación de la tabla de etiquetas, la identificación etiquetable representa la identificación de la tabla modelo y el tipo etiquetable representa el nombre de la clase.
  • Para migrar los cambios anteriores, utilizamos el comando siguiente:
    php artisan migrate
  • Mira la tabla de la base de datos:
Datos disponibles en una tabla de audio:
Relación Laravel
Datos disponibles en la tabla de publicaciones:
Relación Laravel
Datos disponibles en la tabla de etiquetas:
Relación Laravel
Datos disponibles en la tabla de taggables:
Relación Laravel
  • Ahora definimos la relación en el modelo.
Audio.php
  1. <? php  
  2. aplicación de espacio de nombres;  
  3. use  Illuminate \ Database \ Eloquent \ Model;  
  4. Clase  Audio  extiende  Modelo  
  5. {  
  6.   // obtener todas las etiquetas del audio.   
  7.    etiquetas de funciones públicas ()   
  8.   {  
  9.     return $ this -> morphToMany ( 'Aplicación \ Etiqueta' 'etiquetable' );   
  10.   }  
  11. }  
Post.php
  1. aplicación de espacio de nombres;  
  2. use  App \ Photo;  
  3. use  Illuminate \ Database \ Eloquent \ Model;  
  4. use  Illuminate \ Database \ Eloquent \ SoftDeletes;  
  5. clase  Post  extiende el  modelo  
  6. {  
  7. // obtén todas las etiquetas de esta publicación.  
  8.  etiquetas de funciones públicas ()   
  9. {  
  10.   return $ this -> morphToMany ( 'Aplicación \ Etiqueta' 'etiquetable' );   
  11. }  
  12. }  
  • Ahora definimos la ruta.
  1. use  App \ Post;  
  2. use  App \ Audio;  
  3. // Ruta para obtener las etiquetas del modelo Post.  
  4. Ruta :: get ( '/ post / tags' function ()  
  5. {  
  6.   $ post = Post :: find (1);   
  7.   foreach $ post -> etiquetas  como $ tag )   
  8.   {  
  9.     devolver $ etiqueta -> nombre;   
  10.   }});  
  11. // Ruta para obtener las etiquetas del modelo de audio.  
  12. Ruta :: get ( '/ audio / tags' function ()  
  13. {  
  14.   $ audio = Audio :: find (1);   
  15.   foreach $ audio -> etiquetas  como $ etiqueta )   
  16.   {  
  17.     devolver $ etiqueta -> nombre;   
  18.   }});  
Salida
Al acceder a la ruta de la publicación, la salida sería:
Relación Laravel
Al acceder a la ruta del audio, la salida sería:
Relación Laravel
Inversa de la relación de muchos a muchos (polimórfica)
En una relación polimórfica de muchos a muchos, encontramos las etiquetas que pertenecen al modelo de publicación y audio. Pero, en una relación inversa de muchos a muchos (polimórficos), descubriremos todas las publicaciones y audios que pertenecen a una etiqueta en particular.
Comprendamos a través de un ejemplo.
  • Primero, definimos el método en un modelo de etiqueta.
Tag.php
  1. <? php  
  2. aplicación de espacio de nombres;  
  3. use  Illuminate \ Database \ Eloquent \ Model;  
  4. clase  Etiqueta  extiende  Modelo  
  5. {  
  6.    // obtener todas las publicaciones de la etiqueta.   
  7.     publicaciones de funciones públicas ()   
  8.     {  
  9.       return $ this -> morphedByMany ( 'Aplicación \ Publicación' 'etiquetable' );    
  10.     }  
  11. // obtener todos los audios de la etiqueta.  
  12.  audios de funciones públicas ()   
  13.     {  
  14.       return $ this -> morphedByMany ( 'Aplicación \ Audio' 'etiquetable' );    
  15.     }  
  16. }  
En el código anterior, definimos dos métodos, posts () y audios () . En el método posts (), estamos recuperando todas las publicaciones que pertenecen a una etiqueta específica. En el método audios (), estamos recuperando todos los audios que pertenecen a una etiqueta específica.
  • Ahora, definimos la ruta.
  1. use  App \ Tag;  
  2. // Ruta para obtener todas las publicaciones de una etiqueta.  
  3. Ruta :: get ( '/ tag / post / {id}' function $ id ) {  
  4. $ tag = Tag :: find ( $ id );  
  5. foreach $ etiqueta -> publicaciones  como $ publicación )   
  6. {  
  7.    return $ post -> título;   
  8. }  
  9. });  
  10. // Ruta para obtener todos los audios de una etiqueta.  
  11. Ruta :: get ( '/ tag / audio / {id}' function $ id ) {  
  12. $ tag = Tag :: find ( $ id );  
  13. foreach $ etiqueta -> audios  como $ audio )   
  14. {  
  15.    devolver $ audio -> nombre;   
  16. }  
  17. });  
Salida
Relación Laravel
Relación Laravel

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

outbrain

Páginas