Mostrando entradas con la etiqueta twig. Mostrar todas las entradas
Mostrando entradas con la etiqueta twig. Mostrar todas las entradas

jueves, 5 de diciembre de 2013

Symfony 2 avanzado: Ordenando relaciones OneToMany (Doctrine)

En Doctrine, Las relaciones OneToMany son un mecanismo muy potente para acceder a una lista de objetos hijo. El ejemplo más claro de uso de las relaciones OneToMany sería una factura y las líneas de factura o un pedido y el detalle del pedido; y en general cualquier relación maestro-esclavo o padre-hijo en la que la clave foránea se encuentra en la tabla hija.

Así en los proyectos Symfony 2 que usan Doctrine obtener la lista de objetos hijo desde el padre es tan sencillo como acceder a la propiedad del objeto. Internamente Doctrine convierte eso en una query a la base de datos, pero el resultado obtenido por defecto no viene ordenado. Podemos garantizar el orden añadiendo la cláusula OrderBy a la declaración de la propiedad OneToMany, pero esa ordenación es muy limitada. Veamos un ejemplo:

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity()
 * @ORM\Table(name="facturas")
 */
class Factura
{
  /**
   * @var integer
   * 
   * @ORM\Id
   * @ORM\Column(name="id_factura", type="integer", nullable=false)
   */
  private $id;

  /**
   * @var \DateTime
   *
   * @ORM\Column(name="fac_fecha", type="text", nullable=false)
   */
  private $fecha;

  /**
   *
   * @ORM\OneToMany(targetEntity="Lineas", mappedBy="factura", cascade={"all"})
   * @ORM\OrderBy({"id" = "ASC"})
   */
  private $lineas;

  // ...
}

/**
 * @ORM\Entity()
 * @ORM\Table(name="lineas_factura")
 */
class Lineas
{
  /**
   * @var integer
   * 
   * @ORM\Id
   * @ORM\Column(name="id_linea", type="integer", nullable=false)
   */
  private $id;

  /**
   * @var \DateTime
   *
   * @ORM\Column(name="lin_fecha", type="text", nullable=false)
   */
  private $fecha;

  /**
   * @var integer
   * 
   * @ORM\ManyToOne(targetEntity="Factura", inversedBy="lineas")
   * @ORM\JoinColumn(name="id_factura", referencedColumnName="id_factura")
   */
  private $factura;

  /**
   * @var integer
   *
   * @ORM\OneToOne(targetEntity="Producto", cascade={"all"})
   * @ORM\JoinColumn(name="id_producto", referencedColumnName="id_producto")
   */
  private $producto;

  // ...
}

/**
 * @ORM\Entity()
 * @ORM\Table(name="productos")
 */
class Producto
{
  /**
   * @var integer
   * 
   * @ORM\Id
   * @ORM\Column(name="id_producto", type="integer", nullable=false)
   */
  private $id;

  /**
   * @var string
   *
   * @ORM\Column(name="prod_nombre", type="text", nullable=false)
   */
  private $nombre;

  /**
   * @var float
   *
   * @ORM\Column(name="prod_precio", type="float", nullable=false)
   */
  private $precio;

  // ...
}

En este ejemplo la propiedad lineas de la clase Factura tiene una cláusula OrderBy que hace que la lista resultado se obtenga ordenada por id. ¿Pero que ocurriría si quisiéramos que el resultado viniese ordenado por algún dato del producto asociado como el nombre o el precio? ¿No hay forma de hacerlo con Doctrine?

Pues no, no la hay. Pero algo se puede hacer: podríamos ordenar el resultado después de obtenerlo. Al fin y al cabo se trata de un simple array de objetos. ¿Pero como hacerlo para que esté disponible en toda la aplicación y para cualquier tipo de lista? Sencillo: Con un servicio y más concretamente con una extensión Twig.

class MyExtension extends \Twig_Extension
{
  public function getName()
  {
    return 'MyExtension';
  }

