Netbeans es mi IDE de desarrollo favorito cuando estoy programando en PHP. Podemos mejorar nuestra productividad utilizando Netbeans haciendo uso de sus numerosos atajos de teclado que nos facilitará el trabajo. Aunque sé que hay bastantes más (y por supuesto para otros lenguajes), voy a intentar enumerar los más útiles que conozco. Si vosotros conocéis alguno más, no dudéis en escribir un comentario y lo añadiré al post.
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.
foreach ($array as $value) { }
foreach ($array as $key => $value) { }
if (true) { }
switch ($categoriesLlistat) { case $value: break; default: break; }
while (true) { }
while ($row = mysql_fetch_array($query)) { }
while ($row = mysql_fetch_object($query)) { }
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
Etiquetas: atajos, netbeans, php, phpdoc, productividad, programación, teclado
Si vamos a realizar cambios en nuestra web y se tratan de cambios que pueden afectar al funcionamiento de la página (cambios en la base de datos, cambio de funcionalidades, etc), lo ideal es redirigir a una página de mantenimiento para informar a los usuarios mientras se realizan los cambios. En este caso lo vamos a hacer editando el archivo .htaccess y dando permiso a nuestra ip para acceder a la web normalmente y poder ver los cambios. El resto de usuarios verán la página de mantenimiento a la que les redirigiremos.
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.
Etiquetas: 302, css, htaccess, imágenes, ip, mantenimiento, redirect
Según la documentación oficial de PHP, las funciones anónimas (o closures) permiten la creación de funciones que no tienen un nombre especificado.
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
Etiquetas: closures, funciones, funciones anónimas, php
¿Cómo se puede desloguear un usuario sin tener que acceder a la ruta correspondiente del logout? Para algunas funcionalidades que queramos añadir a nuestro proyecto, es posible que necesitemos desloguear al usuario. Un ejemplo podría ser el caso de desactivar/borrar su cuenta, pero puede que haya más (todo depende de nuestra imaginación
). Vamos a ver como hacerlo con Symfony2.
$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
Etiquetas: logout, redirect, RedirectResponse, setFlash, Symfony2
El motivo por el que nos puede aparecer este error (utilizando el sistema de control de versiones svn) al intentar hacer un commit, es porque hemos borrado (o ha desaparecido misteriosamente
) la carpeta .svn de alguno de los directorios del proyecto.
svn: Directory .svn containing working copy admin area is missingHay 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
Etiquetas: control de versiones, error, svn
En el grupo de Symfony2 hay una gran cantidad de preguntas entre las que, de vez en cuando, podemos encontrar un buen hilo donde se trata un tema interesante. Entre tanta “paja” (preguntas fáciles de responder solamente leyendo la documentación) es posible que pasemos por alto alguna de estas buenas preguntas junto a sus respuestas.
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
Etiquetas: autoload, controlador, doctrine2, servicio, sphinx, Symfony2
Nos vamos acercando inevitablemente al cambio de Symfony 1.x a Symfony2 y la conclusión que he sacado de mi asistencia al evento #desymfony es que cuanto antes nos pongamos con ello, mucho mejor. Symfony2 mejora a su predecesor en numerosos aspectos y se convertirá en el framework definitivo para el desarrollo de aplicaciones web en el futuro. Si quieres saber todas las nuevas características de esta versión, te recomiendo que visites la web oficial de Symfony2: http://symfony.com/.
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/miproyectoEntramos en la carpeta que acabamos de crear:
$ cd $HOME/NetBeansProjects/miproyectoDescargamos 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!
Etiquetas: localhost, netbeans, php, servidor, Symfony, Symfony2
Una de las dificultades que podemos encontrar al utilizar el ORM Doctrine (por ejemplo, en Symfony) es configurar las relaciones entre tablas en el schema.yml que define nuestra base de datos. A modo de ejemplo, voy a mostrar los tres tipos de relaciones que podemos querer configurar:
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: oneCon esta relación, podremos acceder al perfil de un usuario así:
$user->Profile->nickname // obtenemos el nickname del perfil del usuario
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: manyPara acceder a los números de teléfono de un usuario, podemos hacer:
foreach($user->Telephones as $telephone){ echo $telephone->number; }
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: ArticleTagsPodremos 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!
Etiquetas: base de datos, doctrine, relaciones, Symfony
Existe un problema bastante frecuente cuando ejecutamos un task en Symfony 1.4, pareciéndonos el siguiente error:
“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 } |
En el post anterior creamos un sistema de registro de usuarios básico para Symfony 1.4. Lo que vamos a hacer ahora es un sistema de login (y logout) para que el usuario pueda iniciar sesión en nuestra web.
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!
Etiquetas: formularios, login, logout, registro, Symfony