[Parte 1] Configurando Symfony2 y sus plantillas

Symfony, Tutoriales

Este post es la parte 1 de 6 del artículo: Creando un Blog con Symfony2

Debido a que la web de udelabs lleva varías semanas sin funcionar a petición de un par de usuarios me tomo la libertad de subir el tutorial traducido por ellos, quizás con alguna modificación que iba haciendo pero todos los méritos son de ellos. Tutorial en inglés

Descripción

Este capítulo cubre los primeros pasos para crear un sitio web Symfony2. Descargaremos y configuraremos la Edición estándar de Symfony2, crearemos el paquete del Blog y adjuntaremos las principales plantillasHTML. Al final de este capítulo habremos configurado un sitio web Symfony2 que estará disponible a través de un dominio local, por ejemplo, http://symblog.dev/. El sitio web contendrá la estructura HTMLprincipal del blog junto con algún soso contenido.

En este capítulo cubriremos las siguientes áreas:

  1. La creación de una aplicación Symfony2
  2. Configurando un dominio de desarrollo
  3. Los paquetes de Symfony2
  4. El enrutado
  5. Los controladores
  6. Las plantillas con Twig

Como hemos dicho vamos a utilizar la edición estándar de Symfony2. Esta distribución viene con las bibliotecas del núcleo de Symfony2 y los paquetes más comunes que se requieren para crear sitios web. Puedes descargar el paquete de Symfony2 de su sitio web. Puesto que no quiero repetir la excelente documentación proporcionada por el libro de Symfony2, por favor consulta el capítulo de la Instalación y configuración de Symfony2 para ver los requisitos detallados. Esto te guiará en el proceso de cuál es el paquete a descargar, cómo instalar los proveedores necesarios, y la forma correcta de asignar permisos a los directorios.

Es importante prestar especial atención a la sección Configuración de Permisos en el capítulo de instalación. Este explica las distintas formas en que puedes asignar permisos a los directorios app/cache yapp/logs para que el usuario del servidor web y el usuario de línea de ordenes tengan acceso de escritura a ellos.

Creando un dominio de Desarrollo

A efectos de esta guía vamos a utilizar el dominio local http://symblog.dev/ sin embargo, puedes elegir cualquier dominio que desees. Estas instrucciones son específicas para Apache y se supone que ya has configurado Apache y está corriendo en tu máquina. Si te sientes cómodo configurando dominios locales, o utilizas un servidor web diferente, tal como nginx puedes omitir esta sección.

Estos pasos se llevaron a cabo en la distribución Fedora de Linux por lo tanto los nombres de ruta, etc., pueden variar en función de tu sistema operativo.

Vamos a empezar creando un servidor virtual con Apache. Busca el archivo de configuración de Apache y anexa los siguientes ajustes, asegurándote de cambiar las rutas de DocumentRoot y Directoryconsecuentemente. La ubicación y nombre del archivo de configuración de Apache puede variar mucho dependiendo de tu sistema operativo. En Fedora se encuentra ubicado en /etc/httpd/conf/httpd.conf. Tendrás que editar este archivo con privilegios sudo.

Luego agrega un nuevo dominio en la parte inferior del archivo host ubicado en /etc/hosts. Una vez más, tendrás que editar este archivo con privilegios sudo.

# /etc/hosts
127.0.0.1 symblog.dev

Por último no olvides reiniciar el servicio Apache. Esto deberá cargar los ajustes de configuración actualizados que hemos hecho.

$ sudo service httpd restart
Si te encuentras creando dominios virtuales todo el tiempo, puedes simplificar este proceso, usando servidores virtuales dinámicos.

Ahora deberías poder visitar http://symblog.dev/app_dev.php/.

Pantalla de bienvenida de Symfony2

Si esta es tu primera visita a la página de bienvenida de Symfony2, dedica algún tiempo para ver las páginas de demostración. Cada página de demostración ofrece fragmentos de código que muestran cómo funciona cada página en segundo plano.

También notarás una barra de herramientas en la parte inferior de la pantalla de bienvenida. Esta es la barra de depuración web y te proporcionará información muy valiosa sobre el estado de tu aplicación. La información incluye el tiempo consumido en la elaboración de la página, el uso de memoria, las consultas hechas a la base de datos, el estado de autenticación y puedes ver mucho más desde esta barra de herramientas. Por omisión, la barra de herramientas sólo está visible cuando se ejecuta en el entorno dev, puesto que proporcionar la barra de herramientas en producción sería un gran riesgo de seguridad ya que expone una gran cantidad de información interna de tu aplicación. A través de esta guía, nos referiremos constantemente a la barra de herramientas a medida que introduzcamos nuevas características.

