CakePHP

CakePHP tiene varias características que lo hacen una gran opción como framework para desarrollo de aplicaciones rápidas y con un coste relativamente poco elevado.

• Comunidad activa y amigable
• Licencia flexible
• Compatibilidad con PHP4 y PHP5
• CRUD integrado para la interacción con la base de datos y las preguntas simplificadas
• Scaffolding
• Arquitectura Modelo Vista Controlador (MVC)
• Despachador de peticiones con buena vista, URL personalizadas
• Validación incorporada
• Plantillas rápidas y flexibles (Sintaxis PHP, con Helpers)
• Helpers en Vistas para AJAX, Java script, Formularios HTML y más
• Seguridad, Sesiones y Componentes para Manejo de Peticiones
• Lista de Control y Acceso flexible
• Desinfección de datos
• Caché flexible en Vistas
• Trabaja desde cualquier subdirectorio web del sitio, con poca o ninguna configuración de Apache envuelta

CakePHP y MVC

CakePHP proporciona clases para el Controlador, Modelo y la Vista, pero adicionalmente incluye algunas clases más para mejorar el tratamiento a cada capa y hacer el desarrollo más sencillo y rápido. Componentes, Comportamientos y Helpers son clases que proveen de extensabilidad y reusabilidad a la base de las clases del MVC.

Extensiones de los Controladores ("Componentes")

Un componente es una clase que ayuda a la lógica de un controlador. Si tienes alguna lógica y la quiere compartir entre varios controladores (o aplicaciones), un componente suele ser una buena elección. En lugar de escribir lógica en el método de un controlador, se puede empaquetar en un componente para poder compartirla.

Los Controladores también están equipados con callbacks. Puedes utilizar estos callbacks si necesitas insertar alguna lógica en las operaciones del núcleo de CakePHP. Los Callbacks disponibles incluyen:

• beforeFilter(), se ejecuta antes que cualquier otra acción del controlador
• beforeRender(), se ejecuta después de la lógica del controlador, pero antes de que la vista se renderice
• afterFilter(), se ejecuta después de toda la lógica del controlador, incluido el renderizado de la vista. Puede que no haya ninguna diferencia entre afterRender() y afterFilter(), a menos que hayas llamado manualmente a render() en el controlador y hayas incluido alguna lógica después de esa llamada.

Extensiones de las Vistas

Un ayudante (Helper) es una clase que ayuda a la lógica de una vista. Del mismo modo que varios controladores utilizan un componente, los ayudantes hacen que varias vistas accedan y compartan lógica presentacional. Con uno de los ayudantes del núcleo, el AjaxHelper, el manejo de las peticiones Ajax en las vistas es mucho más fácil.

La mayoría de las aplicaciones repiten piezas de código en sus vistas. CakePHP facilita la reutilización de este código con diseños (layouts) y elementos (elements). Por defecto, toda vista renderizada por un controlador se coloca en un diseño (layout). Los elementos entran en juego cuando hay que reutilizar estos fragmentos pequeños de contenido.

Extensiones de los Modelos

Del mismo modo, los Comportamientos (Behaviors) son formas de añadir funcionalidad común entre los modelos. Por ejemplo, si almacena datos de los usuarios en una estructura de árbol, puede especificar que su modelo de usuario se comporte como un árbol, y obtener libre funcionalidad para eliminar, añadir y mover nodos en la estructura de árbol subyacente.

Los modelos también cuentan con el apoyo de otra clase llamada DataSource (Origen de datos). Los DataSource son una abstracción que permite a los modelos manipular diferentes tipos de datos de forma consistente. Si bien la principal fuente de datos en una aplicación CakePHP es a menudo una base de datos, puede escribir DataSources adicionales que les permitan a sus modelos representar canales RSS, archivos CSV, entradas LDAP, o eventos iCal. Los DataSources le permiten asociar registros de diferentes fuentes: en lugar de limitarse sólo a uniones (joins) SQL, los DataSources le permiten decirle a su modelo LDAP que está asociado a muchos eventos iCal. Así como los controladores, los modelos también incluyen callbacks:

• beforeFind()
• afterFind()
• beforeValidate()
• beforeSave()
• afterSave()
• beforeDelete()
• afterDelete()

