Curso de Symfony 2 (III): del modelo de la BBDD al Controlador CRUD Básico

Una vez configurada la aplicación tal como se indicaba en la parte II, donde disponíamos ya de una base de datos llamada s2 y nuestra aplicación estaba configurada para funcionar con dicha base de datos, a través del fichero de configuración app/config/parameters.ini:
[parameters]
    database_driver=”pdo_mysql”
    database_host=”localhost”
    database_port=””
    database_name=”s2″
    database_user=”root”
    database_password=””
    mailer_transport=”smtp”
    mailer_host=”localhost”
    mailer_user=””
    mailer_password=””
    locale=”es”
    secret=”xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx”
Será necesario crear un nuevo Bundle para poder ir introduciendo nuestro código en la aplicación.
Para ello deberemos ejecutar un comando en terminal de comandos llamando al php.exe, sí éste se ha incluido en el Path del sistema, podremos ejecutarlso simplemente escribiendo “php” en la línea de comandos, si no es así deberemos escribir la ruta completa al fichero php.exe desde el directorio de instalación de xampp, en el caso de la instalación por defecto sería “C:xamppphpphp.exe”.
Todos los comandos deberán ser ejecutados en el directorio de instalación de Symfony2.
El comando que debemos ejecutar para crear el Bundle es:

php app/console generate:bundle --namespace=Pepesan/NuevoBundle --format=yml 

He aquí una captura de la consola de Aptana (mi gestor de proyectos y editor de ficheros PHP), ejecutando el comando de consola…

aunque también podemos ejecutar todos los comandos desde el intérprete de comandos de Windows, como en esta captura…

Como puede observase en el comando:

  • Primero se llama al php.exe, sin poner la extensión, es el intérprete que vamso a utilizar para ejecutar el comando, en el ejemplo “php”
  • Después indicamos que queremos utilizar la consola de aplicaciones de symfony2, en el ejemplo “app/console”.
  • Después indicamos el comando en concreto que queremos ejecutar, la generación de un nuevo bundle, en el ejemplo “generate:bundle”.
  • Después indicamos el espacio de nombres del nuevo bundle, exactamente donde se va a guardar, indicando la ruta a partir del directorio src, en el ejemplo “–namespace=Pepesan/NuevoBundle”.
  • Después indicamos el formato que queremos utilizar para la configuración, en este caso YAML, en el ejemplo “–format=yml”

A continuación, veremos la salida del comando que acabamos de ejecutar,  donde el comando se verá la información y las preguntas que nos va haciendo y las contestaciones que debemos ir dando para seguir el ejemplo. Pondré en Itálica, la información que presenta el comando por sí mismo y en negrita lo que hago para continuar el comando:
 Welcome to the Symfony2 bundle generator

Your application code must be written in bundles. This command helps
you generate them easily.

Each bundle is hosted under a namespace (like Acme/Bundle/BlogBundle).
The namespace should begin with a “vendor” name like your company name, your
project name, or your client name, followed by one or more optional category
sub-namespaces, and it should end with the bundle name itself
(which must have Bundle as a suffix).

See http://symfony.com/doc/current/cookbook/bundles/best_practices.html#index-1
for more
details on bundle naming conventions.

Use / instead of for the namespace delimiter to avoid any problem.

Bundle namespace [Pepesan/NuevoBundle]: aquí pulso la tecla “enter”, porque me sirve ese espacio de nombres para el Bundle.

In your code, a bundle is often referenced by its name. It can be the
concatenation of all namespace parts but it’s really up to you to come
up with a unique name (a good practice is to start with the vendor name).
Based on the namespace, we suggest PepesanNuevoBundle.

Bundle name [PepesanNuevoBundle]: aqui vuelvo a pulsar la tecla “enter”, porque me sirve ese nombre para referenciar al Bundle, este nombre lo suaremos cuando queramos referenciar elementos de este Bundle en el código.

The bundle can be generated anywhere. The suggested default directory uses
the standard conventions.

Target directory [C:xampphtdocsSymfony/src]: Simplemente pulso la tecla “enter”, porque el directorio src me sirve para guardar las carpetas y ficheros del bundle.

Determine the format to use for the generated configuration.

Configuration format (yml, xml, php, or annotation) [yml]: vuelvo a pulsar “enter”, porque quiero usar el formato YAML para la configuración.

To help you getting started faster, the command can generate some
code snippets for you.

Do you want to generate the whole directory structure [no]? yes (pulso enter, despues de escribir “yes”, para aceptar que me genere el arbol completo de directorios del bundle)

  Summary before generation

You are going to generate a “PepesanNuevoBundlePepesanNuevoBundle” bundle
in “C:xampphtdocsSymfony/src/” using the “yml” format.

Do you confirm generation [yes]? aqui vuelvo a pulsar la tecla “enter”, para aceptar las configuraciones que me han resumido

  Bundle generation

Generating the bundle code: OK
Checking that the bundle is autoloaded: OK
Confirm automatic update of your Kernel [yes]?
pulso “enter”, porque quiero que me añada el Bundle automáticamente al kernel de mi apliciación, fichero “app/AppKernel.php”.
Enabling the bundle inside the Kernel: OK
Confirm automatic update of the Routing [yes]?
pulso “enter”, porque quiero que me incluya las rutas definidas en el Bundle en la aplicación, en el fichero “app/config/routing.yml”
Importing the bundle routing resource: OK

  You can now start using the generated code!

