instalación de xampp en windows

Xampp es un servidor independiente de plataforma, software libre, que consiste principalmente en la base de datos MySQL, el servidor web Apache y los intérpretes para lenguajes de script: PHP y Perl. El nombre proviene del acrónimo de X (para cualquiera de los diferentes sistemas operativos), Apache, MySQL, PHP, Perl.

En resumidas cuentas nos proporciona un entorno de desarrollo rápido para poder probar nuestras aplicaciones PHP (entre otras cosas).

Para instalarlo en Windows simplemente vamos a la página de descargas y bajamos el instalador y lo ejecutamos. Seguir los pasos es muy sencillo.

Instalación de composer en windows.

Hace algún tiempo hablamos sobre Composer en esta entrada para arrancar un proyecto con CakePHP. Es un gestor de dependencias para php, te permite declarar las librerías de las cuales tu proyecto depende o necesita y las instala en el proyecto por ti. Para instalarlo basta con descargar el instalador y ejecutarlo.

Antes de instalar Composer debes tener instalado php en tu pc. Si has instalado xampp primero bastará con indicarle la instalación de php que está en el directorio de xampp.

Si todo ha ido bien debes ejecutar composer -v en una consola y debe aparecer algo similar a la imagen siguiente:

Iniciar un proyecto laravel

Ya estamos listos para arrancar nuestro proyecto con Laravel, para ello, vamos a la carpeta htdocs dentro de xampp desde la consola y ejecutamos el siguiente comando:

composer create-project laravel/laravel nombre_del_proyecto –prefer-dist

Como ves composer empezará a descargar  e instalar todos los componentes necesarios para crear nuestro proyecto.

Para verificar que todo ha ido bien, basta con arrancar el apache de xampp y en el navegador ir a la url http://localhost/nombre_proyecto/public donde deberás ver una pantalla como la siguiente:

¡ Ya puedes continuar el desarrollo bajo Laravel !

The post Laravel con Xampp y Composer en Windows appeared first on Developando.com.

Los pasos que vamos va a seguir son:

• Creación de la clase que renderizará las vista con los errores.
• Configurar CakePHP para que cuando se lance una excepción se apunte a esta nueva clase.

Crear clase para renderizar las excepciones

Para ello vamos a crear un fichero que llamaremos ‘MyAppExceptionRender‘ y lo vamos a situar en el directorio ‘~/app/Lib/Error/‘. Este es el contenido que tendrá nuestro fichero:

<App::uses('EceptionRenderer', 'Error');
class MyAppExceptionRenderer extends ExceptionRenderer {
    
    protected function _cakeError(CakeException $error) {
          return $this-&gt;controller-&gt;redirect('/');
    }

    public function error400($error) { 
        return $this-&gt;controller-&gt;redirect('/');
    }

    public function error500($error) { 
        return $this-&gt;controller-&gt;redirect('/');
    }

}

Hemos sobreescrito tres metodos de la clase ‘ExceptionRenderer’ que se encargan de:

• ‘_cakeError‘: capturar todos los errores internos generados por el framework CakePHP
• ‘error400‘: muestra pantalla de error para respuestas del servidor con código 400
• ‘error500‘: muestra pantalla de error para respuestas del servidor con código 500

Cuando ocurra alguno de estos errores se redirigirá al visitante al ‘home’ de nuestra aplicación.

Configurar el core de CakePHP

Tras crear el fichero anterior ahora debemos configurar el core de la aplicación para que utilice esta clase. Para ello hay que editar el fichero ‘~/app/Config/core.php’ con esta configuración:

Configure::write('Exception', array(
    'handler' => 'ErrorHandler::handleException',
    'renderer' => 'AppExceptionRenderer',
    'log' => true
));

Siguiendo estos dos sencillos pasos habremos conseguido que todas las excepciones que se produzcan en nuestra aplicación se redirijan al home de nuestro sitio web.

The post CakePHP, redirigir todas las excepciones al home appeared first on Developando.com.

Creación del formulario CakePHP

Lo primero que debemos haces es crear el formulario que queremos enviar por AJAX al servidor. Para ello utilizaremos este código, que creará un formulario con dos campo, uno de texto y un desplegable con tres opciones:

<?php
echo $this->Form->create('Ejemplo', array('id' => 'ejemploForm', 'default' => false));
 
