> Symfony 5 > Symfony 5 Seguridad: Autenticadores
Login to bookmark this video
Buy Access to Course
28.

La API de usuario y el serializador

|

Share this awesome video!

|

Keep on Learning!

Start your All-Access Pass

With a Subscription, click any sentence in the script to jump to that part of the video!

Login Subscribe

La mayoría de nuestras páginas hasta ahora han sido páginas HTML normales. Así que vamos a crear una ruta pura de la API que devuelva datos JSON sobre el usuario autentificado en ese momento. Puede ser una ruta a la que llamemos desde nuestro propio JavaScript... o quizás estés creando una API para que la consuma otra persona. Más adelante hablaremos de ello.

Vamos a crear un nuevo controlador para esto llamado UserController... y hagamos que extienda nuestra clase BaseController:

19 lines | src/Controller/UserController.php
// ... lines 1 - 2
namespace App\Controller;
// ... lines 4 - 7
class UserController extends BaseController
{
// ... lines 10 - 17
}

Dentro, añade un método llamado apiMe(). Dale un @Route() - autocompleta el del Componente Symfony - y establece la URL como /api/me:

19 lines | src/Controller/UserController.php
// ... lines 1 - 5
use Symfony\Component\Routing\Annotation\Route;
class UserController extends BaseController
{
/**
* @Route("/api/me")
// ... line 12
*/
public function apiMe()
{
// ... line 16
}
}

Este no es un endpoint muy "restful", pero a menudo es conveniente tenerlo. Para requerir la autenticación para usar este endpoint, añade@IsGranted("IS_AUTHENTICATED_REMEMBERED"):

19 lines | src/Controller/UserController.php
// ... lines 1 - 4
use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
// ... lines 6 - 7
class UserController extends BaseController
{
/**
// ... line 11
* @IsGranted("IS_AUTHENTICATED_REMEMBERED")
*/
public function apiMe()
{
// ... line 16
}
}

En este proyecto estoy utilizando una mezcla de anotaciones y código PHP para denegar el acceso. Elige el que más te guste para tu aplicación. Dentro del método, podemos decir simplemente: devolver $this->json() y pasarle el usuario actual: $this->getUser():

19 lines | src/Controller/UserController.php
// ... lines 1 - 7
class UserController extends BaseController
{
/**
* @Route("/api/me")
* @IsGranted("IS_AUTHENTICATED_REMEMBERED")
*/
public function apiMe()
{
return $this->json($this->getUser());
}
}

¡Qué bonito! Vamos a probarlo. Ahora mismo estamos conectados... así que podemos ir a/api/me y ver... ¡absolutamente nada! ¡Sólo corchetes vacíos!

Por defecto, cuando llamas a $this->json(), pasa los datos a la claseJsonResponse de Symfony. Y entonces esa clase llama a la función json_encode() de PHP en nuestro objeto User. En PHP, a menos que hagas un trabajo extra, cuando pasas un objeto ajson_encode(), lo único que hace es incluir las propiedades públicas. Como nuestra clase Userno tiene ninguna propiedad pública:

170 lines | src/Entity/User.php
// ... lines 1 - 12
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
// ... lines 15 - 19
private $id;
// ... lines 21 - 24
private $email;
// ... lines 26 - 29
private $roles = [];
// ... lines 31 - 34
private $firstName;
// ... lines 36 - 39
private $password;
private $plainPassword;
// ... lines 43 - 168
}

Obtenemos de vuelta una respuesta aburrida.

Aprovechando el serializador

Esto... no es suficiente. Así que, en su lugar, vamos a aprovechar el componente serializador de Symfony. Para instalarlo, en tu terminal, ejecuta:

composer require "serializer:1.0.4"

Esto instala el paquete del serializador, que incluye el componente Serializer de Symfony, así como algunas otras librerías que le ayudan a funcionar de forma realmente inteligente. Pero no tiene una receta que haga nada del otro mundo: sólo instala el código.