  public function getFilters()
  {
    return array(
      'sortCollection' => new \Twig_Filter_Method($this, 'sortCollection'),
    );
  }

  public function sortCollection($collection, $properties) {

    $objects = $collection->getValues();
    if($properties == null) {
      return $objects;
    }

    if(is_string($properties)) {
      $property = $properties;
      $properties = array( );
      $properties[] = $property;
    }

    if(is_array($properties)) {

      usort($objects, function ($a, $b) use ($properties) {

        foreach($properties as $property) {

          $objA = $a;
          $objB = $b;

          if(is_string($property)) {

            $property = explode('.', $property);
            foreach($property as $method) {

              if($objA == null || $objB == null) {
                break;
              }

              $getter = 'get' . $method;

              if(method_exists($objA, $method)) {
                $objA = $objA->$method();
              }
              elseif(method_exists($objA, $getter)) {
                $objA = $objA->$getter();
              }
              else {
                $objA = null;
              }

              if(method_exists($objB, $method)) {
                $objB = $objB->$method();
              }
              elseif(method_exists($objB, $getter)) {
                $objB = $objB->$getter();
              }
              else {
                $objB = null;
              }
            }
          }

          if($objA != null && $objB == null) {
            return -1;
          }
          elseif($objA == null && $objB != null) {
            return 1;
          }
          elseif($objA < $objB) {
            return -1;
          }
          elseif($objA > $objB) {
            return 1;
          }
        }

        return 0;
      });
    }

    return $objects;
  }
}

¿Pero como lo usamos? Pues básicamente en Twig, para obtener una lita de líneas de factura ordenadas por el nombre del producto, haríamos lo siguiente:

<ul>
{% for linea in factura.lineas | sortCollection([ 'producto.nombre' ]) %}
  <li>
    {{ linea.producto.nombre }}
  </li>
{% endfor %}
</ul>

Una extensión Twig, también puede definirse como servicio y por lo tanto, también podríamos ordenar una colección de objetos Doctrine directamente desde el controlador. Por ejemplo podríamos necesitar una lista de líneas de factura ordenadas primero por precio del producto asociado y segundo por el nombre (para productos del mismo precio). Sería como sigue:

$myExtension = $this->get('twig.extension.MyExtension');
$list = $myExtension->sortCollection($factura->getLineas(), array(
  'producto.precio',
  'producto.nombre'
));

sábado, 5 de octubre de 2013

Symfony 2: Primeros pasos

Llevo algún tiempo trabajando con Symfony 2 y, aunque aun no soy un experto, voy a intentar explicar cual es la estructura global de una aplicación Symfony y cuales son los primeros pasos para desarrollar una página web este popular framework PHP. Voy a dar por supuesto que ya sabéis qué es Symfony. Empezaré por algunos conceptos:


Bundles

Toda aplicación Symfony 2 está formada por bundles. Básicamente un bundle es una carpeta que contiene tu código fuente PHP, archivos de configuración y otros recursos como imágenes, hojas de estilos CSS, archivos HTML, javascripts, etc. Todo ello dentro de una estructura predeterminada de subcarpetas jerarquizadas.

Una aplicación Symfony 2 debe contener al menos un bundle, pero no hay límite en el número de bundles que se pueden crear. Algunos programadores ponen todo el código en un único bundle gigantesco mientras que otros prefieren crear un bundle por cada división lógica de la aplicación. Por ejemplo se puede crear un MainBundle para la parte principal de la web y un AdminBundle para la parte de administración.


Entidades (Doctrine)

Symfony es un framework PHP que implementa el patrón MVC (Modelo-Vista-Controlador), en el cual toda aplicación de divide en tres capas: modelo, vista y controlador. La primera capa es el modelo y se encarga del manejo y persistencia de los datos de la aplicación. En Symfony la capa del modelo está controlada por una herramienta llamada Doctrine que se encarga precisamente del acceso a los datos y su persistencia. Doctrine hace que nuestra aplicación sea independiente del motor de bases de datos, de forma que no será necesario escribir ni una sola sentencia SQL sino que tendremos que definir una serie de objetos PHP llamados entidades y Doctrine se encargará de lo demás.