Configurando Symfony: La interfaz Web

Symfony2 introduce una interfaz web para configurar varios aspectos relacionados con el sitio web, tal como la configuración de la base de datos. Para este proyecto necesitamos una base de datos, por lo tanto esto nos permite empezar utilizando el configurador.

Visita http://symblog.dev/app_dev.php/ y haz clic en el botón Configurar. Introduce los detalles de configuración de la base de datos (esta guía asume el uso de MySQL, pero puedes elegir cualquier otra base de datos a la que tengas acceso), seguidos —en la siguiente página— por la generación de un segmento CSRF. Se te presentará la configuración de los parámetros que Symfony2 ha generado. Presta especial atención a la notificación en la página, es probable que tu archivo app/paramaters.yml no se pueda escribir, por lo tanto tendrás que copiar y pegar los ajustes en el archivo que se encuentra enapp/parameters.yml (esta configuración puede sustituir los ajustes existentes en el archivo).

Paquetes: bloques de construcción de Symfony2

Los paquetes son el elemento fundamental de cualquier aplicación Symfony2, de hecho Symfony2 en sí mismo es un paquete. Los paquetes nos permiten separar la funcionalidad proporcionando unidades de código reutilizable. Ellos encierran todo lo necesario para apoyar el propósito del paquete incluyendo controladores, modelo, plantillas, y diversos recursos, como imágenes y CSS. Vamos a crear un paquete para nuestro sitio web bajo el espacio de nombres Blogger. Si no estás familiarizado con los espacios de nombres en PHP debes dedicar algún tiempo leyendo sobre ellos, ya que en Symfony2 se utilizan profusamente, todo es un espacio de nombres. Ve el cargador automático de Symfony2 para obtener detalles específicos sobre cómo logra Symfony2 cargar tus clases automáticamente.

Una buena comprensión de los espacios de nombres te puede ayudar a eliminar problemas comunes que puedes encontrar cuando la estructuración de directorios no se hace correctamente en las estructuras del espacio de nombres.

Creando el paquete

Para encapsular la funcionalidad del blog vamos a crear un paquete, le daremos un nombre original para salir de lo común y corriente, lo llamaremos Blog. Este contará con todos los archivos y recursos necesarios, por lo tanto fácilmente se podría instalar en otra aplicación de Symfony2Symfony2 ofrece una serie de tareas que nos ayudarán a realizar las operaciones más comunes. Una de estas tareas es el generador de paquetes.

Para arrancar el generador de paquetes ejecuta la siguiente orden. Se te presentará una serie de instrucciones que te permitirán la manera de configurar tu paquete. En esta ocasión, vamos a utilizar el valor predeterminado para cada pregunta.

$ php app/console generate:bundle –namespace=Blogger/BlogBundle –format=yml

Una vez finalizado el generador, Symfony2 habrá construido el diseño básico para el paquete. Aquí debemos tener en cuenta unos cuantos cambios importantes.

No es obligatorio que utilices el generador de tareas proporcionado por Symfony2, este simplemente está ahí para ayudarte. Podrías haber creado manualmente la estructura de directorios y los archivos del paquete. Si bien no es obligatorio usar los generadores, proporcionan algunos beneficios, como son la rapidez y ejecución de todas las tareas necesarias para conseguir todo lo necesario en el paquete y funcionando. Un ejemplo de ello es el registro del paquete.

Registrando el paquete

Nuestro nuevo paquete BloggerBlogBundle automáticamente se ha registrado en el núcleo de nuestra aplicación situado en app/AppKernel.phpSymfony2 nos obliga a registrar todos los paquetes que necesita usar la aplicación. También notarás que algunos paquetes se registran sólo cuando estás en el entorno dev o test. Cargar esos paquetes en el entorno prod (por ‘producción’) sería introducir una sobrecarga adicional de cierta funcionalidad que no se utilizaría. El siguiente fragmento de código muestra cómo se ha registrado el paquete BloggerBlogBundle.

Enrutado