$this->Form->input('nombre');
$this->Form->input('edad', array('options' => array_combine(range(18, 36, 1), range(18, 36, 1))));
 
echo $this->Form->end('Enviar');
?>
 
<div id="resultado"></div>

Con la opción “default=>false” indicamos que el botón del formulario no haga el submit, lo haremos nosotros vía ajax.

Controller CakePHP para recibir la petición

Creamos un controlador de ejemplo para recibir los datos de formulario por Ajax. Este controlador tiene un único método que comprobará si la petición recibida es vía Ajax, y de ser devolverá una frase con el nombre y la edad recibidas.

<?php
class EjemploController extends AppController {
 
    function index(){
        $this->autoRender = false; // No renderiza mediate el fichero .ctp
        if($this->request->is('ajax')){ // Comprobar si es una petición ajax
 
            $nombre = $this->request->data['Ejemplo']['nombre'];
            $edad = $this->request->data['Ejemplo']['edad'];
 
            echo "La edad de ".$nombre." es ".$edad;
        }
    }
}
?>

Creación de la petición AJAX

Para realizar la petición ajax haremos uso del helper de CakePHP llamado “JSHelper“. Capturaremos el evento ‘submit’ del formulario y le asociaremos la llamada ajax, para que cada vez que se pulse sobre el botón del formulario, se ejecute esta función asíncronamente. Para este ejemplo tenemos utilizaremos el controlador anterior que tenemos creado en el servidor.

El código de la llamada sería el siguiente:

<?php
$this->Js->get('#ejemploForm')->event('submit', $this->Js->request(array(
            'controller' => 'ejemplo',
            'action' => 'index'
                ), array(
            'update' => '#resultado',
            'evalScripts' => true,
            'async' => true,
            'method' => 'post',
            'dataExpression' => true,
            'data' => $this->Js->serializeForm(array('isForm' => true, 'inline' => true))
        ))
);
?>

Cada vez que se pulse el botón de submit del formulario, se realizará la llamada al servidor con los datos del formulario, y se recibirá la respuesta y se mostrará en el área identificada por “#resultado”.

The post CakePHP, submit formulario en petición AJAX appeared first on Developando.com.

Para indicar a CakePHP qué campo o campos se van a utilizar para realizar la ordenación debemos utilizar el parámetro ‘order‘ de las opciones permitidas en las consultas.

Veamos el funcionamiento del parámetro ‘order‘ en un ejemplo. Vamos a obtener todos los partidos que existen la base de datos, indicando que queremos que el resultado de la consulta esté ordenador por fecha:

 $options = array(            
            'order' => array('Partidos.fecha ASC'),
        );
$this->Partidos->find("all", $options)

En el código vemos que aparece el parámetro ‘order‘ y como valor tiene un array con todos los campos por los que queremos que se ordenen los resultados. En este caso se ordenarán por fecha ascendente, es decir del más antiguo al más reciente.

Si quisiesemos ordenar por varios campos de la tabla deberíamos añadirlos de la siguiente forma:

 $options = array(            
            'order' => array('Partidos.fecha ASC','Partidos.nombre DESC'),
        );
$this->Partidos->find("all", $options)

Al configurar varios valores en el parámetro ‘order‘ obtendremos una consulta a la base de datos de esta forma:

SELECT * FROM Partidos ORDER BY  Partidos.fecha  ASC,  Partidos.nombre DESC

Con este sencillo parámetro podrás obtener un conjunto de registros ordenados tras consultar en base de datos con CakePHP.

The post CakePHP, orden resultados consulta base de datos appeared first on Developando.com.

Detectar problema robots.txt

Si se crea el fichero ‘robots.txt‘ en la carpeta raíz del servidor, al acceder a la url “http://midominio.com/robots.txt” se obtendrá un error de este tipo:

Not Found
Error: The requested address '/robots.txt' was not found on this server.

Y en el ‘error.log‘ de la aplicación CakePHP podremos ver una línea de este estilo:

2014-05-06 13:47:09 Error: [MissingControllerException] Controller class Robots.txtController could not be found.

Solucionar problema robots.txt

Para solucionar este error únicamente hay que mover el fichero ‘robots.txt‘ a la carpeta ‘~/app/webroot/‘. Una vez movido el fichero, si se accede a la url anterior podremos ver el contenido completo del fichero ‘robots.txt’ que será consultado por los rastreadores de nuestro sitio.