A priori puede parece complicado pero es justo lo contrario. Las entidades se guardan como archivos PHP en una carpeta llamada Entity dentro de cada bundle.


Vistas (Twig)

En el patrón MVC, la capa vista es la que se encarga de la presentación en pantalla y de la interacción con el usuario. En symfony se utiliza un motor de plantillas llamado Twig que simplifica la creación de las vistas. Aquí puedes consultar más información sobre Twig en Español. Las vistas se guardan como archivos Twig en una carpeta llamada Resources/views dentro de cada bundle.


Controladores

En el patrón MVC, la capa controlador se encarga de procesar las peticiones, obtener los datos a través del modelo y lanzar las vistas. En symfony 2 los controladores son clases PHP que se derivan de la clase Controller y que se guardan como archivos PHP en una carpeta llamada Controller dentro de cada bundle.


Enrutamiento

Symfony permite controlar todas las rutas que acepta un sitio web. Cada ruta puede ser estática de tipo /seccion/accion/ o tener parámetros, que se encierran entre corchetes, como /seccion/ver/{param}. Al final cada ruta se corresponde a un método de uno de los controladores y los parámetros serán los argumentos del método. Por ejemplo el sitio MasQueCursos.org podría configurar las siguientes rutas:

  • "/" Página principal.
  • "/cursos" Lista de cursos.
  • "/cursos/buscar" Buscador avanzado de cursos.
  • "/cursos/{nombre}" Detalle de un curso.
  • "/centros" Lista de centros de formación.
  • "/centros/{nombre}" Detalle de un centro de formación.
  • "/temas" Lista de temas disponibles.
  • "/temas/{nombre}" Lista de cursos de un tema.
  • Etc.

Además en Symfony cada ruta debe tener un nombre único que lo identifique y estar asociada a un controlador y a una acción (método de la clase). Por ejemplo:

  • Página principal:
    • Nombre="indice", Ruta="/"
    • Controlador="@MasQueCursosBundle/Controller/DefaultController"
    • Accion="indexAction"
  • Lista de cursos:
    • Nombre="lista_cursos", Ruta="/cursos"
    • Controlador="@MasQueCursosBundle/Controller/CursosController"
    • Accion="listaAction"
  • Buscardor de cursos:
    • Nombre="buscar_cursos", Ruta="/cursos/buscar"
    • Controlador="@MasQueCursosBundle/Controller/CursosController"
    • Accion="buscarAction"
  • Detalle de un curso:
    • Nombre="ver_curso", Ruta="/cursos/{nombre}"
    • Controlador="@MasQueCursosBundle/Controller/CursosController"
    • Accion="verAction"
  • Etc.

Todo el sistema de rutas se puede configurar en Symfony de dos formas: a través de los archivos de configuración o a través de anotaciones, un sistema directamente heredado de Java, que consiste en poner datos de configuración directamente en los comentarios. Por ejemplo la siguiente clase es un controlador con anotaciones: Hay una anotación @Route a nivel del controlador y otra para cada método de la clase.

namespace Ifraktal\MasQuecursosBundle\Controller;

use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;

/**
 * @Route("/cursos")
 */
class CursosController extends Controller {

    /**
     * @Route("/", name="lista_cursos")
     */
    public function listaAction()
    {
        // ...
    }

    /**
     * @Route("/buscar", name="buscar_cursos")
     */
    public function buscarAction()
    {
        // ...
    }

    /**
     * @Route("/{nombre}", name="ver_curso")
     */
    public function verAction($nombre)
    {
        // ...
    }

    // ...
}

Hasta aquí la primera entrada. En próximas entradas explicaré la estructura de carpetas de un proyecto symfony; cómo crear un proyecto Symfony 2 desde cero; etc.

lunes, 23 de septiembre de 2013

¿Qué es Symfony?