El enrutado del paquete se ha importado al archivo de enrutado principal de la aplicación ubicado en app/config/routing.yml.

La opción prefix nos permite montar todo el enrutado de BloggerBlogBundle con un prefijo. En nuestro caso hemos optado por montarlo en el valor predeterminado /. Si por ejemplo quisieras que todas tus rutas llevaran el prefijo /blogger sólo tienes que cambiar el prefijo a prefix: /blogger.

Estructura predeterminada

Por omisión el diseño del paquete se crea bajo el directorio src. Esto comienza en el nivel superior con el directorio Blogger, el cual corresponde directamente con el espacio de nombres Blogger, en el que hemos creado nuestro paquete. Bajo este, tenemos el directorio BlogBundle el cual contiene el paquete real. Examinaremos el contenido de este directorio a medida que vayamos avanzando. Si estás familiarizado con las plataformas MVC, algunos de los directorios se explican por sí mismos.

El controlador predeterminado

Como parte del generador de paquetes, Symfony2 ha creado un controlador predeterminado. Podemos ejecutar este controlador, visita la dirección http://symblog.dev/app_dev.php/hello/symblog. Deberías ver una página con un simple saludo. Intenta cambiando la parte symblog de la URL por tu nombre. Podemos examinar cómo se generó esta página a un alto nivel.

Enrutado

El archivo de enrutado del BloggerBlogBundle ubicado en src/Blogger/BlogBundle/Recursos/config/routing.yml contiene la siguiente regla de enrutado.

La ruta se compone de un patrón y algunas opciones predeterminadas. El patrón se compara con la URL, y las opciones defaults especifican el controlador que se ejecutará si coincide la ruta. En el patrón/hello/{name}, el marcador de posición {name} coincide con cualquier valor puesto que no se han establecido requisitos específicos. La ruta tampoco especifica ningún formato, método HTML, o región. Puesto que no existen requisitos para métodos HTTP, todas las peticiones GETPOSTPUT, etc., serán elegibles para concordar con el patrón.

Si la ruta reúne todos los criterios especificados, será ejecutada por el _controller de la opción defaults. La opción _controller especifica el nombre lógico del controlador que permite a Symfony2 asignarla a un archivo específico. El ejemplo anterior hará que la acción index en el controlador Default ubicado en src/Blogger/BlogBundle/Controller/DefaultController.php se ejecute.

El controlador

El controlador en este ejemplo es muy sencillo. La clase DefaultController extiende la clase Controller que proporciona algunos métodos útiles, como el método render que utilizaremos a continuación. Debido a que nuestra ruta define un marcador de posición este se pasa a la acción como el argumento $name. La acción no hace más que llamar al método render especificando la plantilla index.html.twigubicada en el directorio Default de las vistas del BloggerBlogBundle. El formato del nombre de la plantilla es paquete:controlador:plantilla. En nuestro ejemplo, este esBloggerBlogBundle:Default:index.html.twig el cual designa a la plantilla index.html.twig, ubicada en el directorio Default de las vistas del BloggerBlogBundle, o físicamente en el archivosrc/Blogger/BlogBundle/Resources/views/Default/index.html.twig. Puedes utilizar diferentes variaciones del formato de la plantilla para reproducir plantillas en diferentes lugares de tu aplicación y sus paquetes. Veremos esto más adelante en este capítulo.

También le pasamos la variable $name a la plantilla a través de una matriz de opciones.

La plantilla (la Vista)

Como puedes ver la plantilla es muy simple. Esta imprime Hello seguido por el argumento nombre pasado desde el controlador.

Limpiando

Puesto que no necesitamos algunos de los archivos creados por el generador de paquetes, podemos limpiar un poco.

Puedes eliminar el archivo del controlador src/Blogger/BlogBundle/Controller/DefaultController.php, junto con el directorio de la vista y su contenido ensrc/Blogger/BlogBundle/Resources/views/Default/. Por último, elimina la ruta definida en src/Blogger/BlogBundle/Resources/config/routing.yml

Plantillas

