• [CTRL] + [SPACE] : Completa el código que estamos escribiendo. Por ejemplo, si queremos escribir LocateRegistry solamente escribimos Loc y presionamos el atajo para que nos sugiera la palabra completa. Si presionamos dos veces el atajo, muestra todas las opciones que comiencen con los caracteres escritos.
• [ALT] + [INSERT] : Agrega constructores, métodos accesores, propiedaes, overrides, etc..
• [ALT] + [ENTER] : Se usa sobre el texto subrayado para ver la sugerencia que nos hace el IDE cuando hay algún error de sintaxis o se necesita realizar algun import o surround
• [CTRL] + [R]: Si lo hacemos sobre el identificador, renombra todas las ocurrencias.
• Generador de documentación PHPDoc: Si posicionamos el cursor en la línea anterior donde empieza la declaración de la función, escribimos /** y pulsamos [ENTER], automáticamente se nos generará la documentación PHPDoc de esa función.
• [ALT]+[SHIFT]+F : Tabula el código automáticamente.
• [SHIFT]+[ESC] : Maximiza o minimiza la ventana donde tecleamos el codigo.
• [CTRL]+B ó [CTRL]+(click) : Nos abre el archivo donde se encuentra la declaración de la variable/funcion/clase.
• [CTRL]+[TAB] : Lista de los archivos que tenemos abierto para cambiar de uno a otro rápidamente.
• [CTRL]+[SHIFT]+UP ó [CTRL]+[SHIFT]+DOWN : Copia la linea en la que estamos en la fila superior o inferior.
• [ALT]+[SHIFT]+UP ó [ALT]+[SHIFT]+DOWN : Moveremos la línea en la que nos encontramos hacia arriba o hacia abajo.
• [CTRL]+E : Borra la línea en la que estamos.
• [CTRL]+[SHIFT]+C : Comenta la línea actual. Si hacemos una selección, comentará todo el código seleccionado.
• [CTRL]+R : Renombramos una variable/función/clase y hace el cambio automáticamente en el resto del código (MUY útil).

Vamos a ver a continuación unos atajos para escribir código mucho más rápido con Netbeans. Tan solo tendremos que escribir la primera palabra que se indica y pulsar la tecla del tabulador.

• fore + [TAB] : Genera un bucle foreach típico.

  foreach ($array as $value) {
   
  }

• forek + [TAB] : Nos generará un bucle foreach, extrayendo también la clave del array.

  foreach ($array as $key => $value) {
   
  }

• if + [TAB] : Autocompleta el código de un bloque if.

  if (true) {
   
  }

• swi + [TAB] : Genera un bloque switch.

  switch ($categoriesLlistat) {
      case $value:
   
          break;
      default:
   
          break;
  }

• while + [TAB] : Escribirá automáticamente un bucle while.

  while (true) {
   
  }

• my_fa + [TAB] : Genera un bucle while, extrayendo los datos de una consulta mysql en forma de array.

  while ($row = mysql_fetch_array($query)) {
   
  }

• my_fo + [TAB] : Genera un bucle while, extrayendo los datos de una consulta mysql en forma de objeto.

  while ($row = mysql_fetch_object($query)) {
   
  }

• my_fr + [TAB] : Genera un bucle while, extrayendo los datos de una consulta mysql en forma de filas.

  while ($row = mysql_fetch_row($query)) {
   
  }

También se pueden generar atajos de código definidos por nosotros mismos. Ese es un tema que da para otro post

1
2
3
4
5
6

<IfModule mod_rewrite.c>
 RewriteEngine on
 RewriteCond %{REMOTE_ADDR} !^999\.999\.999\.999
 RewriteCond %{REQUEST_URI} !/mantenimiento.html$ [NC]
 RewriteRule .* /mantenimiento.html [R=302,L]
</IfModule>

En la línea 3, cambiaremos la ip por la nuestra propia para poder acceder normalmente.
La línea 4 indica que no redirija si ya estamos en la página de mantenimiento (para evitar un bucle infinito).
Y en la línea 5 indicamos la ruta de la propia página de mantenimiento con una redirección 302 (redirección temporal).

Hasta aquí todo bien. El problema es que desde la página de mantenimiento no podemos acceder a las imágenes o estilos css porque también se ejecuta la redirección. Para evitar esto, añadiremos una línea más al código anterior:

1
2
3
4
5
6
7

<IfModule mod_rewrite.c>
 RewriteEngine on
 RewriteCond %{REMOTE_ADDR} !^999\.999\.999\.999
 RewriteCond %{REQUEST_URI} !/mantenimiento.html$ [NC]
 RewriteCond %{REQUEST_URI} !\.(jpe?g?|png|gif|css) [NC]
 RewriteRule .* /mantenimiento.html [R=302,L]
</IfModule>

Ahora todo debería funcionar correctamente. Cuando hayamos terminado de hacer los cambios, solo tendremos que comentar las líneas anteriores.

Ejemplo sencillo de lo que quiere decir:

$saludo = function($nombre)
{
    printf("Hola %s\r\n", $nombre);
};
 
$saludo('Mundo');
$saludo('PHP');

Pero en este ejemplo vamos a ir un poco más allá.
Imaginemos que tenemos este array:

$usuarios = array(
             array('id' => 1, 'nombre' => 'Jon', 'cumple' => '1984-02-17'),
             array('id' => 2, 'nombre' => 'Luis', 'cumple' => '1985-07-07'),
             array('id' => 3, 'nombre' => 'Antonio', 'cumple' => '1974-11-17')
         );

Si quisiéramos obtener los ids de cada usuario, haríamos algo parecido a esto:

$ids = array();
foreach ($usuarios as $usuario) {
    $ids[] = $usuario['id'];
}

Pero hay una forma mucho más elegante de hacerlo utilizando las funciones anónimas que nos proporciona PHP:

$ids = array_map(function ($usuario) {
    return $usuario['id'];
}, $usuarios);

Mucho más limpio y elegante… Vamos a rizar más el rizo. Ahora queremos obtener los usuario que hayan nacido a partir de 1980. Normalmente haríamos algo así:

$usuarios_filtrados = array();
$fecha_inicial = strtotime('1980-01-01');
foreach ($usuarios as $usuario) {
    if (strtotime($usuario['cumple']) >= $fecha_inicial) {
        $usuarios_filtrados[] = $usuario;
    }
}

En esta ocasión lo haremos utilizando de nuevo las funciones anónimas o closures:

$fecha_inicial = strtotime('1980-01-01');
$usuarios_filtrados = array_filter($usuarios, function($usuario) {
    global $fecha_inicial;
    return strtotime($usuario['cumple']) >= $fecha_inicial;
});

Y esto solo son algunos ejemplos. Las herramientas las tenemos ahí, depende de nosotros si las utilizamos o no

$this->get("request")->getSession()->invalidate();
$this->get("security.context")->setToken(null);

Como extra, podemos informar al usuario mediante un mensaje flash y le redirigimos a la página que queramos:

$this->get("session")->setFlash('message.success', true);
return new RedirectResponse($this->generateUrl('homepage'));

Evidentemente, la página a la que vamos a redirigir tiene que poder ser vista por usuarios anónimos (no debe necesitar autentificación).

Pd.: Ya escribí como Instalar Symfony2 desde cero

svn: Directory .svn containing working copy admin area is missing

Hay dos soluciones:

1) Descargarnos de nuevo el proyecto completo (checkout).

svn co http://servidorsvn/proyecto/trunk proyecto

2) Si la carpeta .svn ha desaparecido solamente de uno de los directorios del proyecto, podemos bajarnos solo esa carpeta y mover el archivo .svn a nuestro proyecto (a la carpeta a la que falta el .svn).

En este ejemplo, se ha borrado la carpeta .svn del directorio css.

svn co http://servidorsvn/proyecto/trunk/css css_copia

mv css_copia/.svn /ruta_al_proyecto/proyecto/css/

rm -rf css_copia

Voy a intentar recopilar este tipo de hilos y traducirlos al castellano, siempre dejando el enlace al hilo original del grupo de Symfony2 por si hay alguna nueva respuesta.

Para empezar, podemos encontrar como utilizar Sphinx haciendo uso de la api como un servicio en Symfony2.

1) Nos descargamos la api de Sphinx de la página oficial http://sphinxsearch.com/, colocándolo en la carpeta vendor/sphinx-client. Debemos renombrar la clase a SphinxClient.

2) Lo añadimos en el autoload.php

  $loader->registerPrefixes(array(
   // ...
   'Sphinx'           => __DIR__.'/../vendor/sphinx-client',
  ));

3) Añadimos Sphinx como servicio de Symfony2 en el fichero config.yml

 services:
     search:
         class: SphinxClient
         calls:
             - [setArrayResult, [true]]
             - [setLimits, [0, 20, 1000]]

4) Por último, podemos hacer uso del servicio desde el controlador de esta forma:

$search  = $this->get('search');
$results = $search->Query($search_terms, 'myindex');

Evidentemente deberemos leer la documentación de Sphinx para instarlo y configurarlo correctamente. La página oficial es bastante completa en ese sentido.

Hilo original: doctrine2 and sphinx

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!