Es difícil explicar qué es Symfony. Sería correcto decir que Symfony es un framework basado en lenguaje PHP, diseñado para optimizar el desarrollo de las aplicaciones web usando en el patrón Modelo Vista Controlador (MVC). Algo así pone en la Wikipedia en su entrada Symfony. Pero eso es quedarse terriblemente corto. Esa misma definición encaja por ejemplo con Codeigniter y en realidad son dos cosas totalmente distintas, aunque persigan el mismo fin.

En la página web oficial de Symfony lo describen como un framework PHP, una filosofía y una comunidad; todos trabajando juntos en armonía. Esa es una definición "de libro", pero tampoco explica bien que es Symfony.

En realidad Symfony es más bien un conjunto de herramientas y servicios heterogéneos que, trabajando juntos, permiten desarrollar páginas y aplicaciones web complejas de forma eficiente, reduciendo el tiempo de desarrollo y automatizando las tareas comunes. Entre las herramientas que proporciona Symfony se encuentra un framework PHP, un gestor de plantillas (Twig) y un gestor ORM (Doctrine) y mucho más. Además es sumamente sencillo incorporar herramientas y aplicaciones de terceros.

La diferencia principal entre Symfony y otros frameworks PHP como Codeigniter es que mientras Codeigniter es un framework PHP puro (y ya está), Symfony es mucho más. Symfony proporciona toda una nueva filosofía de trabajo, incorporando multitud de herramientas que ayudan al desarrollo web y dirigen el proyecto, pero también lo limitan. Una ver has adoptado Symfony no puedes hacer las cosas como quieras: tienes que adaptarte a su filosofía. También es cierto que la la curva de aprendizaje de Symfony es mucho más pronunciada que Codeigniter. Empezar de cero con Symfony no es fácil, por mucha experiencia que tengas en PHP y en otros frameworks.


Un poco de historia

Symfony es un proyecto de software libre creado en 2005 por Fabien Potencier, actual CEO de Sensio Labs. La versión 1.0 fue liberada en 2007 y actualmente va por la versión 2.3, estando en preparación la 2.4. Cada nueva versión de Symfony incorpora mejoras y nuevas herramientas. Por desgracia las nuevas versiones no siempre son retrocompatibles, siendo necesario realizar cambios en el código fuente de los proyectos para adaptarse, aunque el salto más grande se produjo entre la versión 1.4 y la 2.0 (Symfony 2).


Un vistazo rápido

El framework Symfony obliga desarrollar usando el patrón Modelo-Vista-Controlador (MVC). Dicho patrón divide el desarrollo del proyecto en tres partes: el Modelo que gestiona todo lo relacionado con los datos que maneja la aplicación, la Vista que gestiona todas las interacciones con el usuario y el Controlador que gestiona todo lo que ocurre en la aplicación. El controlador procesa las peticiones, recupera los datos usando el modelo y lanza las vistas que interaccionan con el usuario. En Symfony cada una de estas partes está regulada por un componente diferente:

  • Modelo: En Symfony la parte del modelo viene gestionada por Doctrine que es una una biblioteca de clases cuyo objetivo es dotar al proyecto de poderosas herramientas para facilitar la lectura/escritura de información desde/hacia una base de datos. Doctrine es compatible con la mayoría de gestores de bases de datos, como MySQL, PostgreSQL, Oracle, etc.

    Una de las características más importantes es que el código en Doctine es independiente del gestor de base de datos. En teoría se podría cambiar el gestor en cualquier momento sin tener que modificar una línea de código. Para ello en Doctrine las queries se escriben usando DQL (Doctrine Query Language) que es una especie de SQL orientado a objetos.

  • Vistas: La parte de las vistas en symfony se gestiona con el motor de plantillas Twig del que ya hablamos hace tiempo.

    Al igual que otros motores de plantillas, Twig ayuda a separar de forma sencilla la lógica de la aplicación (código PHP) de la presentación (HTML/CSS). Es una herramienta muy potente pero a la vez muy flexible que permite diseñar plantillas de presentación muy complejas sin usar instrucciones PHP, haciendo que el código HTML/CSS final sea mucho más legible. En Twig se pueden usar variables, filtros, funciones, estructuras de control (if, for, ...), macros, expresiones, comentarios y más.

  • Controlador: En el patrón MVC el controlador se encarga de recoger las peticiones HTML, procesarlas, recuperar los datos, generar nuevas peticiones y/o lanzar las vistas correspondientes. En Symfony la parte del controlador está gestionada por clases propias del framework. Se pueden definir múltiples controladores y dentro de cada controlador varias acciones.

  • Arquitectura: Toda aplicación Symfony se divide en paquetes (bundles). Cada bundle puede contener: controladores, entidades (modelo), plantillas (vistas), archivos de configuración y otros recursos (formularios, menús, traducciones, etc.). Todo ello se controla a través de de namespaces, una característica de PHP 5.3.

  • Configuración: Symfony es un producto altamente configurable que soporta además diversos métodos de configuración, de forma que en cada proyecto se puede escoger la que mejor se adapte a las necesidades, pudiendo incluso mezclarse. Symfony puede usar indistintamente configuración a través de archivos YAML, XML o PHP. También soporta Annotations para configurar por ejemplo las rutas de los controladores.