Cuando utilizamos Symfony2, tenemos 2 opciones predeterminadas para el motor de plantillas; Twig y PHP. Incluso, podrías optar por no usar ninguno de estos y elegir una biblioteca diferente. Esto es posible gracias al contenedor de inyección de dependencias de Symfony2. Vamos a usar Twig como nuestro motor de plantillas por una serie de razones:

  1. Twig es rápido — Las plantillas Twig se compilan hasta clases PHP por lo que hay muy poca sobrecarga al usar las plantillas Twig.
  2. Twig es conciso — Twig nos permite realizar funcionalidad de plantillas con muy poco código. Comparando esto con PHP en que estas son unas declaraciones a ser muy detalladas.
  3. Twig admite la herencia entre plantillas — Esto personalmente es uno de mis favoritos. Las plantillas tienen la capacidad de extender y sustituir otras plantillas, lo cual permite a las plantillas hijas cambiar los valores predeterminados proporcionados por sus padres.
  4. Twig es seguro — De manera predeterminada Twig tiene activado el escape de toda su producción, e incluso proporciona un entorno de área de seguridad para plantillas importadas.
  5. Twig es extensible — Twig viene con un montón de funcionalidades básicas comunes que se espera tenga un motor de plantillas, pero para aquellas ocasiones donde se requiere una funcionalidad adicional a medida, fácilmente puedes extender a Twig.

Estos sólo son algunos de los beneficios de Twig. Para más razones por las que debes utilizar Twig ve el sitio oficial de Twig.

Estructurando el diseño

Debido a que Twig admite la herencia entre plantillas, vamos a utilizar el enfoque de la herencia de tres niveles. Este enfoque nos permite modificar la vista en tres distintos niveles dentro de la aplicación, lo cual nos da un montón de espacio para nuestras personalizaciones.

La plantilla principal — Nivel 1

Vamos a empezar creando nuestra plantilla básica a nivel de bloques para symblog. Aquí, necesitaremos dos archivos, la plantilla y la hoja de estilo — CSS. Puesto que Symfony2 es compatible con HTML5 también lo vamos a utilizar.

 

Hay tres archivos externos incluidos en la plantilla, un JavaScript y dos CSS. El archivo JavaScript corrige la carencia de apoyo para HTML5 en los navegadores IE previos a la versión 9. Los dos archivos CSSimportan tipos de letra desde Google Web font.

Esta plantilla marca la estructura principal de nuestro sitio web. La mayor parte de la plantilla está compuesta por HTML, con las extrañas directivas de Twig. Ahora vamos a examinar estas directivas de Twig.

Empecemos enfocándonos en el HEAD del documento. Veamos de cerca el título:

<title>{% block title %}symblog{% endblock %} – symblog</title>