The post CakePHP configurar fichero robots.txt appeared first on Developando.com.

Cuando la aplicación está desplegada en un servidor remoto también tendremos contratado y configurada una dirección de un servidor SMTP propio del hosting o servidor donde esté alojada dicha aplicación.

¿Pero que podemos hacer para trabajar y probar en local?

Pero el problema que podemos tener es que no dispongamos de un servidor remoto y por tanto de un servidor SMTP para el envío de estos correos electrónicos de prueba. Para ello podemos configurar el servidor SMTP de Gmail para que los correos sean encaminados hacia él.

De esta forma podremos enviar correos durante el desarrollo de nuestra aplicación desde nuestra máquina local.

Configuración servidor SMTP Gmail

Para configurarlo únicamente hay que editar el fichero ‘~/app/Config/email.php‘, que es donde se añaden todas las posibles configuraciones necesarias para el envío de correos electrónicos. Estas son las líneas que habría que añadir para la nueva configuración del SMTP de Gmail:

public $gmail = array(
 'transport' => 'Smtp',
 'from' => "ejemplo@developando.com",
 'host' => "smtp.gmail.com",
 'port' => 465,
 'username' => 'miusuario@gmail.com',
 'password' => '1234567890'
 );

En estas líneas se configura:

• El protocolo de envío será SMTP.
• La dirección que aparecerá como persona que envía el correo se configura con el parámetro ‘from‘.
• Puerto del servidor SMTP, 465 para gmail.
• Dirección del servidor SMTP configurada con el parámetro ‘host‘. Para gmail la dirección que debemos utilizar es ‘smtp.gmail.com’.
• Nombre de usuario configurado en el parámetro ‘username‘, que será debe coincidir con una cuenta de Gmail.
• Parámetro ‘password‘ con la contraseña de dicha cuenta de gmail.

Con estos parámetros ya podríamos comenzar a utilizar el envío de correos a través del SMTP de Gmail.

CakePhp configurar uso de la nueva configuración

Tras editar este fichero debemos indicar a la aplicación que la configuración de correo a utilizar sea esta que acabamos de añadir identificado por el nombre ‘gmail‘. Esto se hará añadiendo el nombre de la configuración al crear un ‘CakeEmail‘ como se indica a continuación:

$email = new CakeEmail('gmail');

Con esta configuración habremos conseguido poder enviar correos electrónicos desde una máquina local a través del servidor SMTP de Gmail.

Esperamos que el tutorial sea de utilidad. Para cualquier duda, queja o comentario utlizad el formulario que aparece a continuación.

The post CakePHP, configurar servidor de correo SMTP Gmail appeared first on Developando.com.

Durante el tutorial vamos a realizar un ejemplo que lo que va a conseguir es que se muestre en la pantalla un mensaje que se le pase por la url al controlador.

Pasos para la creación de un nuevo plugin en CakePHP

1.- Estructura de carpetas del nuevo plugin

Para crear un nuevo plugin deberemos ir a la carpeta ‘Plugin‘ que está situado en ‘~/app/Plugin‘ en el raíz de instalación de nuestra aplicación CakePHP y crear ahí la carpeta del nuevo plugin. En este ejemplo vamos a crear un plugin llamado ‘Saludos‘, por lo que la estructura de carpetas tras crear la del plugin sería la siguiente:

/app
        /Config
        /Console
        /Controller
        /Lib
        /Locale
        /Model
        /Plugin
                /Saludos
...

Una vez que hemos creado la carpeta raíz del nuevo plugin deberemos crear las carpetas para los diferentes elementos que vamos a utlizar:

/Saludos
        /Config
        /Controller
        /Model
        /View
        /webroot
...

  En estas carpetas iremos creando los controladores del nuevo plugin, las páginas que renderizan las vistas, las clases para interactuar con los modelos de base de datos…

2.- Creación de un controlador dentro del nuevo plugin

Tras crear la estructura de carpetas vamos a pasar a crear nuestro primer controlador del nuevo plugin. Para ello crear el fichero ‘SaludarController‘ dento de la carpeta ‘~/app/Plugin/Saludos/Controller/‘:

class SaludarController extends AppController {
 
         function saludoInicial($texto){
                 $this->set('texto',$texto); 
         }
 
}