Los nombres de estos métodos deben ser lo suficientemente descriptivos para que sepa lo que hacen.

Controladores

Un controlador es usado para manejar la lógica de cierta sección de la aplicación. Comúnmente, los controladores son usados para manejar la lógica de un sólo modelo. Por ejemplo, si estás construyendo un sitio que maneja una colección de vídeos, podrías tener un VideoController y un AlquilerController manejando los vídeos y los alquileres, respectivamente. En Cake, los nombres de los controladores están siempre en plural.

Los controladores de tu aplicación son subclases de la clase AppController de Cake, que a su vez extiende la clase principal Controller. Los controladores pueden tener cualquier cantidad de acciones (funciones usadas en tu aplicación web para mostrar vistas).

La clase AppController puede ser definida en /app/app_controller.php y debe contener métodos que son compartidos entre dos o más controladores. A su vez, AppController es una subclase de Controller que es una clase de la biblioteca estándar de Cake. Una acción es una única funcionalidad de un controlador. Es ejecutada automáticamente por el Dispatcher si una solicitud de página entrante la especifica en la configuración de rutas (routes). Retomando el ejemplo de la colección de vídeos, nuestro VideoController podría tener las acciones view(), rent(), y search(). El controlador debería estar ubicado en /app/controllers/videos_controller.php y contener:

class VideosController extends AppController
{
  function view($id)
  {
    //lógica de la acción...
   }
  function rent($customer_id, $video_id)
  {
    //lógica de la acción...
  }

  function search($query)
  {
    //lógica de la acción...
  }
}

El App Controller

La clase AppController es la clase superior a todos los controladores de la aplicación. AppController extiende la clase Controller incluida en la librería base de CakePHP. Las propiedades y métodos creados en tu AppController estarán disponibles para todos los controladores de tu aplicación. Es el sitio ideal para poner el código que será común a todos los controladores de la aplicación. CakePHP combina las siguientes variables de AppController con los controladores de tu aplicación:

• $components
• $helpers
• $uses: es un atributo que le permite acceder a modelos adicionales al que por defecto se encuentra definido. Si ponemos como ejemplo una aplicación, como un blog, por defecto sólo se tiene acceso al modelo Post, pero si se utiliza un código como el siguiente, se tendrá acceso al modelo Comment:

<?php
class PostsController extends AppController {
var $name = 'Posts';
var $uses = array('Post', 'Comment');
}
>

Desde que Comment está asociado a Post a través de una relación "tiene" , se puede acceder al modelo Comment a través de Post , de la siguiente manera:

$comments = $this->Post->Comment->findAllByPostId($id);

Esta relación en cadena se extiende de forma indefinida, incluyendo todos los modelos debajo de la línea. En ocasiones esto es muy ineficiente. Es necesario evitarlo en la manera de lo posible y utilizar otros medios para proporcionar la misma funcionalidad. Tener uno o dos modelos extras en su $uses no matará la aplicación pero incrementa el trabajo en torno a un 5% por cada modelo extra, así que con siete u ocho modelos extra, la página tardará en cargarse un 40% más.

El Pages Controller

El núcleo de CakePHP viene con un controlador por defecto llamado Pages Controller (el Controlador de Páginas) (cake/libs/controller/pages_controller.php). La página de inicio que se ve tras la instalación es generada utilizando este controlador.

Atributos del controlador

$name

Los usuarios de PHP4 deberían empezar la definición de sus controladores con el atributo $name. Este atributo debería ser asignado con el nombre del controlador. Usualmente este es simplemente el plural del modelo principal al que el controlador está asociado. Esto previene algunos problemas de distinción de mayúsculas que tiene PHP4 para los nombres de las clases.

<?php
class RecetasController extends AppController {
var $name = 'Recetas';}?>

$components, $helpers y $models

Los siguientes atributos más utilizados del controlador indican a CakePHP qué ayudantes (helpers), componentes (components), y modelos (models) utilizarás en conjunción con el controlador actual.

Atributos Relacionados con la Página: "$layout" y "$pageTitle"

Existen unos pocos atributos en los controladores de CakePHP que te dan control sobre cómo se colocan tus vistas (views) dentro del diseño (layout).