La primer cosa que notamos es esa extraña etiqueta {%. Esta no es HTML, y definitivamente tampoco es PHP. Esta es una de las tres etiquetas de Twig. Esta etiqueta es la etiqueta de Twig que Hace algo. Se utiliza para ejecutar expresiones tales como instrucciones de control y para definir elementos de bloque. Puedes encontrar una lista completa de las estructuras de control en la documentación de Twig. El bloqueTwig que definimos en el título hace dos cosas; Establece el identificador del bloque para el título, y proporciona una salida predeterminada entre las directivas block y endblock. Al definir un bloque podemos tomar ventaja del modelo de herencia de Twig. Por ejemplo, en una página para mostrar un blog deseamos que el título de la página refleje el título del blog. Lo podemos lograr extendiendo la plantilla y reemplazando el bloque del título.

{% extends ‘::base.html.twig’ %}
{% block title %}The blog title goes here{% endblock %}

En el ejemplo anterior hemos extendido la plantilla base de la aplicación que por primera vez definió el bloque título. Notarás que al formato de plantilla utilizado en la directiva extends le faltan las partes paquete ycontrolador, recuerda que el formato de la plantilla es paquete:controlador:plantilla. Al excluir las partes paquete y controlador estamos especificando que se usen las plantillas de la aplicación definidas a nivel de app/Resources/views/.

A continuación definimos otro bloque de título y pusimos un cierto contenido, en este caso el título del blog. Puesto que la plantilla principal ya contiene un bloque título, este lo sustituye por el nuestro. El título ahora reproduce ‘El título del blog va aquí – symblog’. Esta funcionalidad proporcionada por Twig se utiliza profusamente en la creación de plantillas.

En el bloque stylesheet introducimos la siguiente etiqueta de Twig, la etiqueta {{, o la etiqueta que Dice algo.

<link href=”{{ asset(‘css/screen.css’) }}” type=”text/css” rel=”stylesheet” />

Esta etiqueta se utiliza para imprimir el valor de una variable o expresión. En el ejemplo anterior esta imprime el valor devuelto por la función asset, el cual nos proporciona una forma portátil para vincular nuestros elementos de la aplicación, tales como CSSJavaScript e imágenes.

La etiqueta {{ también se puede combinar con filtros para manipular la salida antes de imprimirla.

{{ blog.created|date(“d-m-Y”) }}

Para ver una lista completa de los filtros ve la documentación de Twig.

La última etiqueta de Twig, que hasta ahora no hemos visto en las plantillas, es la etiqueta de comentario {#. Su uso es el siguiente:

{# The quick brown fox jumps over the lazy dog #}

No hay otros conceptos a introducir en esta plantilla. Esta proporciona el diseño principal que necesitamos listo para personalizarlo.

A continuación vamos a añadir algunos estilos. Crea una hoja de estilos en web/css/screen.css y añade el siguiente contenido. Esto agregará estilos para la plantilla principal.

Plantilla del paquete — nivel 2

Ahora, pasemos a la creación del diseño del paquete Blog. Crea un archivo ubicado en src/Blogger/BlogBundle/Resources/views/base.html.twig con el siguiente contenido:

A primera vista, esta plantilla puede parecer un tanto simple, pero su simplicidad es la clave. En primer lugar, esta extiende a la plantilla base de la aplicación, la cual hemos creado antes. En segundo lugar, sustituye el bloque de la barra lateral padre con cierto texto. Debido a que la barra lateral estará presente en todas las páginas de nuestro blog tiene sentido llevar a cabo la personalización en este nivel. Puedes preguntarte ¿por qué no sólo ponemos la personalización en la plantilla de la aplicación, ya que estará presente en todas las páginas? Esto es simple, la aplicación no sabe nada sobre el paquete y tampoco debería. El paquete debe autocontener toda su funcionalidad y hacer que la barra lateral sea parte de esta funcionalidad. Bien, así que ¿por qué no basta con colocar la barra lateral en cada una de las plantillas de página? Una vez más esto es simple, tendríamos que duplicar la barra lateral cada vez que agreguemos una página. Además, esta plantilla de nivel 2 nos da la flexibilidad para que en el futuro agreguemos otras personalizaciones que heredarán todas las plantillas hijas. Por ejemplo, posiblemente queramos cambiar los derechos de autor del pie de página en todas las páginas, este sería un gran lugar para hacerlo.

Plantillas de página — Nivel 3

Finalmente estamos listos para el diseño del controlador. Estos diseños comúnmente se relacionan con un controlador de acción, es decir, la acción show blog debe tener una plantilla show blog.

Vamos a empezar creando el controlador de la página inicial y su plantilla. Ya que se trata de la primera página que estamos creando, es necesario crear el controlador. Crea el controlador ensrc/Blogger/BlogBundle/Controller/PageController.php con el siguiente contenido:

Ahora crea la plantilla para esta acción. Como puedes ver en la acción del controlador vamos a reproducir la plantilla de la página índice. Crea la plantilla ensrc/Blogger/BlogBundle/Resources/views/Page/index.html.twig

Esta introduce el formato que queramos especificar a la plantilla final. En este ejemplo, la plantilla BloggerBlogBundle::base.html.twig extiende a la plantilla nombrada pero omitimos la parte del Controlador. Al excluir la parte Controlador estamos especificando que se use la plantilla a nivel del paquete creada en src/Blogger/BlogBundle/Resources/views/base.html.twig.

Ahora vamos a agregar una ruta para nuestra página inicial. Actualiza la configuración de ruta del paquete ubicada en src/Blogger/BlogBundle/Resources/config/routing.yml.

Por último tenemos que eliminar la ruta predeterminada para la pantalla de bienvenida de Symfony2. Elimina la ruta _welcome de la parte superior del archivo de enrutado dev ubicado enapp/config/routing_dev.yml.

Ahora estamos listos para ver nuestra plantilla del blogger. Apunta tu navegador a http://symblog.dev/app_dev.php/.

Página de inicio de Symblog

Deberías ver el diseño básico del blog, con el contenido principal y la barra lateral reflejando los bloques que hemos sustituido en las plantillas correspondientes.

La página Sobre

La tarea final de esta parte de la guía es crear una página estática para la página sobre. Esta te mostrará la manera de vincular las páginas y, además, cumplir el criterio de la herencia de tres niveles que hemos adoptado.

La ruta

Al crear una nueva página, una de las primeras tareas debería ser crear su ruta. Abre el archivo de enrutado del BloggerBlogBundle ubicado en src/Blogger/BlogBundle/Resources/config/routing.yml y añade la siguiente regla de enrutado.

El controlador

A continuación abre el controlador de la Página que se encuentra en src/Blogger/BlogBundle/Controller/PageController.php y agrega la acción para procesar la página sobre.

La vista

Para la vista, crea un nuevo archivo situado en src/Blogger/BlogBundle/Resources/views/Page/about.html.twig y copia el siguiente contenido.

La página sobre no es nada espectacular. Su única acción es reproducir un archivo de plantilla con un insípido contenido. Sin embargo, sí nos lleva a la siguiente tarea.

Enlazando páginas

Ahora casi tenemos lista la página. Echa un vistazo a http://symblog.dev/app_dev.php/about para ver esto. En su estado actual no hay forma de que un usuario de tu blog vea la página sobre, a no ser que escriba la URL completa al igual que lo hicimos nosotros. Como era de esperar Symfony2 ofrece ambas partes de la ecuación de enrutado. Puede coincidir rutas, como hemos visto, y también puede generar lasURL de esas rutas. Siempre debes usar las funciones de enrutado que proporciona Symfony2. En tu aplicación nunca deberías tener la tentación de poner lo siguiente:

Tal vez te estés preguntando qué es lo incorrecto con este enfoque, tal vez la forma en que siempre se enlazan sus páginas. Sin embargo, hay una serie de problemas con este enfoque.

  1. Este utiliza un enlace duro e ignora el sistema de enrutado de Symfony2 por completo. Si, en algún momento, quieres cambiar la ubicación de la página de contacto tendrías que encontrar todas las referencias al enlace duro y cambiarlas.
  2. Este ignora el entorno de tus controladores. El entorno es algo que no hemos explicado todavía, pero que has estado utilizando. El controlador frontal app_dev.php nos da acceso a nuestra aplicación en el entorno dev. Si sustituyes app_dev.php con app.php vas a ejecutar la aplicación en el entorno prod. La importancia de estos entornos se explica más adelante en la guía, pero por ahora es importante tener en cuenta que el enlace fijo definido anteriormente no mantiene el entorno actual en que nos encontramos, el controlador frontal no se antepone a la URL.

La forma correcta para enlazar páginas, es con los métodos path y url proporcionados por Twig. Ambos son muy similares, excepto que el método url nos proporcionará direcciones URL absolutas. Permite actualizar la plantilla de la aplicación principal que se encuentra en app/Resources/views/base.html.twig para enlazar la página sobre y la página inicial.

Ahora actualiza tu navegador para ver que los enlaces de las páginas Inicio y Sobre trabajan como se esperaba. Si ves el código fuente de las páginas te darás cuenta de que el enlace se ha prefijado con/app_dev.php/. Este es el controlador frontal explicado más arriba, y como puedes ver al usar path lo ha mantenido.

Finalmente actualicemos los enlaces del logotipo para que redirijan a la página inicial. Actualiza la plantilla ubicada en app/Resources/views/base.html.twig.

Conclusión

Hemos cubierto los aspectos básicos respecto a una aplicación de Symfony2 incluyendo cierta personalización de la aplicación y ahora está funcionando. Comenzamos a explorar los conceptos fundamentales detrás de una aplicación Symfony2, incluyendo el enrutado y el motor de plantillas Twig.

A continuación veremos cómo se crea la página de Contacto. Esta página es un poco más complicada que la página Sobre, ya que permite a los usuarios interactuar con un formulario web para enviar consultas. El siguiente capítulo introducirá conceptos más avanzados como la validación y formularios.

© Copyright 2011, dsyph3r :: Traducido por Nacho Pacheco

Partes del artículo[Parte 2] Página de contacto: Validadores, formularios y correo electrónico >>

13 Responses to “[Parte 1] Configurando Symfony2 y sus plantillas”

  1. Carlos

    gracias, llevo un par de dias buscandolo ya que la pagina parece que no funciona, espero que subas los que faltan

    Responder
  2. Aprendiz

    na pa eso estamos, tengo casi todo metido en borrador pero evidentemente sin estilos, pues lo pillé de la cache de google, que es lo que más cuesta así que poco a poco lo iré publicando :)

    Responder
  3. Aprendiz

    Bueno como ya he dicho las gracias hay que dárselas a sus autores :D

    dsyph3r como creador del tutorial
    y Nacho Pacheco por la traducción

    Dudo que entren a este blog así que os invito a que les enviéis los mensajes de agradecimiento a su twitter :D

    Responder
  4. Maria

    Hola Aprendiz,

    A ver si puedes ayudarme, yo he empezado hace poco con symfony2 y ahora mismo estoy intentando entender el funcionamineto de los roles.

    Tengo un usuario que puede tener 3 roles ROLE_USUARIO, ROLE_TECNICO, ROLE_ADMIN

    en el twig si ejecuto el siguiente código al autenticar el usuario me muestra los 3 roles:
    Roles: {% for role in app.user.roles %}{{ role.nombre }} {% if not loop.last %}, {% endif %}{% endfor %}

    Pero en cambio, al ejecutar is_Grante(‘ROLE_USUARIO’) retorna false y no etniendo porque, no sé como hacer que los roles que tiene el usuario sean los que devuelvan true en is_granted

    Gracias

    Responder
    • Aprendiz

      Buenas María, no sé si lo has escrito mal aquí al escribirlo o también en el código pero en twig la instrucción sería, no sé ahora si la mayúscula daría error pero le falta la d


      {% if is_granted('ROLE_USUARIO') %}
      ...
      {%endif%}

    • Maria

      Hola Aprendiz,

      El código en el .twig lo tengo correcto, pero aún así no sé porque no obtiene los roles, o que es lo que estoy haciendo mal.

      Tengo una Entity Usuarios, y una Entity Roles. En la Entity Usuarios tengo definida una relación ManyToMany con Roles

      /**
      * @ORMManyToMany(targetEntity=”Roles”)
      * @ORMJoinTable(name=”usuarios_roles”,
      * joinColumns={@ORMJoinColumn(name=”id_usuario”, referencedColumnName=”email”)},
      * inverseJoinColumns={@ORMJoinColumn(name=”id_rol”, referencedColumnName=”nombre”)}
      * )
      */

      La base de datos tiene lo siguiente:
      => select * from usuarios;
      email | id_usuario | nombre | password
      ————————+————+——–+———-
      usuario1@mail.com | 1 | Maria | 1234
      (1 fila)

      => select * from roles;
      nombre | id_rol | descripcion
      ————–+——–+————-
      ROLE_USUARIO | 1 |
      ROLE_TECNICO | 2 |
      ROLE_ADMIN | 3 |
      (3 filas)

      => select * from usuarios_roles;
      id_usuario | id_rol
      ————————+————–
      usuario1@mail.com | ROLE_USUARIO
      usuario1@mail.com | ROLE_TECNICO
      usuario1@mail.com | ROLE_ADMIN
      (3 filas)

      En el security.yml tengo lo siguiente:
      access_control:
      – { path: /_wdt, role: IS_AUTHENTICATED_ANONYMOUSLY }
      – { path: ^/*, roles: [ROLE_USUARIO, ROLE_ADMIN, ROLE_TECNICO]}

      providers:
      usuarios:
      entity: {class: GestorIncidenciasIncidenciasBundleEntityUsuarios, property: email}

      Y cuándo me autentico, en el symfony profiler, me dice:

      Username usuario1@mail.com
      Authenticated? yes
      Roles [null, null, null]

      Como este usuario tiene 3 roles definidos, entiendo que hasta ahí está llegando porque me muestra 3 null, pero no coge sus nombres, haciendo así que no me funcione y no entiendo porque.

      Gracias

    • Aprendiz

      Usuario implementa a UserInterface? o algo parecido? y Roles implementa a RoleInterface?

      Lo importante creo recordar es que Usuario implemente un método getRoles() que devuelva un array de strings que comienzen por ‘ROLE_’

      según estoy viendo ahora en tu código de twig cuando haces un for por cada rol… puede que hay esté el problema getRoles te devuelve un array de objetos.

    • Maria

      Gracias Aprendiz!!!

      Era exactamente esto. Tenia que ser un array de strings, solucionado :)

      Muchas Gracias

Deja un comentario

  • (will not be published)


1 + 2 =