En el controlador se crear un único método que lo que hará será enviar a la vista el valor del texto recibido en la llamada al controlador para ser mostrado en la pantalla.

3.- Crear fichero de la vista para el nuevo método del controlador

Debemos crear el fichero ‘~/app/Plugin/Saludos/View/saludo_inicial.ctp‘ con el siguiente contenido:

<?= 'Bienvenido: '.$texto ?>

Esta vista lo único que hará será mostrar por pantalla el nombre que le llega por parámetro en la llamada del método ‘SaludoInicial‘ del controlador.

4.- Configurar la precarga del plugin en el fichero bootstrap

Para que CakePHP detecte el nuevo Plugin deberemos añadir una nueva línea en el fichero ‘~/app/Config/bootstrap.php‘ indicándole a CakePHP que debe cargar el plugin con el nombre ‘Saludos‘:

CakePlugin::load('Saludos');

Con estos cuatro pasos ya habremos creado el nuevo plugin de CakePHP y este sería accesible a través de la url:

http://developando.com/saludos/saludar/saludoInicial/David

En la url se pueden distinguir:

• Direción del sitio web – http://developando.com/
• Nommbre del plugin – saludos
• Nombre del controlador – saludar
• Nombre de la acción – saludoInicial
• Parámetro con el texto a mostrar – David

CakePHP permite configurar rutas o ‘routes’ para que esta url ‘tan fea‘ pueda tener el formato que queramos.

5.- Configurar el fichero de routes

5.1- Crear el fichero de routes

Para configurar las ‘url amigables‘ del plugin CakePHP debemos crear el fichero ‘~/app/Plugin/Saludos/Config/routes.php‘ indicando las rutas con las que debe trabajar CakePHP.

Por ejemplo, si añadimos la siguiente línea:

<?php
// Rutas para las acciones del controlador
Router::connect('/saludoInicial/*', array('plugin' => 'saludos', 'controller' => 'saludar', 'action' => 'saludoInicial'));

En esta línea dentro del fichero ‘routes‘ se indica a CakePHP que todas la peticiones que lleven a ‘saludoInicial’ se deben tratar con:

• Plugin: ‘Saludos‘
• Contolador: ‘Saludar‘
• Acción: ‘SaludoInicial‘

5.2- Editar configuración del fichero bootstrap

Una vez creado este fichero de rutas debemos indicar a CakePHP la existencia del mismo. Para ello editaremos de nuevo el fichero ‘~/app/Config/bootstrap.php‘ del paso anterior añadiendo a la línea que habíamos puesto para cargar el plugin un nuevo parámetro indicando que utilice el fichero de ‘routes‘ creado dentro del nuevo plugin.

La línea debe quedar de esta forma ahora:

CakePlugin::load(array('Saludos' => array('routes' => true)));

Con estos dos últimos pasos hemos conseguido que ahora el método creado en el controlador del nuevo plugin sea accesible a través de una url más amigable como la siguiente:

http://developando.com/saludoInicial/David

Con estos pasos serás capáz de crear un nuevo plugin y empezar a trabajar con él. En este tutorial hemos creado un sencillo ejemplo, ahora puedes ‘complicar’ el nuevo plugin añadiendo más controladores, modelos de datos, vistas y elementos….

Si este tutorial te ha resultadao de utilidad, o tienes algún problema o duda, por favor deja tus comentarios.

The post CakePHP, crear un nuevo plugin y configurar controladores y rutas appeared first on Developando.com.

Vamos a realizar diferentes consultas a una tabla de ejemplo ‘Personas’, obteniendo diferentes resultados. Comenzaremos por las consultas más sencillas y luego iremos añadiendo consultas a base de datos más complejas.

Consulta pidiendo todas las filas de una tabla

Con esta consulta obtendremos todas las personas que están almacenadas en la tabla:

$todasPersonas = $this->Personas->find('all');

Añadir diferentes criterios de búsqueda

CakePHP entiende diferentes tipos de parámetros que serán utlizados para crear la consulta a la base de datos, rellenando en ella los diferentes criterios de búsqueda.

Vamos a ver unos cuantos ejemplos para crear consultas cada vez más complejas con diferentes criterios de búsqueda:

