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 Blog Developando.

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' => "[email protected]",
 'host' => "smtp.gmail.com",
 'port' => 465,
 'username' => '[email protected]',
 '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 Blog Developando.

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 Blog Developando.

Ordenar los resultados de la consulta

Veamos un simple ejemplo de una consulta que devuelve todas las personas que están almacenadas en una tabla de la base de datos. Para obtener todas las personas de la tabla utiliaríamos la siguiente línea:

$this->Personas->find("all");

Orden ascendente

Con la línea anterior obtendríamos un listado con todas las personas, pero ahora lo que queremos es que este listado esté ordenado alfabéticamente. Entonces a la consulta anterior deberemos añadirle la condición ‘order’ para indicar el orden en el que serán devueltos los registros:

$this->Personas->find("all",array('order'=>'Personas.nombre'));

Añadiendo el parámetro ‘order’ ahora los resultados serán ordenados de la ‘A’ a la ‘Z’.

Orden descendente

Para ordenarlos de forma descendente deberemos utilizar la siguiente línea, indicando ahora ‘order DESC‘:

$this->Personas->find("all",array('order'=>'Personas.nombre DESC'));

Los resultados serán devueltos ahora ordenados de la ‘Z’ a la ‘A’.

Agrupar los resultados de la consulta

Si lo que se quiere es agrupar el resultado de la consulta debermos utilizar el parámetro ‘group‘:

$this->Personas->find("all",array('group'=>'Personas.ciudad'));

Con estos dos parámetros ‘group‘ y ‘order‘ podrás agrupar y ordenar el resultado de todas tus consultas.

The post CakePHP, ordenar y agrupar resultados consultas base de datos appeared first on Blog Developando.

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 Blog Developando.

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 Blog Developando.

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 Blog Developando.

Ejemplo 1, variable global con el nombre del usuario

Vamos a ver un sencillo ejemplo de variable global en un controlador de CakePHP. Vamos a crear una variable que almacene el nombre de una persona, y lo utilizaremos en dos métodos diferentes del mismo controlador:

public class MyController{
      var $nombreGlobal = "David";
 
      public function saludar(){
          return "Hola ".$this->nombreGlobal; // Devolverá 'Hola David'
      }
 
      public function despedir(){
          return "Adios ".$this->nombreGlobal; // Devolverá 'Adios David'
      }
}

En este ejemplo vemos que se utiliza la misma variable en los dos métodos que tiene el controlador.

Ejemplo 2, variable global con un contador

class MyController {
 
      var $contador = 0;
 
      public function inciar(){
           while($this->contador < 10){
                $this->contador++;
           }
           finalizar();
      }
 
      public function finalizar(){
           return "Contador acabado en :".$this->contador; // Devolverá 'Contador acabado en : 10'
      }
}

En este ejemplo tenemos un variable global que será incrementada en un método hasta llegar a un límite. Cuando se alcanza el límite, se llama a otro método que mostrará el valor con el que se ha detenido.

Ejemplo 3, variables globales utilzando herencia

En el caso de querer compartir una variable entre varios controladores, lo que se debe hacer es tener un controlador ‘Padre’ del que van a heredar todos los que necesiten dicha variable.

Creamos el controlador ‘padre’ con la variable global

El controlador ‘padre’ tiene la variable que será usada por el resto de controladores que hereden de él:

class AppController {
      var $nombreGlobal = "Developando";
 }

Controladores heredados

Controladores que van a acceder a la variable global definida.

3.1 – Primer controlador

class SaludarController extends AppController {
      public function saludar(){
          return "Hola ".$this->nombreGlobal; // Devolverá 'Hola Developando'
      }
 }

3.2 – Segundo controlador

class SaludarController extends AppController {
      public function despedir(){
          return "Adios ".$this->nombreGlobal; // Devolverá 'Adios Developando'
      }
 }

En este ejemplo vemos que en un controlador se ha definido una variable global llamada ‘nombreGlobal‘ que es utilizada por dos controladores. Para conseguir esto únicamente hemos tenido que añadir ‘extends AppController‘ en los controladores hijos y así emplear la herencia de CakePHP, y por tanto, poder acceder a dicha variable.

Estos serían un ejemplos sencillos para ver el uso de una variable global dentro de un controlador en CakePHP.

The post CakePHP, uso de variables globales en controladores appeared first on Blog Developando.

