En este primer post procederemos a su instalación. Personalmente, me gusta programar en local (en mi propio ordenador) y una vez haya acabado con el desarrollo o quiera probarlo en un entorno de producción, hacer el deploy a un servidor real. Por ello, primero voy a explicar como configurar un servidor web en nuestro ordenador y después procederemos con la instalación de Symfony2.

La instalación la voy a hacer en un entorno Linux con la distribución Ubuntu 11.04. Adaptar los comandos según nuestra distribución (o sistema operativo).

1) Primero instalamos Apache

# apt-get install apache2 apache2.2-common apache2-utils ssl-cert  apache2-mpm-prefork

2) Instalamos y habilitamos el módulo para utilizar modrewrite

# apt-get install libapache2-mod-proxy-html

Para habilitar el modulo en apache, ejecutamos:

# a2enmod rewrite

3) Instalamos PHP5

# apt-get install php5 libapache2-mod-php5 php5-common php5-intl

4) Instalamos Mysql

# apt-get install mysql-server mysql-client php5-mysql

5) Por último instalamos phpmyadmin (opcional)

# apt-get install phpmyadmin

Con estos sencillos pasos ya tendremos un servidor web instalado en nuestro ordenador.

Ahora continuamos con la instalación de Symfony2. Mi IDE favorito para programar es Netbeans, por lo que es el que utilizaré en este ejemplo. Si no lo hemos cambiado, nuestro workspace (donde se encuentran los proyectos a los que podemos acceder desde Netbeans) lo encontraremos en la carpeta NetBeansProjects en nuestra carpeta Home.

Procedemos a crear una nueva carpeta con el nombre de nuestro proyecto en el workspace de Netbeans:

$ mkdir $HOME/NetBeansProjects/miproyecto

Entramos en la carpeta que acabamos de crear:

$ cd $HOME/NetBeansProjects/miproyecto