• Incluir un campo de búsqueda en la consulta: en este caso vamos a buscar las personas cuyo ‘nombre‘ coincida con el que pasamos como parámetros.

  $opciones=array('conditions' => array('Personas.nombre' => "David"));
   
  $personasEncontradas = $this->Personas->find('all',$opciones);

  Ahora estamos haciendo la consulta indicando como criterio de búsqueda el nombre, por lo que se generará una consulta ‘select’ con la siguiente condición:

  WHERE Personas.nombre='David';

• Consultas con varias condiciones unidas por la etiqueta AND: ahora realizaremos la búsqueda pero filtrando por varios criterios que deberán cumplirse. Para elo utlizaremos debemos añadir al array de condiciones todas las que queramos que se apliquen a la consulta. A la consulta anterior, vamos a añadirle otro criterio de búsqueda que filtre por la ‘edad‘:

  $opciones=array('conditions' => array('Personas.nombre' => "David", "Personas.edad" => '27'));
   
  $personasEncontradas = $this->Personas->find('all',$opciones);

  Ahora estamos haciendo la consulta indicando como criterio de búsqueda el nombre y la edad, por lo que se generará una consulta ‘select’ con la siguiente condición:

  WHERE Personas.nombre='David' AND Personas.edad='27';

• Incluir varias condiciones separadas por la etiqueta OR: ahora realizaremos la búsqueda pero filtrando por varios criterios esta vez con la etiqueta OR, por lo que con que se cumpla un criterio ya devolverá el resultado. Para elo utlizaremos debemos añadir al array de condiciones todas las que queramos que se apliquen a la consulta. A la consulta anterior, vamos a añadirle otro criterio de búsqueda que filtre por la ‘edad‘:

  $opciones=array(find('all', array('conditions'=>
          array('OR'=>
                  array('Personas.nombre' => 'David',
                        'Personas.edad'   => '27')
                )));
   
  $personasEncontradas = $this->Personas->find('all',$opciones);

  Ahora estamos haciendo la consulta indicando como criterio de búsqueda el nombre y/o la edad, por lo que se generará una consulta ‘select’ con la siguiente condición:

  WHERE Personas.nombre='David' OR Personas.edad='27';

• Consultas con indicadores de mayor, menor o igual que: también se pueden hacer consultas utlizando cualquiera de estos caracteres de comparación ‘<>, <=, >=, >,<‘. Crearemos una consulta de ejemplo que busque todas las personas cuya edad esté entre 20 y 30 años y midan ‘170’:

  $opciones=array(find('all', array('conditions'=>
                 array('Persona.edad >=' => '20',
                       'Persona.edad <=' => '30',
                       'Persona.altura' => '170')
                  )));
   
  $personasEncontradas = $this->Personas->find('all',$opciones);

  Ahora estamos haciendo la consulta indicando como criterio de búsqueda un rango de edades y la altura, por lo que se generará una consulta ‘select’ con la siguiente condición:

  WHERE Personas.edad>='David' AND Personas.edad<=30 AND Personas.altura='170';

• Utilizar la etiqueta ‘IN‘ como criterio de búsqueda: vamos a hacer una consulta en la que buscaremos personas cuya altura se encuentre entre ciertas alturas que serán indicadas creando una array. Por tanto, para hacer consultas de este tipo utilizando ‘IN‘ debemos hacer lo siguiente:

  $alturas=array(170,180,190);
  $opciones=array(find('all', array('conditions'=>array('Persona.altura>=' => $alturas))));
   
  $personasEncontradas = $this->Personas->find('all',$opciones);

  La consulta que se generará tendrá el siguiente parámetro de comparación:

  WHERE Personas.altura IN (170,180,190);

• Consultas utlizando NOT IN: ahora realizaremos la búsqueda como en el paso anterior pero utilizando en este caso ‘NOT IN’. Para ello deberemos pasar los siguientes parámetros, para que devuelva las personas cuyas alturas no se coincidan con las que se pasan por parámetro:

  $alturas=array(170,180,190);
  $opciones=array(find('all', array('conditions'=>
          array('NOT'=> array('Personas.altura' => $alturas) )));
   
  $personasEncontradas = $this->Personas->find('all',$opciones);

  En este ejemplo la consulta se generá así:

  WHERE Personas.altura NOT IN (170,180,190);

• Consultas haciendo uso del comparador ‘BETWEEN‘: ahora vamos a buscar personas cuya edad se encuentre en un rango determinado, entre 15 y 45 años. Para ello utilizaremos los siguientes parámetros:

  $personasFiltradas = $this->Personas->find('all',array('conditions'=>array(array('Personas.edad BETWEEN ? AND ?' => array(15,45)))))

  En este caso la consulta generada tendría este formato:

  WHERE Personas.edad BETWEEN 15 AND 45;

Todas estos tipos de consultas se pueden combinar para crear consultas más complejas. Si tenéis alguna duda de cómo crear algún tipo de consulta poneros en contacto con nosotros.

The post CakePHP, consultas complejas a base de datos utilizando Model appeared first on Developando.com.

Imaginemos que queremos tener un sitio en la aplicación donde generar la ruta de las imágenes. Es decir, partimos del nombre de una imagen y queremos obtener la ruta en el servidor a la misma. Una solución sería poner esta ruta cada vez que se añade una nueva imagen, ¿pero qué ocurre si tenemos que cambiar la carpeta donde están alojadas nuestras imágenes en el servidor?. Pues este problema se resuelve con el uso de un ‘Helper’ que nos devuelva la ruta a la carpeta de imágenes que tengamos configurada. Así si en algún momento se modifica la ubicación de esta carpeta únicamente habría que editar un único fichero y todas las imágenes de la aplicación cogerían esta nueva ruta que se configurase en el Helper de CakePHP.

El código de este ejemplo sería el siguiente, primero creando el helper, luego configurando el ‘Controller’ y finalmente utlizándolo desde una de las vistas de la aplicación.

Creación del helper

Creamos un fichero que llamaremos ‘ImageHelper.php’ en la carpeta ‘~/app/View/Helper/‘ con el siguiente contenido, llamar a la clase igual que el nombre del fichero creado:

<?php
/* /app/view/helper/ImageHelper.php */
 
class ImageHelper extends AppHelper {
        function getRutaImagenes() {
                return "/image/carpeta1/carpeta1a";
        }
}
?>

Configurar controladores para utilizar el Helper

1.- Configurar helper para todas las vistas de un controlador

Para poder utilizar este nuevo ‘Helper‘ desde alguna de las vistas primero debemos añadir en el controlador de dicha vista la siguiente línea, indicando los ‘helpers’ que se utilizan:

class GaleriaController extends AppController {
      var $helpers = array('Image');
 
      // .... resto de variables y funciones del Controlador
}

Como se observa en el código se añade la variable ‘var $helpers‘ indicando en el array el nombre de los que se utilizarán por el controlador y las vistas que lo renderizan. Una cosa que se podría hacer si este ‘Helper’ va a ser común a toda la aplicación es meter esta línea en el fichero ‘AppController‘ para que así pueda ser utilizado desde todas las vistas, independientemente del controlador de la vista que lo esté llamando.

Si el ‘Helper’ se ha creado en algún plugin, habría que anteponer el nombre del plugin al añadirlo a la variable ‘helpers’. Por ejemplo, si hemos creado el ‘helper’ en un plugin llamado ‘Galeria’, entonces habría que nombra al ‘helper’ de esta forma:

var $helpers = array('Galeria.Image');

2.- Configurar helper para una única vista de un controlador

También puede ser que nos interese únicamente configurar un helper para una función del controlador. Para hacer esto únicamente habría que definir dicho helper dentro del método de la función del controlador de esta forma:

class GaleriaController extends AppController {
      function index(){
            $this->helpers[] = 'Image';
      }
 
      function login(){
            // En el método login no está definido el helper Image
      }
}

En el código anterior se observan dos métodos. El primero de ellos ‘index‘, tiene definido el helper ‘Image‘, por lo que desde la vista se podrán llamar a las funciones que estén configuradas en dicho helper. Por el contrario, la segunda función ‘login‘ no podrá realizar llamadas al helper ‘Image’ ya que este sólo fue definido en el primer método.

Uso del Helper desde la vista

Una vez que ya lo tenemos configurado vamos a ver un ejemplo de cómo utilizar este nuevo ‘Helper’ desde una de las vistas. Siguiendo con el ejemplo, tenemos una imagen que queremos mostrar, partiendo del nombre y obteniendo la ruta que hemos configurado en el helper. Para ello añadiremos la siguiente línea:

<img src="<?= $this->Image->getRutaImagenes.'/mi_imagen.png ?>" />

Esta línea llamará al método ‘getRutaImagenes‘ del helper ‘Image‘, devolviendo como resultado la ruta que hemos configurado a la carpeta de las imágenes, quedando finalmente la imagen creada de este modo:

<img src="/image/carpeta1/carpeta1a/mi_imagen.png" />

Ahora con cambiar la ubicación que se ha configurado en el ‘Helper’ ya quedaría cambiada en todas las imágenes.

The post CakePHP, creación y utilización de Helpers appeared first on Developando.com.

Configurar el nuevo manejador de excepciones

Un ‘Exception handler‘ o manejador de excepciones será una clase encargada de capturar las excepciones y tratarlas, mostrando en pantalla la salida correcta. Creando nuestro propio manejador de excepciones conseguiremos tener control absoluto sobre las nuevas excepciones que vayamos creando en nuestra aplicación CakePHP.

Lo que vamos a hacer es reutilizar el manejador de excepciones que viene definido en CakePHP. Por tanto para ello crearemos un nuevo majenador que extienda del que viene por defecto.

PASO 1: para crear el nuevo manejador de excepciones debemos editar el fichero de configuración del núcleo de CakePhp, ‘~/app/Config/core.php‘, añadiendo esta línea en la que se indica:

Configure::write('Exception.handler', 'MyExceptionHandler::handle');

• Nombre de la clase del nuevo manjeador de excepciones: ‘MyExceptionHandler’
• Nombre del método que se ejecutará al capturar la excepción: ‘handle’

Al añadir la configuración del nuevo ‘Exception.handler‘ CakePHP ignorará el resto de configuraciones previas existentes para manejar excepciones, pero como nosotros vamos a crear un manejador que herede del que ya existe el comportamiento será el mismo, salvo que ahora tendremos control sobre nuestro manejador de excepciones, pudiendo realizar las acciones que se requieran.

PASO 2: añadir la siguiente línea al fichero de configuración de CakePhp ‘~/app/Config/bootstrap.php‘:

App::uses('MyExceptionHandler', 'Lib');

PASO 3: crear la clase para el nuevo manejador de excepciones. Para ello crear el fichero ‘~/app/Lib/MyExceptionHandler.php‘. En este clase añadiremos un método que será el que se ejecute cuando se produzca alguna excepción en la aplicación y que se configuró en el ‘paso 1′. Por tanto, el contenido de este fichero quedará de la siguiente forma:

class MyExceptionHandler extends ErrorHandler{
    public static function handle($error) {
        echo 'Exception capturada por Developando: '.$error->getMessage();
    }
}

Tras realizar estos pasos todas las excepciones que se produzcan en la aplicación serán tratadas por el método ‘handle($error)‘ de la nueva clase que hemos creado.

Con esta configuración hecha hasta el momento, cuando se produzca una excepción veremos una pantalla en blanco con una línea con el mensaje de dicha excepción.

Esta sería una línea de ejemplo de una posible salida por pantalla de nuestra aplicación frente a una excepción:

Exception capturada por Developando: SQLSTATE[23000]: Integrity constraint violation: 1048 Column 'id' cannot be null

El siguiente paso que se debe seguir es dar formato a la página donde se están mostrando las excepciones, y tratralas de la forma conveniente para realizar alguna acción en función del código o mensaje de error que contenga cada excepción capturada. Esto se tratará en futuros tutoriales.

Si lo que quieres es que se sigan tratando las excepciones como hasta ahora se debe hacer una llamada a un método para que todo siga igual ya que previamente la configuración que había en el fichero ‘~/app/Config/core.php‘ indicaba que el método que manejaba las excepciones se llamaba ‘handleException‘ y estaba en la clase ‘ErrorHandler‘.  Por tanto nuestro manejador de excepciones quedaría de la siguiente forma, realizando una llamada al método original que tiene heredado:

<?php
class MyExceptionHandler extends ErrorHandler{
    public static function handle($error) {
        // Ejecutar método heredado que manejaba las excepciones
        parent::handleException($error);
        // Hacer las acciones que se quieran: mensajes de log...
        / ...
    }
}
?>

Si tienes alguna duda, queja o sugerencia déjanos tu comentario y te contestaremos gustosamente.

The post CakePHP, crear nuestro propio manejador de excepciones o Exception.handler appeared first on Developando.com.