El Atributo de Parámetros ("$params")

Los parámetros del controlador están disponibles en $this->params en tu controlador de CakePHP. Esta variable es usada para proporcionar acceso a la información sobre la petición actual. El uso más común de $this->params es obtener acceso a información que ha sido entregada al controlador a través de las operaciones POST o GET.

form
$this->params['form']

Cualquier dato POST de cualquier formulario se almacena aquí, incluyendo información también hallada en $_FILES.

Admin
$this->params['admin']

Componentes

Los componentes son paquetes de lógica que son compartidos entre los controladores. CakePHP incluye un conjunto de componentes listos para usar para conseguir ayuda con:

• Seguridad
• Sesiones
• Lista de control de acceso (ACL)
• Emails
• Cookies
• Autenticación
• Manejo de pedidos (Requests)

Modelos

Estos separan el domino lógico de la presentación, aislando la lógica. Un Modelo es generalmente un punto de acceso a la base de datos, más específicamente a una tabla de la base de datos. Por defecto, cada modelo usa la tabla cuyo nombre es el plural de dicho modelo. Ej. el modelo 'User' usa la tabla 'users'. Los Modelos también pueden contener reglas de validación de datos, información sobre asociaciones, y métodos específicos para la tabla que usan. De esta manera es como se ve un modelo simple de Usuario (User) en Cake:

<?php
  // AppModel te da toda la funcionalidad de un Modelo en Cake
  class User extends AppModel
  {
       // Siempre es buena práctica incluir esta variable
       var $name = 'User';
       // Esto es usado para validar datos,
       var $validate = array();
       // También puedes definir asociaciones
       // Mira la sección 6.3 para más información.
       var $hasMany = array('Image' =>
         array('className' => 'Image')
         );
       // También puedes incluir tus propias funciones:
        function makeInactive($uid)
        {
          // Coloca tu lógica aquí
        }
  }
?>

Funciones del Controlador

Aunque esta sección describirá las funciones más usadas en los controladores de Cake, es importante recordar usar la api oficial como una referencia completa.

Interactuando con tus Vistas

• set( string $variable, mixed $valor): Esta función es la principal manera de llevar datos desde el controlador a la vista. Puedes usarla para enviar lo que sea: variables, arreglos, etc. Una vez usado, la variable puede ser usada en tu vista; ejecutando set('color', 'blue') en tu controlador hace que la variable $color este disponible en la vista.
• validateErrors: Retorna la cantidad de errores generados por un un guardado no exitoso.
• validate: Valida los datos del modelo de acuerdo a sus reglas de validación.
• render(string $accion, string $layout, string $archivo): Esta función puede que no la necesites muy a menudo, ya que render() es llamada automáticamente al final de cada acción del controlador, y será renderizada la vista con el mismo nombre de la acción del controlador. Un uso alternativo podría ser ejecutar esta función en cualquier parte de la lógica del controlador.

Redirección de Usuarios

• redirect(string $url): Indica al usuario hacia dónde dirigirse. La URL usada como parámetro puede ser una URL interna del Cake, o una URL.
• flash(string $mensaje, string $url, int $pausa): Esta función muestra el mensaje ($mensaje) el número de segundos indicado por $pausa dentro del layout de flash (ubicado en app/views/layouts/flash.thtml). Tras esto redirecciona al usuario a la $url especificada.

Las funciones redirect() y flash() de Cake no incluyen una llamada a exit(). Si deseas que tu aplicación termine tras un redirect() o flash(), deberás incluír tu propia llamada a exit() inmediatamente despúes. También es preferible llamar a return en vez de exit(), dependiendo de la situación (por ejemplo, si necesitas que se ejecute un callback).

Callbacks de Controlador

Los controladores de Cake incorporan algunos callbacks que pueden ser usados para ejecutar código antes o despúes de alguna función del controlador. Para utilizar esta funcionalidad se deben declarar estas funciones en el controlador usando los parámetros y valores de retorno aquí detallados.

• beforeFilter: Llamada antes de cada acción del controlador. La función perfecta para verificar sesiones activas y privilegios de usuarios.
• afterFilter: Llamada después de cada acción del controlador.
• beforeRender: Llamada después de la lógica del controlador, y justo antes que una vista es renderizada.