Una de las cosas buenas de utilizar $this->json() es que, en cuanto se instala el serializador de Symfony, automáticamente se empieza a utilizar para serializar los datos en lugar del normal json_encode(). En otras palabras, cuando actualizamos la ruta, ¡funciona!

Añadir grupos de serialización

No vamos a hablar demasiado de cómo funciona el serializador de Symfony, ya que hablamos mucho de él en nuestros tutoriales de la Plataforma API. Pero al menos vamos a dar unas pinceladas básicas.

Por defecto, el serializador serializará cualquier propiedad pública o cualquier propiedad que tenga un "getter" en ella. Incluso serializará displayName -que no es una propiedad real- porque hay un método getDisplayName().

En realidad... esto es demasiada información para incluirla en la ruta. Así que tomemos más control. Podemos hacerlo diciéndole al serializador que sólo serialice los campos que están en un grupo específico. Pasa 200 para el código de estado, un array de cabeceras vacío -ambos son los valores por defecto- para que podamos llegar al cuarto argumento de $context:

21 lines | src/Controller/UserController.php
// ... lines 1 - 7
class UserController extends BaseController
{
// ... lines 10 - 13
public function apiMe()
{
return $this->json($this->getUser(), 200, [], [
// ... line 17
]);
}
}

Es una especie de "opciones" que pasas al serializador. Pasa una llamadagroups establecida en un array. Voy a inventar un grupo llamado user:read... porque estamos "leyendo" de "usuario":

21 lines | src/Controller/UserController.php
// ... lines 1 - 7
class UserController extends BaseController
{
// ... lines 10 - 13
public function apiMe()
{
return $this->json($this->getUser(), 200, [], [
'groups' => ['user:read']
]);
}
}

Copia ese nombre de grupo. Ahora, dentro de la entidad User, tenemos que añadir este grupo a todos los campos que queramos incluir en la API. Por ejemplo, vamos a incluir id. Sobre la propiedad, añade una anotación o atributo PHP: @Groups(). Asegúrate de autocompletar el del serializador de Symfony para obtener la declaración useen la parte superior. Dentro, pegaré user:read:

177 lines | src/Entity/User.php
// ... lines 1 - 8
use Symfony\Component\Serializer\Annotation\Groups;
// ... lines 10 - 13
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
/**
// ... lines 17 - 19
* @Groups("user:read")
*/
private $id;
// ... lines 23 - 175
}

Copia eso y... vamos a exponer email, no queremos exponer roles, sí afirstName y... ya está:

177 lines | src/Entity/User.php
// ... lines 1 - 13
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
/**
// ... lines 17 - 19
* @Groups("user:read")
*/
private $id;
/**
// ... line 25
* @Groups("user:read")
*/
private $email;
// ... lines 29 - 34
/**
// ... line 36
* @Groups("user:read")
*/
private $firstName;
// ... lines 40 - 175
}

También podríamos poner el grupo encima de getDisplayName() si quisiéramos incluirlo... o getAvatarUri()... en realidad lo añadiré ahí:

177 lines | src/Entity/User.php
// ... lines 1 - 13
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
// ... lines 16 - 159
/**
* @Groups("user:read")
*/
public function getAvatarUri(int $size = 32): string
{
// ... lines 165 - 169
}
// ... lines 171 - 175
}

¡Intentémoslo! Refresca y... ¡superguay! ¡Tenemos esos 4 campos!

Y fíjate en una cosa: aunque se trata de una "ruta de la API"... y nuestra ruta de la API requiere que estemos conectados, podemos acceder totalmente a esto... aunque no tengamos un sistema de autenticación de tokens de la API. Tenemos acceso gracias a nuestra cookie de sesión normal.

Así que eso nos lleva a nuestra siguiente pregunta: si tienes rutas de API como ésta, ¿necesitas un sistema de autenticación por token de API o no? Abordemos ese tema a continuación.