Referencias

lunes, 3 de junio de 2013

Herramientas de programación web: Twig

Hoy voy a hablar un poco de Twig, una herramienta más enfocada al diseño web que a la programación que viene integrada en el framework Symfony2, pero que puede utilizarse también por separado.

Twig es un motor de plantillas para PHP similar a Smarty. Es un proyecto de código abierto (open source) ofrecido bajo licencia BSD y desarrollado por Fabien Potencier, el creador de Symfony. Por ello es lógico que Twig sea el motor de plantillas por defecto de Symfony2.

Al igual que otros motores de plantillas, Twig ayuda a separar de forma sencilla la lógica de la aplicación (código PHP) de la presentación (HTML/CSS). Es una herramienta muy potente pero a la vez muy flexible que permite diseñar plantillas de presentación muy complejas sin usar instrucciones PHP, haciendo que el código HTML/CSS final sea mucho más legible.


Ejemplo

El siguiente es un ejemplo básico de plantilla Twig:

<!DOCTYPE html>
<html>
  <head>
    <title>Client List</title>
  </head>
  <body>
    <h1>Client List</h1>
    <ul>
    {# Recorrido por la lista de clientes #}
    {% for client in clients %}
      <li>
        <a> href="/client/{{ client.id }}">
          {{ client.name }}
        </a>
      </li>
    {% else %}
      No se han encontrado clientes.
    {% endfor %}
    </ul>
  </body>
</html>

Variables, filtros y funciones

Uando Twig podemos acceder al contenido de una variable simplemente poniendo su nombre entre llaves dobles: {{ var }}. Además podemos acceder a las propiedades de un objeto usando la sintaxis {{ obj.attr }}. Este mecanismo es tan potente y flexible en Twig que buscará primero como elemento (obj['attr']); si no existe buscará como atributo (obj.attr); y por último si no existe buscará como método (obj.getAttr()). Otra característica de Twig es que podemos aplicar filtros a las variables para modificar su comportamiento. Por ejemplo para formatear una fecha antes de imprimirla en pantalla: {{ date | date('d/m/Y H:i') }}. Los filtros además pueden encadenarse de forma que se ejecuten uno detras de otro. Así {{ text | striptags | upper }} eliminaría los tags HTML del texto y lo escribiría en mayúsculas.


Estructuras de control

En Twig hay una serie de instrucciones que se escriben entre {% ... %}.

  • {% if cond1 %}...{% elseif cond2 %}...{% else %}...{% endif %}
  • {% for item in array %}...{% else %}...{% endfor %}
  • {% set var = value %}
  • Etc.

Comentarios

Los comentarios se escriben entre {# ... #}:


Referencias