Si no sigues estos pasos, cuando ejecutes la acción del controlador de CakePHP, se lanzará una excepción de este tipo, en el que se indica que no exite un fichero con la plantilla de la página a renderizar:

Error: The view for MiFuncionController::miFuncion() was not found.
 
Error: Confirm you have created the file: c:\MiApp\app\View\MIFuncion\mi_funcion.ctp

Para evitar que salte esta excepción únicamente hay que añadir la siguiente línea al final del método que ejecuta la acción del controlador de CakePHP:

$this->autoRender = false;

A continuación mostramos un método que devolverá un mensaje pero que no cargará ninguna vista:

public function accionSinVista(){
 
        $this->set('result', "Resultado de la operación.");
 
        // No se va a mostrar nada por pantalla, no renderizar vista
        $this->autoRender = false;
 
}

Esto puede ser útil para obtener valores a través de peticiones ajax desde el navegador. Queremos que se ejecute una lógica en el servidor, pero no es necesario que se muestre una página. También podría ser útil cuando se realiza la lógica necesario y se redirecciona a otra vista.

The post CakePHP, ejecutar acción de controladores sin renderizar la vista appeared first on Blog Developando.

Para los javeros, Composer es a php lo que puede ser Maven a Java, en resumen, un gestor de dependencias para nuestros proyectos php. Además, ya no es solo que podamos gestionar las dependencias sino que podemos crear, por ejemplo, la estructura de nuestros proyectos sobre cakePHP con Composer, lo que simplifica y agiliza tanto la creación como el mantenimiento ante posibles publicaciones de versiones posteriores.

Vamos a ver como crear nuestro esqueleto de cakePHP con Composer.

INSTALACIÓN DE COMPOSER

Para instalar Composer debemos ir a la página del proyecto y descargar la versión correspondiente a nuestro sistema operativo y seguir las instrucciones que en la misma página encontramos.

PROYECTO CAKEPHP VÍA COMPOSER

Creamos nuestro proyecto (estoy utilizando phpStorm como IDE de desarrollo) en la raíz de nuestro proyecto creamos el fichero composer.json … WTF!? vale, me explico, en este fichero es donde incluiremos las dependencias y los repositorios donde buscar estas dependencias … un ejemplo para verlo más fácil, en mi proyecto cakePHP este es mi fichero composer.json :

{
    "name": "cakePhpProject",
    "repositories": [
        {
            "type": "pear",
            "url": "http://pear.cakephp.org"
        }
    ],
    "require": {
        "pear-cakephp/cakephp": ">=2.3.4"
    },
    "config": {
        "vendor-dir": "Vendor/"
    }
}

Como se observa este fichero incluye el nombre del proyecto, la definición de los repositorios y las dependencias. La página de referencia donde buscar los paquetes a añadir en nuestros proyectos es Packagist. (Este compose.json es para crear el proyecto base de CakePHP).

El siguiente paso consiste en obtener el fichero compose.phar en la raíz de nuestro proyecto, esto lo podemos hacer ejecutando el siguiente comando en la raíz de nuestro proyecto:

php -r "eval('?>'.file_get_contents('https://getcomposer.org/installer'));"

Otra forma es descargarlo directamente de aquí y copiarlo en la raíz de nuestro proyecto.

Ahora debemos ir a la consola, situarnos en la raíz del proyecto (donde estará el fichero composer.json) y ejecutar php composer.phar install que leerá nuestro fichero compose.json y descargará los paquetes de CakePHP en nuestro directorio Vendor. 

Ahora ya podemos generar el esqueleto de nuestro proyecto cakePHP. Para ello, desde la consola nos ubicamos en /Vendor/bin si listamos los ficheros veremos que ya tenemos el fichero cake.php.bat que será el que utilizaremos según las instrucciones de cakePHP para generar nuestro esqueleto de proyecto.

Una vez ejecutado si volvemos a nuestro editor voilà! veremos que tenemos el proyecto cakePHP bien formado. Ahora te recomiendo que pruebes a instalar el paquete Debug_kit para cakePHP ya que te proporciona mucha información interesante para desarrollar tus aplicaciones cakePHP.

PD: Para instalar Debug_kit tendrás que tener instalado git.

¡Suerte!

The post Crear un proyecto CakePHP con Composer appeared first on Blog Developando.