Descargamos Symfony2 (comprueba la última versión en http://symfony.com/download):

$ wget http://symfony.com/download?v=Symfony_Standard_Vendors_2.0.0-RC4.tgz

Y descomprimimos:

$ tar zxvf Symfony_Standard_Vendors_2.0.0-RC4.tgz

Borramos el archivo comprimido que hemos descargado:

$ rm Symfony_Standard_Vendors_2.0.0-RC4.tgz

Ya tenemos instalado un proyecto básico en Symfony2. Ahora vamos a configurar Apache para poder acceder desde nuestro navegador favorito.

Creamos un nuevo archivo donde irá la configuración de nuestra web:

# vi /etc/apache2/sites-available/miproyecto

Que contendrá el siguiente contenido (cambia “jonseg” por el nombre de tu carpeta Home):

<VirtualHost *:80>
   ServerAdmin email@email.com
   DocumentRoot /home/jonseg/NetBeansProjects/miproyecto/Symfony/web
   ServerName miproyecto.com
   ServerAlias *.miproyecto.com
   ErrorLog /var/log/apache2/miproyecto_error.log
   CustomLog /var/log/apache2/miproyecto_access.log common
   DirectoryIndex index.php
   <Directory "/home/jonseg/NetBeansProjects/miproyecto/Symfony/web">
        Options Indexes FollowSymLinks
        Order Allow,Deny
        Allow from all
        AllowOverride all
        <IfModule mod_php5.c>
           php_admin_flag engine on
           php_admin_flag safe_mode off
           php_admin_value open_basedir none
        </ifModule>
   </Directory>
</VirtualHost>

Creamos un enlace simbólico de este archivo en sites-enabled para indicar que es una web activa:

# ln -s /etc/apache2/sites-available/miproyecto /etc/apache2/sites-enabled/miproyecto

Para que se apliquen los cambios, reiniciamos el servidor Apache:

# /etc/init.d/apache2 restart

Por último, forzamos en el archivo /etc/hosts la ip de nuestra web, que en este caso será localhost o 127.0.0.1

# vim /etc/hosts

Y añadimos esta línea al final del fichero:

127.0.0.1 www.miproyecto.com miproyecto.com

Después de todo esto, ya podremos acceder a nuestro nuevo proyecto en Symfony2 desde el navegador escribiendo la url que hemos configurado.

Como primer paso, debemos comprobar si cumplimos con la configuración básica para que funcione nuestro proyecto. Lo haremos desde la siguiente url:

http://miproyecto.com/config.php

Como vemos, nos encontramos con dos problemas (podríamos tener más, deberemos resolverlos según sea necesario). En este caso el error es que las carpetas app/cache y app/logs no tienen los permisos necesarios.

Lo arreglaremos así:

chmod 777 $HOME/NetBeansProjects/miproyecto/Symfony/app/cache
chmod 777 $HOME/NetBeansProjects/miproyecto/Symfony/app/logs

Una vez arreglados los problemas, ya podemos acceder a nuestro proyecto web con Symfony2 mediante esta url:

http://miproyecto.com/app_dev.php/

En próximos artículos nos iremos adentrando poco a poco en el desarrollo de Bundles, las plantillas con Twig, etc.

Cualquier duda, en los comentarios!

Relaciones uno a uno

Un caso típico para este tipo de relación es el de un usuario y su perfil. Un usuario solamente tiene un perfil y un perfil solo puede pertenecer a un usuario.

User:
  tableName: user
  columns:
    id:
      type: integer(4)
      primary: true
      notnull: true
      autoincrement: true
    email:
      type: string(255)
      notnull: true
      unique: true
    password:
      type: string(45)
 
Profile:
  tableName: profile
  columns:
    user_id:
      type: integer(4)
      primary: true
      notnull: true
      autoincrement: false
    nickname: string(255)
  relations:
    User:
      class: User
      local: user_id
      foreign: id
      foreignAlias: Profile
      type: one
      foreignType: one

Con esta relación, podremos acceder al perfil de un usuario así:

$user->Profile->nickname // obtenemos el nickname del perfil del usuario

Relaciones uno a muchos:

Un ejemplo de este tipo de relación es el de los usuarios y sus números de teléfono. Un usuario puede tener varios números de teléfono pero un teléfono solo puede pertenecer a un usuario.

User:
  tableName: user
  columns:
    id:
      type: integer(4)
      primary: true
      notnull: true
      autoincrement: true
    email:
      type: string(255)
      notnull: true
      unique: true
    password:
      type: string(45)
 
Telephone:
  tableName: telephone
  columns:
    id:
      type: integer(4)
      primary: true
      notnull: true
      autoincrement: true
    user_id:
      type: integer(4)
      notnull: true
    number:
      type: string(255)
  relations:
    User:
      class: User
      local: user_id
      foreign: id
      foreignAlias: Telephones
      type: one
      foreignType: many

Para acceder a los números de teléfono de un usuario, podemos hacer:

foreach($user->Telephones as $telephone){
  echo $telephone->number;
}

Relaciones muchos a muchos

Para terminar, un caso típico de esta relación es la que podemos encontrar entre los artículos de un blog y sus etiquetas. Un artículo puede tener varias etiquetas y una etiqueta puede asignarse a varios artículos. En esta relación necesitaremos obligatoriamente una tercera tabla (article_tags) para poder relacionar la tabla articles y la tabla tags.

Article:
  tableName: articles
  columns:
    id:
      type: integer(4)
      primary: true
      notnull: true
      autoincrement: true
    title:
      type: string(100)
      notnull: true
 
Tag:
  tableName: tags
  columns:
    id:
      type: integer(4)
      primary: true
      notnull: true
      autoincrement: true
    name:
      type: string(100)
      notnull: true
  relations:
    Article:
      foreignAlias: Tags
      class: Article
      refClass: ArticleTag
 
ArticleTag:
  tableName: article_tags
  columns:
    article_id:
      type: integer(4)
      primary: true
    tag_id:
      type: integer(4)
      primary: true
  relations:
    Article:
      foreignAlias: ArticleTags
    Tag:
      foreignAlias: ArticleTags

Podremos obtener el nombre de todos los tags de un artículo de la siguiente manera:

foreach($article->ArticleTags as $article_tag){
      echo $article_tag->Tag->name;
}

¡Cualquier duda, en los comentarios!

“The default context does not exist”

El problema es que estás utilizando un método de un objeto que utiliza sfContext (para recuperar valores del archivo app.yml, por ejemplo). Parece ser que Symfony no crea una instancia de sfContext y nos devuelve este error.

La siguiente línea debería resolver el problema. La colocaremos en primer lugar dentro de la función execute:

sfContext::createInstance($this->configuration);

Por ejemplo:

1
2
3
4
5

protected function execute ($arguments = array(), $options = array())
{
  sfContext::createInstance($this->configuration);
  // Aqui nuestro codigo
}

Primero creamos el formulario de login, por lo que creamos un nuevo archivo:

/lib/form/LoginForm.class.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<?php
class LoginForm extends BaseForm
{
  public function configure()
  {
    parent::configure();
 
    $this->setWidgets(array(
      'email'        => new sfWidgetFormInput(),
      'password'  => new sfWidgetFormInputPassword(),
    ));    
 
    $this->setValidators(array(
      'email'        => new sfValidatorEmail(array('required'=>true), array('required'=>'El email es obligatorio')),
      'password'  => new sfValidatorString(array('required'=>true), array('required'=>'Escribe tu contraseña')),
    ));
 
    $this->widgetSchema->setNameFormat('login[%s]');
    $this->widgetSchema->setFormFormatterName('list');
 
  }
 
}

El formulario no tiene mayor misterior. Un input text para el email y un input password para la contraseña. Validamos que se hayan rellenado los dos campos.

Editamos las actions del módulo user que creamos en el post anterior para añadir el login.

/apps/frontend/modules/user/actions/actions.class.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

<?php
class userActions extends sfActions
{
  public function executeLogin(sfWebRequest $request)
  {
    $this->form = new LoginForm();
 
    if($request->isMethod("post")){
        $this->form->bind($request->getParameter("login"));
 
        if($this->form->isValid()){
           if(!$user = UserTable::login($this->form->getValue("email"), $this->form->getValue("password"))){
               // No hemos conseguido loguear al usuario
               // Redirigimos de nuevo al login con un mensaje de error
               $this->getUser()->setFlash("error", "datos incorrectos");
               $this->redirect("@user_login");
           }else{
               // Logueamos
               $this->getUser()->setAuthenticated(true);
               $this->getUser()->setAttribute("id",$user->id);
 
               // Comprobamos si tiene referer, si no, le llevamos a la homepage
               $url = $this->getUser()->getAttribute("referer",false)?:"@homepage";
               $this->getUser()->setAttribute("referer", false);
               $this->redirect($url);
           }
        }
 
  }
 
}

Tenemos que comprobar si existe ese email junto con esa contraseña en nuestra base de datos. Si es así, logueamos al usuario y, si no, mostramos un mensaje de error.
La comprobación de si existe el usuario en la base de datos la hacemos en la linea 12, donde llamamos al método estático “login” del archivo UserTable.class.php del modelo.

/lib/model/doctrine/UserTable.class.php

1
2
3
4
5
6
7
8
9
10
11

<?php
class UserTable extends Doctrine_Table
{
    public static function login($email,$password){
      return Doctrine_Query::create()
        ->from('User u')
	->where('u.email = ?', array($email))
        ->andWhere('u.password = ?', array(md5($password))) // Podrimos usar otro algoritmo, en este caso utilizamos md5
	->fetchOne();
    }
}

Y eso es todo, lo más sencillo para el final: la plantilla donde mostramos el formulario.

/apps/frontend/modules/user/templates/loginSuccess.php

1
2
3
4
5
6
7

<?php if($sf_user->getFlash("error")): ?>
    <div class="error"><?php echo $sf_user->getFlash("error"); ?></div>
<?php endif; ?>
<form action="<?php echo url_for("@user_login"); ?>" method="post">
  <?php echo $form; ?>
  <input type="submit" value="Entrar" />
</form>

En este paso sería lógico desarrollar el logout para poder cerrar la sesión en la web. Para ello modificamos de nuevo la actions de nuestro módulo para añadir la nueva funcionalidad:

/apps/frontend/modules/user/actions/actions.class.php

1
2
3
4
5
6
7
8
9

<?php
class userActions extends sfActions
{
  public function executeLogout(sfWebRequest $request){
    $this->getUser()->setAuthenticated(false);
    $this->getUser()->getAttributeHolder()->clear();
    $this->redirect("@homepage");
  }
}

Para ejecutar el logout, solo debemos crear un enlace en nuestra web donde se llame a esta action. No necesitamos plantilla ya que después de logout siempre redirigiremos a la homepage.

<?php echo link_to("Cerrar sesión", '@user_logout'); ?>

Debemos añadir las siguientes rutas en el archivo routing.yml:

user_login:
  url:   /login
  param: { module: user, action: login }
 
user_logout:
  url:   /logout
  param: { module: user, action: logout }

Cualquier duda en los comentarios!

Para este post, la intención es crear un formulario de registro de usuarios sencillo desde cero para Symfony 1.4, sin la complejidad de un plugin ya que muchas veces tienen funcionalidades que no necesitaremos en nuestro proyecto.

Antes de empezar, evidentemente, crearemos un proyecto nuevo y generamos un modulo llamado “user”.

Primero modificamos el archivo schema.yml, añadiendo una tabla user básica y sencilla.

/config/doctrine/schema.yml

1
2
3
4
5
6
7
8
9

User:
  tableName: user
  actAs:
    Timestampable: ~
  columns:
    email:
      type: string(255)
    password:
      type: string(45)

Indicamos que se comporte como Timestampable para que se creen automáticamente los campos created_at y updated_at. No nos olvidemos generar las consultas sql y ejecutarlas en nuestra base de datos.

En el segundo paso, vamos a crear el formulario para el registro del usuario. Creamos un archivo nuevo en /lib/form/ llamado RegisterForm.class.php

/lib/form/RegisterForm.class.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

<?php
class RegisterForm extends BaseForm
{
    public function configure()
    {
        parent::configure();
 
        $this->setWidgets(array(
	    'email'     => new sfWidgetFormInput(),
	    'password'  => new sfWidgetFormInputPassword(),
            'password2' => new sfWidgetFormInputPassword(),
	));
 
	$this->setValidators(array(
            'email'        => new sfValidatorEmail(array('required'=>true), array('required'=> "El email es obligatorio")),
            'password'  => new sfValidatorString(array('required'=>true), array('required'=> "La contraseña es obligatoria")),
            'password2' => new sfValidatorString(array('required'=>true), array('required'=> "La contraseña es obligatoria")),
	));
 
	$this->widgetSchema->setNameFormat('register[%s]');
        $this->widgetSchema->setFormFormatterName('list');
 
        $this->validatorSchema->setPostValidator(new sfValidatorAnd(array(
            new sfValidatorSchemaCompare('password2', sfValidatorSchemaCompare::EQUAL, 'password', array('throw_global_error' => true), array('invalid' => "Las dos contraseñas no coinciden")),
            new sfValidatorDoctrineUnique(array('model' => 'User', 'column' => array('email')), array('invalid'=> "Este email ya está en uso"))
        )));
    }
}

Los formularios pueden darnos muchos quebraderos de cabeza al principio ya que es algo dificil de entender a la primera, por lo que voy a explicarlo un poco más en detalle.

1
2
3
4
5

$this->setWidgets(array(
    'email'     => new sfWidgetFormInput(),
    'password'  => new sfWidgetFormInputPassword(),
    'password2' => new sfWidgetFormInputPassword(),
));

Indicamos que para el campo email queremos un input normal. Como se puede apreciar, le decimos que para los campos contraseña queremos un campo input password.

1
2
3
4
5

$this->setValidators(array(
    'email'        => new sfValidatorEmail(array('required'=>true), array('required'=> "El email es obligatorio")),
    'password'  => new sfValidatorString(array('required'=>true), array('required'=> "La contraseña es obligatoria")),
    'password2' => new sfValidatorString(array('required'=>true), array('required'=> "La contraseña es obligatoria")),
));

Ahora los validadores. El campo email, evidentemente, debe ser un email. El validador sfValidatorEmail se encarga de comprobar que sea un formato de email válido.
Los campos password son obligatorios y no pueden estar vacíos. Podríamos decirle que tienen que tener una longitud mínima y máxima con las opciones max_length y min_length.

1
2
3
4

$this->validatorSchema->setPostValidator(new sfValidatorAnd(array(
    new sfValidatorSchemaCompare('password2', sfValidatorSchemaCompare::EQUAL, 'password', array('throw_global_error' => true), array('invalid' => "Las dos contraseñas no coinciden")),
    new sfValidatorDoctrineUnique(array('model' => 'User', 'column' => array('email')), array('invalid'=> "Este email ya está en uso"))
)));

Vamos a añadir unos validadores un poco más complejos. En el primero, comprobamos que los dos campos de contraseña deben ser iguales. Para ello utilizamos el validador sfValidatorSchemaCompare. Es típico hacer esta comprobación en todos los formularios de registro de usuarios.
En el segundo caso, comprobamos que el email introducido por el usuario no esté ya introducido en la base de datos y, por tanto, en uso por otro usuario. Utilizamos el validador sfValidatorDoctrineUnique.

Ya tenemos el formulario preparado para su uso. Editamos el archivo actions.class.php de nuestro módulo “user” y añadimos la acción “Register”:

/apps/frontend/modules/user/actions/actions.class.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?php
class userActions extends sfActions
{
  public function executeRegister(sfWebRequest $request)
  {
 
    $this->redirectIf($this->getUser()->isAuthenticated(), "@homepage");
 
    $this->form = new RegisterForm();
 
    if($request->isMethod("post")){
 
       $this->form->bind($request->getParameter("register"));
       if($this->form->isValid()){
 
           $user = new User();
           $user->email = $this->form->getValue("email");
           $user->password = md5($this->form->getValue("password")); // podriamos utilizar otro sistema para encriptar la contraseña
           $user->save();
 
           $url = $this->getUser()->getAttribute("referer",false)?:"@homepage";
           $this->getUser()->setAttribute("referer",false);
           $this->redirect($url);
       }
    }
  }
}

En la línea 7 le indicamos que si el usuario ya está logueado le redirija a la homepage.

Hemos utilizado el algoritmo md5 para encriptar la contraseña antes de guardarla en la base de datos. Podríamos utilizar otro algoritmo como sha1 o uno propio. Es totalmente recomendable encriptar las contraseñas y no guardarlas en texto plano en nuestra base de datos por motivos de seguridad.

Por último, creamos la plantilla donde se mostrará el formulario de registro.

/apps/frontend/modules/user/templates/registerSuccess.php

1
2
3
4

<form action="<?php echo url_for("@user_register"); ?>" method="post">
  <?php echo $form; ?>
  <input type="submit" value="Registrarse" />
</form>

Debemos añadir la siguiente ruta en el archivo routing.yml:

user_register:
  url:   /register
  param: { module: user, action: register }

Y eso es todo, ya hemos creado un sistema muy básico de registro de usuarios en Symfony 1.4. A partir de aquí se puede expandir e incluir las funcionalidades que queramos.
En un próximo post, realizaremos el login y el logout.

Cualquier duda o si hay que explicar algo mejor, en los comentarios

Al intentar crear un nuevo proyecto con el comando:

php symfony generate:project miproyecto

La orden no se ejecutaba en su totalidad y me dejaba unos “bonitos” mensajes de error, relacionados con la función token_get_all():

PHP Notice:  Use of undefined constant T_FINAL - assumed 'T_FINAL' in /var/symfony14/lib/util/sfClassManipulator.class.php on line 52
PHP Notice:  Use of undefined constant T_ABSTRACT - assumed 'T_ABSTRACT' in /var/symfony14/lib/util/sfClassManipulator.class.php on line 52
PHP Notice:  Use of undefined constant T_STATIC - assumed 'T_STATIC' in /var/symfony14/lib/util/sfClassManipulator.class.php on line 52
PHP Notice:  Use of undefined constant T_PUBLIC - assumed 'T_PUBLIC' in /var/symfony14/lib/util/sfClassManipulator.class.php on line 52
PHP Notice:  Use of undefined constant T_PROTECTED - assumed 'T_PROTECTED' in /var/symfony14/lib/util/sfClassManipulator.class.php on line 52
PHP Notice:  Use of undefined constant T_PRIVATE - assumed 'T_PRIVATE' in /var/symfony14/lib/util/sfClassManipulator.class.php on line 52
PHP Notice:  Use of undefined constant T_FUNCTION - assumed 'T_FUNCTION' in /var/symfony14/lib/util/sfClassManipulator.class.php on line 52
PHP Fatal error:  Call to undefined function token_get_all() in /var/symfony14/lib/util/sfClassManipulator.class.php on line 117

Este problema con la función token_get_all() lo solucionaremos instalando la extensión para php “php5-tokenizer”:

zypper install php5-tokenizer

Me he encontrado este error al generar un nuevo proyecto con Symfony pero nada tiene que ver con el framework. Quizás para cualquier otro proyecto donde no utilicemos Symfony no nos haga falta instalarlo y no lo echemos de menos. Visto lo visto, con Symfony es totalmente necesario tener esta extensión instalada.

En casos como estos es necesario tomar estas dos consultas como un todo y si falla una de las dos operaciones, volver atrás y deshacer la operación. Para ello se utilizan las transacciones.

En este ejemplo vamos a ver como realizar transacciones con el ORM Doctrine y Symfony (no necesariamente debemos utilizar Symfony).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

$conn = Doctrine_Manager::getInstance()->getCurrentConnection();
$conn->beginTransaction();
 
try{
 
    /** Hacemos las operaciones necesarias
      * para realizar la transferencia bancaria */
 
    $userA = UserTable::getById($userA_id);
    $userB = UserTable::getById($userB_id);
 
    $userA->money -= 20;
    $userA->save();
 
    $userB->money += 20;
    $userB->save();
 
    $conn->commit();
}
catch (Exception $e){
    $conn->rollBack();
    throw $e;
}

Si las dos operaciones se realizan con éxito, quedará reflejado en la base de datos. Si por el contrario cualquiera de las dos consultas fallará, se desharán los cambios (rollBack) y no se guardarán en la base de datos (mostramos el error y deberemos tratarlo según nuestros intereses).

Symfony tiene un sistema de logs bastante decente, que nos informa de todo lo que ocurre cada vez que cargamos una nueva página. Vamos a hacer algo sencillo: vamos a escribir nuestros propios mensajes de log personalizados y los escribiremos manualmente en el momento que consideremos oportuno y deseamos tener un control. Además, escribiremos estos logs en un archivo aparte del que utiliza Symfony por defecto. Así podremos leer directamente ese archivo sin tener otros logs mezclados con los que realmente nos interesa.

Primero, vamos a crear un nuevo archivo llamado CustomLog.class.php en la carpeta /lib/:

1
2
3
4
5
6
7
8
9
10
11

<?php
 
class CustomLog{
  static public function newLog($message) {
 
        $logFile = sfConfig::get('sf_log_dir').'/custom_logs.log';
        $custom_log = new sfFileLogger(new sfEventDispatcher(), array('file' => $logFile));
        $custom_log->info($message);
 
  }  
}

El archivo donde guardaremos nuestros logs personalizados, lo encontraremos en “/log/custom_logs.log”.

Para escribir un nuevo log desde cualquier parte del código, simplemente deberemos hacer:

1

CustomLog::newLog("Escribimos un nuevo log");

Si abrimos nuestro archivo de logs personalizados, encontraremos algo como esto:

1

Jul 05 22:31:41 symfony [info] Escribimos un nuevo log

Así podremos llevar un control de lo que ocurre en nuestra web.

Quizás haya una forma mejor de hacerlo. Si es así, no dudes en dejar tu propuesta en los comentarios. A lo mejor también sería conveniente escribir esas 3 lineas dentro de un try.. catch, por lo que pudiera pasar.