Una vez que terminamos de ejecutar el comando veremos que efectivamente me han creado, dentro del directorio “src” un directorio llamado “Pepesan” y dentro de ese directorio uno llamado “Nuevo Bundle”, que contendrá la esctructura del nuevo Bundle, similar a la que se muestra en la captura…

Como puede observarse con la ejecución del comando nos ha creado la estructura completa del Bundle:

  • Controller/ contiene los controladores de Bundle (p.e. NuevoController.php)
  • DependencyInjection/ contendrá el código de injección de pendencias del bundle
  • Resources/config/ guarda la configuración, incluyendo las rutas del bundle (p.e. routing.yml)
  • Resources/views/ almacena las plantillas de vista del bundle (p.e. Nuevo/index.html.twig)
  • Resources/public/ contiene los elementos de la web (imágenes, css, etc…) que será copiados o enlazados simbólicamente al directorio “web” mediante el comando “assets:install"
  • Tests/ almacena las pruebas del bundle

También si vemos el fichero “app/config/routing.yml”, veremos que nos ha incluido las siguientes líneas:
PepesanNuevoBundle:
    resource: “@PepesanNuevoBundle/Resources/config/routing.yml”
    prefix:   /

Y que nos ha modificado el fichero “app/AppKernel.php” pra incluir una línea en la carga de bundles:
$bundles = array(
            new SymfonyBundleFrameworkBundleFrameworkBundle(),
            new SymfonyBundleSecurityBundleSecurityBundle(),
            new SymfonyBundleTwigBundleTwigBundle(),
            new SymfonyBundleMonologBundleMonologBundle(),
            new SymfonyBundleSwiftmailerBundleSwiftmailerBundle(),
            new SymfonyBundleDoctrineBundleDoctrineBundle(),
            new SymfonyBundleAsseticBundleAsseticBundle(),
            new JMSSecurityExtraBundleJMSSecurityExtraBundle(),
            new AcmeDemoBundleAcmeDemoBundle(),
            new PepesanNuevoBundlePepesanNuevoBundle(),
        );

Con estas configuraciones ya tendremos el nuevo Bundle creado y configurada la aplicación para hacer uso del nuevo Bundle.

 

Importando el modelo en la base de datos

Para poder trabajar con datos en fundamental definirlos, digamos por ejemplo en la base de datos. Para empezar vamos a trabajar con una estructura sencilla, sólo una tabla en la base de datos. Para ello, usaremos el siguiente fichero de volcado de base de datos SQL…


— Estructura de tabla para la tabla `clientes`