Otras Funciones Útiles

A pesar de que estas funciones son parte de la clase Object de Cake, también estan disponibles dentro de un Controlador:

• requestAction(string $url, array $extra): Esta función llama a una acción del controlador desde cualquier ubicación y devuelve su vista renderizada. La $url es una URL de Cake (/nombrecontrolador/nombreaccion/parametros). Si el array $extra incluye el índice 'return', AutoRender es automáticamente dejado en true para la acción del controlador. Puedes usar requestAction para obtener datos desde otra acción del controlador u obtener una vista totalmente renderizada desde un controlador.
• log( string $message, int $tipo = LOG_ERROR): Puedes usar esta función para guardar un log de diferentes eventos que ocurren dentro de tu aplicación web. Los logs quedan guardados en el directorio /tmp de Cake. Si $tipo equivale a la constante LOG_DEBUG de PHP, el mensaje será escrito al log como un mensaje de tipo debug. Cualquier otro tipo es escrito al log como un error.

Vistas

Una vista es una plantilla llamada ante una acción. Por ejemplo, la vista PostController::add() será encontrada en /app/views/post/add.thtml. Las vistas en Cake son simples archivos PHP, asi puede usar código PHP dentro de ellas. Aunque la mayoría de sus archivos de vista contienen HTML, una vista puede ser, ciertamente, un grupo de datos, ser un XML, una imagen, etc. En la plantilla del archivo vista puede usar los datos desde el correspondiente modelo. Estos datos son pasados como un array llamado $data. Cualquier dato que usted maneje en la vista usando set() en el controlador está también disponible en su vista.

El helper HTML está disponible en cualquier vista por defecto, y es el helper más usado en las vistas. Es muy útil en la creación de formularios, incluyendo scripts y multimedia, enlazando y agregando validación de datos.

La mayoria de las funciones disponibles en las vistas son provistas por Helpers. Cake viene con un gran conjunto de helpers (discutido en el capitulo “Helpers”), y usted puede incluir el suyo. Porque las vistas no contienen mucha lógica, no hay muchas funciones publicas en la clase vista.

Layouts

Un layout contiene todo el código de presentación que se oculta alrededor de una vista. Cualquier cosa que quiera ver en todas sus vistas debe estar en su layout. Los archivos Layout estan ubicados en /app/views/layouts. El layout por defecto puede ser sobreescrito, colocando un nuevo layout en /app/views/layouts/default.thtml. Una vez que el nuevo layout por defecto es creado, el código contralador de la vista es puesto dentro del layout por defecto cuando la página es recargada. Cuando usted crea un layout, necesita decirle a Cake dónde poner el codigo del controlador: para hacer esto,asegurese que su layout incluye un lugar para $content_for_layout (y opcionalmente, $title_for_layout).

Elementos

Muchas aplicaciones tienen códigos pequeños en bloques de presentación que necesitan ser repetidos página a página, algunas veces en lugares diferentes en el layout. Cake puede ayudar a repetir partes de su sitio web que necesitan ser reusadas. Esas partes reusables son llamada Elementos. Anuncios, cajas de ayuda, controles de navegacion, menús extras y llamadas son a menudo implementados en Cake como elementos. Un elemento es básicamente una mini-vista que puede ser usada en otras vistas. Los elementos se almacenan en la carpeta /app/views/elements/ y tienen la extension de archivo .thtml

// Llamando un Elemento sin parámetros
<?php echo $this->renderElement('helpbox'); ?>

//Llamando un Elemento pasando datos en un array
<?php echo $this->renderElement('helpbox',array("helptext"=>"Oh, this
text is very helpful")); ?>

Dentro del archivo Elemento, todas las variables pasadas están disponibles con el nombre de las llaves del array (muy parecido como set() trabaja en el controlador con las vistas). En el ejemplo de arriba, el archivo /app/views/elements/helpbox.thtml puede usar la variable $helptext. Desde luego, podría ser más práctico pasar un array al elemento. Los elementos pueden ser usados para hacer una vista más fácil de leer, colocando la presentación del elemento repetido en su propio archivo. Pueden ayudarle también a reusar fragmentos de contendido en su sitio web.