CREATE TABLE IF NOT EXISTS `clientes` (
  `clienteid` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `nombre` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `tlf` varchar(20) COLLATE utf8_unicode_ci NOT NULL,
  `web` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
  `image` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
  `dir` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`clienteid`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci AUTO_INCREMENT=9 ;


— Volcado de datos para la tabla `clientes`

INSERT INTO `clientes` (`clienteid`, `nombre`, `tlf`, `web`, `image`, `dir`) VALUES
(1, ‘pepe’, ‘656661477’, ‘http://www.plexxoo.com’, ‘http://images.wikia.com/lotr/es/images/5/59/Eomer.jpg’, ‘calle de mi casa’),
(3, ‘pepe3’, ‘656661479’, ‘http://www.plexxoo.com’, ‘http://images.wikia.com/lotr/es/images/5/59/Eomer.jpg’, ‘calle de mi casa3’),
(4, ‘pepe3’, ‘656661479’, ‘http://www.plexxoo.com’, ‘http://images.wikia.com/lotr/es/images/5/59/Eomer.jpg’, ‘calle de mi casa3’),
(5, ‘pepe3’, ‘656661479’, ‘http://www.plexxoo.com’, ‘http://images.wikia.com/lotr/es/images/5/59/Eomer.jpg’, ‘calle de mi casa3’),
(7, ‘pepe’, ‘pp’, ‘pp’, ‘pp’, ‘pp’),
(8, ‘www’, ‘www’, ‘www’, ‘www’, ‘ww’);

Para importar este modelo, será necesario abrir el phpmyadmin, mediante la URL: http://localhost/phpmyadmin
veremos una pantalla similar a la siguiente…

pulsaremos sobre el enlace de la parte irzquierda de la pantalla, llamado como la base de datos que hemos creado “s2“, así veremos a estructura de la base de datos…

Pulsaremos sobre el botón SQL, para poder introducir el código SQL de generación de la tabla “clientes”…

pulsaremos en el botón “Continuar”, si todo ha ido bien, no debería sacar ningún mensaje de error y al pulsar sobre el botón “Estructura”, deberíamos poder ver la tabla en el listado, tal como aparece en la siguiente captura…

Al terminar este paso, ya dispondremos de una tabla con datos iniciales en la base de datos contra la que está configurada la aplicación de Symfony2.

Importando el modelo de la base de datos con Doctrine

Una vez que disponemos de un modelo ya en la base de datos, será necesario importarlo para generar los ficheros de Entidad de Doctrine para así disponer de una manera de consultar y manejar la tabla de la base de datos con el Bundle de nuestra aplicación Symfony2.
Para ello tenemos que seguir una serie de pasos:

  1. Generar un fichero de configuración XML, teniendo como modelo las tablas de la base de datos.
  2. Generar las entidades en base a ese modelo XML.
  3. Usar esas entidades en los controladores del bundle.

Para generar el fichero XML de configuración debemos ejecutar otro comando de Symfony2:

php app/console doctrine:mapping:convert xml ./src/Pepesan/NuevoBundle/Resources/config/doctrine/metadata/orm --from-database --force

Como puede observase en el comando:

  • Primero se llama al php.exe, sin poner la extensión, es el intérprete que vamso a utilizar para ejecutar el comando, en el ejemplo “php”
  • Después indicamos que queremos utilizar la consola de aplicaciones de symfony2, en el ejemplo “app/console”.
  • Después indicamos el comando en concreto que queremos ejecutar, la generación de un nuevo fichero de mapping (relación entre campos de la base de datos y atributos de los objetos de Doctrine), en el ejemplo “doctrine:mapping:convert”
  • Después indicamos el formato que queremos utilizar para el fichero, en el ejemplo “xml”
  • Después indicamos donde queremos guardar el fichero, en el ejemplo “./src/Pepesan/NuevoBundle/Resources/config/doctrine/metadata/orm”
  • Después indicamos desde donde queremos coger la información que vamos a guardar en el XML, en ejemplo “–from-database”
  • Por último indicamos que queremos que fuerce la generación sobreescribiendo lo que sea necesario, en el ejemplo “–force”

 Si todo ha ido correctamente deberíamos ver una salida similar a la que aparece en la captura…

como resultado nos sacará el mensaje…
Processing entity “Clientes”

Exporting “xml” mapping information to “C:xampphtdocsSymfonysrcPepesanNuevoBundleRes
ourcesconfigdoctrinemetadataorm”

Y dispondremos de un cambio en la estructura del bundle, nos habrá creado un nuevo fichero en el directorio “PepesanNuevoBundleResourcesconfigdoctrinemetadataorm” llamado “clientes.orm.xml” que tendrá el contenido del mapping de la base de datos…
<?xml version=”1.0″ encoding=”utf-8″?>
<doctrine-mapping xmlns=”http://doctrine-project.org/schemas/orm/doctrine-mapping” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://doctrine-project.org/schemas/orm/doctrine-mapping http://doctrine-project.org/schemas/orm/doctrine-mapping.xsd”>
  <entity name=”Clientes” table=”clientes”>
    <change-tracking-policy>DEFERRED_IMPLICIT</change-tracking-policy>
    <id name=”clienteid” type=”integer” column=”clienteid”>
      <generator strategy=”IDENTITY”/>
    </id>
    <field name=”nombre” type=”string” column=”nombre” length=”50″/>
    <field name=”tlf” type=”string” column=”tlf” length=”20″/>
    <field name=”web” type=”string” column=”web” length=”255″/>
    <field name=”image” type=”string” column=”image” length=”255″/>
    <field name=”dir” type=”string” column=”dir” length=”255″/>
    <lifecycle-callbacks/>
  </entity>
</doctrine-mapping>

Como puede verse en el fichero, se establece una relación o mapping, entre la tabla “clientes”  y la Entidad “Clientes”, relacionando todos los atributos de la nueva Entidad con los campos de la tabla.

Generando las Entidades

Ahora deberemos importar este XML para generar los ficheros de Clases Entidad, para ello deberemos ejecutar dos comandos.
El primero es el siguiente:

php app/console doctrine:mapping:import PepesanNuevoBundle annotation

Como puede observase en el comando:

  • Primero se llama al php.exe, sin poner la extensión, es el intérprete que vamso a utilizar para ejecutar el comando, en el ejemplo “php”
  • Después indicamos que queremos utilizar la consola de aplicaciones de symfony2, en el ejemplo “app/console”.
  • Después indicamos el comando en concreto que queremos ejecutar, la importación en el bundle del fichero de mapping XML, en ejemplo “doctrine:mapping:import”
  • Después indicamos el bundle donde queremos importar el fichero, en el ejemplo “PepesanNuevoBundle”
  • Por último, indicamos cómo queremos manejar el mapping, en este caso como anotaciones en el código, en el ejemplo “annotations”

 Así tendremos una salida similar a la de la captura…

donde nos informa de que ha generado correctamente el fichero de Entidad “Clientes.php”…
Importing mapping information from “default” entity manager
  > writing C:xampphtdocsSymfonysrcPepesanNuevoBundle/Entity/Clientes.php
Dicho fichero se coloca en el directorio “Entity” de nueva creación en el directorio del Bundle, si miramos su contenido veremos lo siguiente…
<?php

namespace PepesanNuevoBundleEntity;

use DoctrineORMMapping as ORM;

/**
 * PepesanNuevoBundleEntityClientes
 *
 * @ORMTable(name=”clientes”)
 * @ORMEntity
 */
class Clientes
{
    /**
     * @var integer $clienteid
     *
     * @ORMColumn(name=”clienteid”, type=”integer”, nullable=false)
     * @ORMId
     * @ORMGeneratedValue(strategy=”IDENTITY”)
     */
    private $clienteid;

    /**
     * @var string $nombre
     *
     * @ORMColumn(name=”nombre”, type=”string”, length=50, nullable=false)
     */
    private $nombre;

    /**
     * @var string $tlf
     *
     * @ORMColumn(name=”tlf”, type=”string”, length=20, nullable=false)
     */
    private $tlf;

    /**
     * @var string $web
     *
     * @ORMColumn(name=”web”, type=”string”, length=255, nullable=false)
     */
    private $web;

    /**
     * @var string $image
     *
     * @ORMColumn(name=”image”, type=”string”, length=255, nullable=false)
     */
    private $image;

    /**
     * @var string $dir
     *
     * @ORMColumn(name=”dir”, type=”string”, length=255, nullable=false)
     */
    private $dir;

}

Si observamos el fichero generado con un poco más de calma, nos fijamos en las dos inclusiones de código:

  • El namespace, con la localización del fichero en el Bundle.
  • El Use con la inclusión de la biblioteca de ORM-Mapping de Doctrine, de esta manera disponemos de unos comentarios similares al uso de las entidades JPA de J2EE, pero en Symfony2
  • El código comentado indicando la relación de la entidad con la tabla
  • El nombre de la clase como el nombre de la tabla, salvo porque la primera letra es mayúscula
  • Y luego indicando atributo a atributo, su relación con los nombres de campos de la tabla y sus validaciones, con especial atención a la clave primaria de tabla, que actua como identificativo único de la entidad.

Después de esto ejecutamos el último comando:
php app/console doctrine:generate:entities PepesanNuevoBundle
Como puede observase en el comando:

  • Primero se llama al php.exe, sin poner la extensión, es el intérprete que vamso a utilizar para ejecutar el comando, en el ejemplo “php”
  • Después indicamos que queremos utilizar la consola de aplicaciones de symfony2, en el ejemplo “app/console”.
  • Después indicamos el comando en concreto que queremos ejecutar, generación de las entidades y su puesta en marcha, en ejemplo “doctrine:generate:entities”
  • Después indicamos el bundle donde queremos generar las entidades, en el ejemplo “PepesanNuevoBundle”

Tal como se puede ver en la siguiente captura…

 la salida nos indica lo siguiente…
Generating entities for bundle “PepesanNuevoBundle”
  > backing up Clientes.php to Clientes.php~
  > generating PepesanNuevoBundleEntityClientes

Nos hace un backup del fichero Clientes.php y nos sobre escribe el fochero Clientes.php con el siguiente contenido…
<?php

namespace PepesanNuevoBundleEntity;

use DoctrineORMMapping as ORM;

/**
 * PepesanNuevoBundleEntityClientes
 *
 * @ORMTable(name=”clientes”)
 * @ORMEntity
 */
class Clientes
{
    /**
     * @var integer $clienteid
     *
     * @ORMColumn(name=”clienteid”, type=”integer”, nullable=false)
     * @ORMId
     * @ORMGeneratedValue(strategy=”IDENTITY”)
     */
    private $clienteid;

    /**
     * @var string $nombre
     *
     * @ORMColumn(name=”nombre”, type=”string”, length=50, nullable=false)
     */
    private $nombre;

    /**
     * @var string $tlf
     *
     * @ORMColumn(name=”tlf”, type=”string”, length=20, nullable=false)
     */
    private $tlf;

    /**
     * @var string $web
     *
     * @ORMColumn(name=”web”, type=”string”, length=255, nullable=false)
     */
    private $web;

    /**
     * @var string $image
     *
     * @ORMColumn(name=”image”, type=”string”, length=255, nullable=false)
     */
    private $image;

    /**
     * @var string $dir
     *
     * @ORMColumn(name=”dir”, type=”string”, length=255, nullable=false)
     */
    private $dir;

    /**
     * Get clienteid
     *
     * @return integer
     */
    public function getClienteid()
    {
        return $this->clienteid;
    }

    /**
     * Set nombre
     *
     * @param string $nombre
     */
    public function setNombre($nombre)
    {
        $this->nombre = $nombre;
    }

    /**
     * Get nombre
     *
     * @return string
     */
    public function getNombre()
    {
        return $this->nombre;
    }

    /**
     * Set tlf
     *
     * @param string $tlf
     */
    public function setTlf($tlf)
    {
        $this->tlf = $tlf;
    }

    /**
     * Get tlf
     *
     * @return string
     */
    public function getTlf()
    {
        return $this->tlf;
    }

    /**
     * Set web
     *
     * @param string $web
     */
    public function setWeb($web)
    {
        $this->web = $web;
    }

    /**
     * Get web
     *
     * @return string
     */
    public function getWeb()
    {
        return $this->web;
    }

    /**
     * Set image
     *
     * @param string $image
     */
    public function setImage($image)
    {
        $this->image = $image;
    }

    /**
     * Get image
     *
     * @return string
     */
    public function getImage()
    {
        return $this->image;
    }

    /**
     * Set dir
     *
     * @param string $dir
     */
    public function setDir($dir)
    {
        $this->dir = $dir;
    }

    /**
     * Get dir
     *
     * @return string
     */
    public function getDir()
    {
        return $this->dir;
    }
}
De esta manera nos incluye los método principales de manejo de los datos de la clase Clientes, denominados getter y setters.

Generando un CRUD básico desde una Entidad Doctrine

Una de las cuestiones principales la ahora de gestionar datos es la generación de las operaciones web de manejo de los datos.
La operaciones básicas del CRUD son:

  • Listar
  • Añadir
  • Mostrar
  • Editar
  • Borrar

Para ello utilizaremos la entidad “Clientes” como base de la generación de un Controlador CRUD web.
Para que funcione correctamente la generación será necesario modificar el fichero Clientes.php para que el atributo de la clave primaria de llame “$id” en vez de “$clientesid” de la siguiente manera…
/**
     * @var integer $id
     *
     * @ORMColumn(name=”clienteid”, type=”integer”, nullable=false)
     * @ORMId
     * @ORMGeneratedValue(strategy=”IDENTITY”)
     */
    private $id;

También será necesario cambiar el método getClientesid podniendo lo siguiente:
/**
     * Get id
     *
     * @return integer
     */
    public function getId()
    {
        return $this->id;
    }
Como puede observarse lo único que se han cambiado son los comentarios que están colocados antes de la definición del atributo, el nombre del propio atributo, el método de obtención de datos del atributo $id, todo lo demás en el fichero permanecerá constante.
A continucación ejecutaremos el comando:
php app/console generate:doctrine:crud –entity=PepesanNuevoBundle:Clientes –format=yml
 –with-write

Como puede observase en el comando:

  • Primero se llama al php.exe, sin poner la extensión, es el intérprete que vamso a utilizar para ejecutar el comando, en el ejemplo “php”
  • Después indicamos que queremos utilizar la consola de aplicaciones de symfony2, en el ejemplo “app/console”.
  • Después indicamos el comando en concreto que queremos ejecutar, generación un CRUD a través de las entidades doctrine, en ejemplo “generate:doctrine:crud”
  •  Después indicamos el nombre de la entidad en base a la cual queremos generar el CRUD, en el ejemplo “–entity=PepesanNuevoBundle:Clientes”
  • Por último indicamos el formato de las rutas de URL que queremos utilizar, en este caso YAML, en el ejemplo, “–format=yml”

Con este ocmando dispondremos también de una salida compleja, en itálica veremos la salida estándar y en negrita las pulsaciones de teclado…
 Welcome to the Doctrine2 CRUD generator

This command helps you generate CRUD controllers and templates.

First, you need to give the entity for which you want to generate a CRUD.
You can give an entity that does not exist yet and the wizard will help
you defining it.

You must use the shortcut notation like AcmeBlogBundle:Post.

The Entity shortcut name [PepesanNuevoBundle:Clientes]: Pulsamos “Enter”

By default, the generator creates two actions: list and show.
You can also ask it to generate “write” actions: new, update, and delete.

Do you want to generate the “write” actions [yes]?Pulsamos “Enter”

Determine the format to use for the generated CRUD.

Configuration format (yml, xml, php, or annotation) [yml]:Pulsamos “Enter”

Determine the routes prefix (all the routes will be “mounted” under this
prefix: /prefix/, /prefix/new, …).

Routes prefix [/clientes]:Pulsamos “Enter”


  Summary before generation

You are going to generate a CRUD controller for “PepesanNuevoBundle:Clientes”
using the “yml” format.

Do you confirm generation [yes]?Pulsamos “Enter”

  CRUD generation

Generating the CRUD code: OK
Generating the Form code: OK
Confirm automatic update of the Routing [yes]?
no ( y pulsamos “Enter”)
Importing the CRUD routes: FAILED

  The command was not able to configure everything automatically.
  You must do the following changes manually.

– Import the bundle’s routing resource in the bundle routing file
  (C:xampphtdocsSymfonysrcPepesanNuevoBundle/Resources/config/routing.yml).

    PepesanNuevoBundle_clientes:
        resource: “@PepesanNuevoBundle/Resources/config/routing/clientes.yml”
        prefix:   /clientes

Como nos indica la salida no se ha podido configurar automaticamente las rutas, pero nos dice la solución al problema, includir el fichero de rutas del bundle desde la configuración de la rutas de la aplicación De esta manera copiaremos el código:
    PepesanNuevoBundle_clientes:
        resource: “@PepesanNuevoBundle/Resources/config/routing/clientes.yml”
        prefix:   /clientes

y lo pegaremos al final del fichero app/config/routing.yml.
De esta manera incluimos la condifuración de rutas del bundle en la aplicación por que al entrar en la URL: http://localhost/s2/web/app_dev.php/clientes deberíamos ver una pantalla similar a la siguiente…

En la siguiente entrega veremos cómo funciona el código generado y cómo empezar a modificar los comportamientos web por defecto del CRUD.



Referencias:

Curso de Symfony 2 (II): Instalación y Configuración

Por lo tanto los requisitos de instalación para este tutorial son lo siguientes:

Instalación de XAMPP

A continuación  seguimos los pasos de este tutorial del ministerio de educación. O bien podemos descargarnos el ejecutable autoinstalable con asistente, el típico .exe de instalación de siguiente, siguiente… Finalizar.

Una vez instalado XAMPP, digamos en el directorio c:xampp, por poner un ejemplo, abrimos la carpeta con el explorador de carpetas.
Veremos un ejecutable llamado: xampp-control.exe , lo ejecutamos con un doble click y nos parecerá la pantalla de manejo de servidores de XAMPP.
Cada vez que queramos que cualqueir aplicación web funcione será necesario tener arancado los servidores Apache y Mysql, para esto basta con pulsar sobre los iconos Start, que están al lado de Apache primero y luego de Mysql.
Si todo ha ido bien, al lado del nombre de Apache y Mysql debería apareces un etiqueta con fondo verde con el texto “Running”.
Para verificar la instalación de XAMPP, bastará con entrar a la siguiente dirección URL, a través de nuestro navegador favorito: http://localhost/phpmyadmin
Si la instalación y el arranque de los servicios ha sido correcta, Deberíamos ver el listado de bases de datos disponibles en Mysql desde el interfaz web de PhpMyAdmin.
Los datos de conexión a Mysql por defecto en la instalación de Mysql en XAMPP son los siguientes:

  • Servidor: localhost
  • Puerto: 3306
  • Usuario: root
  • Contraseña: vacía (significa que no tiene contraseña ni es necesario introducirla para conectar)

Colocación del php.exe en el Path

En Windows, para poder ejecutar los comandos de Symfony 2, es necesario poner la ruta donde se encuentra el fichero php.exe en la variable de entorno Path. Esta configuración requiere habitualmente permisos de administración.
Para ello pulsa el botón derecho sobre el Botón o Icono de Equipo, selecciona propiedades. Aparecerá la pantalla de configuración del sistema, en Windows 7 se llama Sistema, pulsamos en “Configuración avanzada del sistema”, pulsamos en el botón “Variables de entorno…”, en el apartado de Variables de sistema buscamos la variable “Path”, la seleccionamos y pulsamos sobre el botón “Editar…” y en el valor añadirmos la ruta al directorio de instalación de PHP de XAMPP, en el caso de la instalación sin modificarlas rutas, es “c:xamppphp”. Pulsamos en Aceptar y otra vez en aceptar y ya estará configurada la variable Path correctamente. De esta manera podremos ejecutar el php.exe desde cualquier directorio.

Conclusiones

Con esto tenemos todo lo necesario para poder instalar Symfony 2 en nuestro ordenador, más adelante detallaremos los pasos necesarios para su subida a producción, o dicho de otra forma, a un hosting para publicar el sitio web en Internet.

 Instalación de Symfony 2

Descargamos el fichero zip y lo descomprimimos en la carpeta htdocs del directorio de instalación de XAMPP, si hemos dejado las rutas de instalación por defecto, deberíamos descomprimirlo en C:xampphtdocs.
Renombramos la carpeta con el nombre s2 para facilitar la escritura de las URL’s y los directorios.
De esta manera deberíamos tener accesible esa carpeta a través de la URL: http://localhost/s2
Si miramos el contenido de la carpeta s2 nos encontraremos el siguiente contenido:

  • Diretorio app: donde se guardan las configuraciones de las aplicaciones
  • Directorio bin: donde se encuentran los ejecutables
  • Directorio src: donde se almacena el código fuente de las aplicaciones
  • Directorio Vendor: donde se almacenan los bundles del framework de Symfony y otros componentes
  • Directorio web: donde se colocan los ficheros que deben ser accesibles desde URL
  • deps: fichero de dependencias
  • deps.lock: fichero de versiones de dependencias
  • License: fichero de licencia
  • Readme.md: fichero de instrucciones de instalación y configuración básicas

    Creando la Base de datos inicial

    Esta tarea podemos realizarla desde el PhpMyAdmin a través de la URL: http://localhost/phpmyadmin
    Una vez abierto el navegador en esa dirección, aparecerá el listado de bases de datos, similar al siguiente:

    Pulsamos sobre el Icono “Bases de Datos” en el menu superior de PhpMyAdmin, aparecerá el formulario de creación de bases de datos, le damos un nombre, por ejemplo “s2” y pulsamos en el boton “Crear”.

    Deberíamos ver un mensaje que nos muestra que la base de datos ha sido creada satisfactoriamente.

    Los datos de configuración de la base de datos que hemos creado son:

    • Servidor: localhost
    • Puerto: 3306
    • Usuario: root
    • Contraseña: vacía (significa que no tiene contraseña ni es necesario introducirla para conectar)
    • Base de datos: s2

     Configuración de una aplicación Symfony 2

    A continuación, entramos en la URL: http://localhost/s2/web/config.php
    Entonces veremos una pantalla similar a la siguiente…

    Pulsaremos sobre el enlace “Configure yout Symfony Application online”, si todo ha ido bien, deberíamos ver una pantalla de configuración de la base de datos de la nueva aplicación, similar a la siguiente…

     Introducimos los datos de conexión a la BBDD que hemos gestionado con el PhpMyAdmin y pulsamos en el botón “Next Step”.
    A continuación veremos la pantalla de configuración de una cadena Secret, similar a la siguiente…

    simplemente dejaremos el valor que nos ha generado y pulsamos en el botón “Next Step”. Si todo ha ido correcto, deberíamos ver una pantalla similar a la siguiente…

    donde nos felicita porque la instalación se ha realizado satisfactoriamente y nos hace un resumen de las configuraciones que ha colocado a la aplicación. Si deseamos cambiar el fichero de configuración donde se almacenan estos parámetros deberemos ir al directorio app/config y editar el fichero parameters.yml, por ejemplo para cambiar el idioma, el parámetro “locale” en el fichero, y poner “es” en vez de “en”.
    Para terminar con la instalación, pulsaremos en el enlace “Go to Wellcome Page” o la URL: http://localhost/s2/web/app_dev.php/
    Con esto entraremos al entorno de desarrollo de la aplicación y veremos una página similar a la siguiente…

    Si somos capaces de ver esta página, significa que la aplicación Symfony se ha generadoy configurado satisfactoriamente y ya podemos pasar al desarrollo de nuestra aplicación web.

    Licencia Creative Commons

    Curso de Symfony 2 (I): Conceptos fundamentales

    Este conjunto de tutoriales tratarán sobre el desarrollo de aplicaciones web con Symfony 2.0
    En este primer tutorial trataremos de explicar los conceptos fundamentales del Framework de Symfony 2.0, para que así las siguientes entregas se puedan llegar a entender mucho más facilmente.

    El glosario de términos que utilizaremos son los siguientes:

    • HTTP/S: protocolo principal de la web.
    • Petición: información enviada desde el cliente HTTP al servidor.
    • URL: Parte de la petición HTTP que define entre otras cosas el servidor, la ruta el fichero y un conjunto de parámetros.
    • Respuesta: información devuelta por parte del servidor al cliente.
    • Base de Datos: fuente de información estructurada en tablas, campos y relaciones.
    • Modelo-Vista-Controlador: patrón de diseño de aplciaciones de tres capas.
    • Modelo: conjunto de clases y objetos que manejan la conexión y las consultas a la base de datos.
    • Control: conjunto de clases que gestionan y procesan la información y la lógica de negocio de una aplicación.
    • Vista: conjunto de ficheros que componen el apartado visual de una aplicación, con lo que interactúa el usuario.
    • Controlador Principal Web: Clase principal que captura las peticiones entrantes de una aplicación web y pasa el control a las distintas funcionalidades de la aplicación web.
    • Módulo: agrupación de funcionalidades de una aplicación. Una aplicación suele contener distintos módulos. Por ejemplo, la gestión de clientes.
    • Acción: funcionalidad específica de un módulo, por ejemplo, dar de alta un cliente.
    • Plantilla: fichero que permite la generación dinámica de una vista de un módulo, por ejemplo la vista que presenta la información de un cliente.
    • Controlador de Módulo: Clase que implementa las funcionalidades del Control de un Módulo.
    • Bundle o Componente:  conjunto de funcionalidades de alto nivel, podría decirse que es un conjunto de módulos.
    • Framework: conjunto de herramientas y bibliotecas que facilitan la tarea del programados a la hora de desarrollar aplicaciones.

    Flujo de la gestión de una petición con Symfony 2

    Una de las cuestiones principales a la hora de entender un nuevo framework web, es la manera en la cual se gestionan las peticiones web internamente, de cara a comprender qué pasos van dándose hasta la resolución de una petición.
    Gracias al libro de Symfony 2 disponemos de un gráfico revelador respecto al funcionamiento interno de Symfony 2.

    Como puede observarse en este diagrama, las distintas peticiones son gestionadas por un Controlador Principal de la Aplicación Web o Control de la Aplicación. Como sucede en otros frameworks, como Spring, todas las peticiones son despachadas por este controlador principal, el cual trata de averiguar que parte de la aplicación debe ser ejecutada para resolver la petición.
    La localización de la funcionalidad se realiza a través de un sistema de routing, o mapping, como quiera verse, en el que se relacionan las distintas direcciones URL con las funcionalidades existentes en la aplicación.
    Una vez localizada la funcionalidad a ejecutar, se cede el control a un Controlador de módulo el cual ejecuta la Acción específica que resolverá la petición generando una Respuesta.

    Componentes principales

    Los componentes principales de Symfony 2 son los siguientes:

    • HttpFundation: contiene las clases Request y Response, entre otras
    • Routing: sistema de enrutado de peticiones
    • Form: clases de manejo de formularios y envíos
    • Validator: clases de validación de datos
    • ClassLoader: sistema de carga de clases
    • Templating: sistema de gestión de plantillas
    • Security: herramientas de seguridad
    • Translation: sistema de traducciones

    Referencias: 

    Symfony 2.0 Book: http://symfony.com/doc/current/book/index.html

    Licencia Creative Commons

    Curso de Drupal 7 (IX): Módulos

    Los módulos en Drupal tienen variadas funciones, tales como añadir nuevos tipos de datos, nuevos tipos de contenido y en general añadir nuevas funcionalidades al sitio web.
    Los módulos principales de Drupal se agrupan en una categoría denominada Núcleo (Core), que son aquellos módulos incluidos con la distribución principal de Drupal.

    Dependencias

     Las dependecias son una manera de plantear los requisitos de los módulos. Como toda pieza de software, los módulos tienen requisitos, o dicho de otro modo, dependen de la existencia de otras piezas de software, en el caso de los módulos, otros módulos que estén instalados y activados para permitir su correcto funcionamiento.
    En la mayor parte de las descripciones de los módulos podemos encontrar debajo del texto descriptivo de la funcionalidad del módulo, un conjunto de listados de módulos que antuan bajo el sistema de dependencias de Drupal.
    De esta manera podemos ver de una manera bastante sencilla, que módulos son necesarios para que un módulo pueda activarse y usarse con normalidad, estos módulos se presentarán en la etiqueta “Necesita”.
    Por otra parte puede pasar que un módulo sea dependencia de otros módulos, es decir, que sea necesario que esté activado y configurado para poder activar otros módulos. Estos módulos dependientes del nuestro se presentarán bajo la etiqueta “Necesitado por”.
    Por ejemplo en el listado inicial de módulos, después de realizar la instalación Standard, puede observarse que el módulo “Comment”, que es el que se encarga de gestionar los comentarios sobre los contenidos del sitio web, “Necesita” para poder funcionar de que los módulos “Text”, “Field” y “Field SQL Storage” estén instalados y activados. Mientras que los módulos “Forum” y Tracker dependen de que el módulo “Comment”esté instalado y configurado.

    Listado de módulos

    Para ver aquellos módulos instalados en nuestro sitio web debemos pulsar en el enlace “Módulos” dentro de la configuración o en la barra de tareas,así veremos un lisado similar al siguiente…


    Como puede observarse accedemos directamente al listado de módulos instalador en nuestro sitio web. Los módulos están estructurados por categorías principales, en este caso en concreto, sólo existe una categoría que es la de Núcleo (Core).
    En cada categoría pueden observarse los siguientes campos:

    • Activado: Checkbox que nos permite activar o desactivar un determinado módulo. si se activa podrán usarse las funcionalidades que añade dicho módulo, sino no.
    • Nombre.
    • Versión.
    • Descripción:
    • Operaciones.

    Las operaciones disponibles a través de este listado son las siguientes:

    • Activar Desactivar un módulo.
    •  Instalar nuevo módulo.
    • Ayuda.
    • Permisos: así podremos configurar los permisos del sitio web respecto a los roles dados de alta. Ver el punto VII del curso.
    • Configurar: enlace a la configuración del módulo.Como cada módulo es una funcionalidad distinta las capacidades configurables de cada módulo varían de uno a otro. la mayor parte de los módulos Núcleo de Drupal, con configurables, de una u otra manera a través de la barra de tareas.

    Activar/desactivar módulos

    Se realiza mediante la checkbox presente en cada fila de la tabla del lisatdo de módulos, luego pulsamos en “Guardar configuración”, cuando hayamos terminado de  activar o desactivar módulos. Hay determinadas checkbox que no pueden activarse o desactivarse dentro de en Nucleo. normalmente suele pasar que dichos módulos son los mínimos para el funcionamiento de Drupal.
    La activación de módulos instalados requerirá que los módulos de los que depende el módulo que vayamos a activar, estén instalados y activados.

    Localización de Módulos

    Una de las tareas fundamentales en la generación de un sitio web con drupal es la localización de módulos que cubran los requisitos que tenemos de construcción para el sitio web. La fuente principal para localizar los módulos escritos para drupal es la propia web de Drupal: http://drupal.org/project/modules tal y como se observa en la siguiente captura…

    como puede verse, la localización de los módulos en muy similar a la de la localización de los Temas (o Themes).
    Disponemos de un buscador donde podemos filtrar por:

    • Categoría del módulo: donde indicamos la funcionalidad principal que buscamos para el módulo.
    • Filtar por compatibilidad: así podemos selccionar la versión de drupal para la que queremos encontrar un módulo.
    • Estado del proyecto: dependiendo del estado actual de madurez del proyecto
    • Cuadro de texto: para buscar por el nombre o la descripción del módulo.
    • Ordenar: de esta manera podemos ordenar los resultados dependiendo de su relevancia, número de instalaciones, etc…

    De esta manera podemos observar muy fácilmente cuales son los 10 módulos más usados para la versión 7 de drupal:

    • Views: permite hacer búsquedas sobre contenidos y modificar la presentación de los mismos.
    • Token: permite colocar códigos en los contenidos que tengan una representación de un dato.
    • Pathauto: permite  generar automáticamente los paths para los contenidos principales de drupal.
    • Chaos tool suite: conjunto de apis que permiten la gestión de páginas como paneles.
    • CCK: permite añadir campos personalizados a contenidos.
    • Administration Menu: mejora del menú de administración.
    • Wysiwyg: permite integrar fácilmente un editor visual de código HTML.
    • Date: permite manejar campos de fecha en los contenidos.
    • Google Analytics: sistema de integración de google analytics en Drupal.

    Página de un módulo

    Usando como ejemplo la página del módulo “IMCE” explicaremos las información relevantes presentes en cualquier página de un módulo…

    Como puede observarse a parte del nombre del módulo, su descripciín y el enlace al código fuente. en la página pueden mostrarse más informaciones del módulo, tales como:

    • Capturas
    • Información del proyecto (Project Information): donde pueden verse informacioens importantes, como por ejemplo: El estado del mantenimiento, o el estado del desarrollo, sus categorías, etc..
    • Descargas (Downloads): donde pueden descargarse los ficheros (uno por versión y estado del desarrollo) comprimidos que permiten la instalación del proyecto.
    • Recursos (Resources): aquí normalmente se encuentra el enlace a la documentación.

    Cómo elegir una versión del módulo

    En este caso, IMCE, al ser un módulo desarrollado desde hace bastante tiempo, dispone de versión para Drupal 6 y para Drupal 7 en su versión “Recommended” o estable. El número de versión de los ficheros permite saber para que versión de Drupal está disponible la descarga, es decir cual descargar para nuestra versión de Drupal.
    De esta manera, la versión 7.x-1.5, significa que esta versión está desarrollada para las versiones de Drupal 7.x (siendo x cualquier valor, inicialmente) y se trata de la versión 1.5 del módulo.
    Por lo que si queremos instalar el módulo para Drupal 7 deberíamos descargarnos o copiar la URL de esa versión.
    Si deseamos descargar el módulo o copiar la URL de instalación, será necesario decidir que con qué versión hacemos, si la versión en Zip o en TGZ. Usualmente los ordenadores windows manejarán más facilmente la versión en Zip, los ordenadores en Linux soportan perfectamente la versión TGZ.
    En nuestro caso al estar en un windows elegiremos la versión en Zip para Drupal 7, versión estable, lease: http://ftp.drupal.org/files/projects/imce-7.x-1.5.zip

    Instalar un módulo

    Desde el listado de módulos tenemos disponible un enlace denominado “Instalar nuevo módulo”, cuando lo pulsamos aparece una pantalla similar a la siguiente…

    Como puede observarse, nos ofrecen dos posibilidades para la instalación del módulo: mediante una ruta URL o subiendo el fichero comprimido a través del formulario.
    una vez relelnado el campo con la URL o selccionado el fichero comprimido del módulo a través del botón examinar, pulsamos en el botón “Instalar”.
    Entonces se verá una barra de progreso de la instalación del módulo y posteriormente, si todo ha ido bien, saldrá una pantalla similar a la siguiente…

    Después pulsaremos en el enlace “enable newly added modules” ó “activar los módulos recientemente instalados” y volveremos al listado de módulos, donde podremos ver nuestro módulo instalado…

    Licencia Creative Commons

    Suscríbete al Boletín

    Si quieres estar al tanto de las novedades del blog, ya sabes :)
    * = campo obligatorio

    powered by MailChimp!

    Uso de cookies

    Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información. ACEPTAR

    Aviso de cookies