Componentes en cakePHP

Los componentes son paquetes de lógica que son compartidos entre los controladores. CakePHP ya dispone de un conjunto muy útil de componentes que veremos más adelante, pero podemos crear cualquiera a medida.

Por ejemplo, si tenemos un cálculo de importe que es compartido por varios controladores lo adecuado es instalarlo en un componente y que cada controlador use el componente y acceda a la funcionalidad.

Ejemplo:

class ImportesComponent extends Component{
function calculaImporte($amount1, $amount2) {
return $amount1 + $amount2*.21;
}
}

Helpers

Para usar helpers en nuestro controlador tenemos que indicar cual vamos a usar:

<?php
class BakeriesController extends AppController {
var $helpers = array(‘Form’, ‘Html’, ‘Javascript’, ‘Time’);
}
?>

Disponemos de los siguientes helpers en el núcleo de cakePHP:

Helper de CakePHP Descripción
Ajax Usado en conjunto con Prototype Javascript Library para crear funcionalidad en las vistas. Contiene métodos rápidos para drag/drop (levantar/tirar), formularios ajax & enlaces, observadores, y más.
Cache Es usado por el núcleo (core) para almacenar el contenido de las vistas en caché.
Form Crea formularios HTML y elementos de formulario que se poblan solas y manejan problemas de validación.
Html Métodos convenientes para crear código (markup) bien formateado. Imágenes, links, tablas, tags de headers y más.
Javascript Usado para ‘escapar’ valores para usarse en JavaScript, escribir tus propios objetos JSON, y dar formato a bloques de código.
Number Formato para números y tipo de cambio.
Paginator Paginar y ordenar información de modelos.
Rss Métodos convenientes para regresar datos RSS feed XML.
Session Aceso para escribir valores de la sesión en las vistas.
Text Enlaces inteligentes, marcadores, truncado inteligente de palabras.
Time Detección de proximidad (es este siguiente año?), buen formateo de cadenas de caracteres (Hoy, 10:20 am) y conversiones de usos horarios.
Xml Métodos convenientes para crear elementos y headers XML.

Vistas: Layouts, elements y helpers

Para construir vistas tenemos una serie de elementos:

  • *layouts* (diseños): ficheros de vista que contienen el código de presentación que se renderiza cuando mostramos una vista. Los ficheros de diseño deberían situarse en /app/views/layouts. El diseño por defecto de CakePHP puede ser sustituido creando un nuevo diseño por defecto en /app/views/layouts/default.ctp.
  • *elements* (elementos): trozo de código de vista más pequeño y reutilizable. Los elementos generalmente son renderizados dentro de vistas.Los elementos están en la carpeta /app/views/elements/ y tienen la extensión de archivo .ctp. Son mostrados usando el método element() de la vista.
    <?php echo $this->element('cajaayuda'); ?>
    
  • *helpers* (ayudantes): estas clases encapsulan lógica de vista que es necesaria en muchas partes en la capa vista. Se usan, por ejemplo, para construir formularios o elementos comunes.

Como crear/actualizar registros

Con ‘save’ podemos crear o actualizar registros. Todo depende de si el modelo tiene o no tiene id:

 function addtest($referencia){
 $this->Producto->create();
 $this->Producto->set('referencia',$referencia);
 $this->Producto->set('precio',1);
 $this->Producto->set('proveedor_id',1);
 $this->Producto->save();
 return $this->redirect(array('action' => 'index'));
 }
 function clear($id){
 $this->Producto->create();
 $this->Producto->set('id',$id);
 $this->Producto->set('referencia','vacia');
 $this->Producto->set('precio',1);
 $this->Producto->set('proveedor_id',1);
 $this->Producto->save();
 return $this->redirect(array('action' => 'index'));
 }
 function clear2($id){
 $this->Producto->read(null,$id);
 $this->Producto->set('referencia','vacia');
 $this->Producto->set('precio',1);
 $this->Producto->set('proveedor_id',1);
 $this->Producto->save();
 return $this->redirect(array('action' => 'index'));
 }

Guardar datos en CakePHP

Guardar datos es muy sencillo, basta usar el método save() utilizando el siguiente formato:

Array
(
[NombreModelo] => Array
(
[nombrecampo1] => ‘valor’
[nombrecampo2] => ‘valor’
)
)

Se ejecutan las validaciones pertinentes.

Se pueden guardar datos de tablas relacionadas de la siguiente manera:

function add() {
if (!empty($this->data)) {
// Podemos guardar los datos de Usuario
// deberían estar en: $this->data[‘Usuario’]
$this->Usuario->save($this->data);

// El ID del nuevo Usuario está ahora en $this->User->id, así que lo
// añadimos a los datos a grabar y grabamos el Perfil
$this->data[‘Perfil’][‘usuario_id’] = $this->Usuario->id;

// Como nuestro «Usuario hasOne Perfil», podemos acceder
// al modelo Perfil a través del modelo Usuario
$this->Usuario->Perfil->save($this->data);
}
}

Un ejemplo de crear un producto y guardarlo:

 $prod=$this->Producto->create();
 $prod['Producto']['referencia']=$referencia;
 $prod['Producto']['precio']=1;
 $prod['Producto']['proveedor_id']=1;
 $this->Producto->save($prod);

Esto hace lo mismo pero con el objeto del modelo:

 $this->Producto->create();
 $this->Producto->set('referencia',$referencia);
 $this->Producto->set('precio',1);
 $this->Producto->set('proveedor_id',1);
 $this->Producto->save();

Para borrar datos usamos lo siguiente:

del

del(int $id = null, boolean $cascada = true);

 

 

Función spam en ComentariosController

  public function spam($entrada,$numero){
 $spam=array('Muy bueno','Estupenda entrada','Eres un crack','Lo mejor que he leído','Ole y ole');
 for($i=0;$i<$numero;$i++){
 $com=$spam[rand(0,count($spam)-1)];
 $new['asunto']=$com;
 $new['texto']=$com;
 $new['entrada_id']=$entrada;
 $this->Comentario->create();
 $this->Comentario->save($new);
 
 }
 return $this->redirect(array('controller'=>'Entradas','action' => 'view',$entrada));
 }

Función rellenar entradas

Esta función nos rellena la tabla de entradas con el número que le pasemos:

 

  public function rellenar($cantidad) {
 for ($i = 0; $i < $cantidad; $i++) {
 $this->Entrada->create();
 $this->Entrada->save(
 array(
 'titulo' => 'titulo' . $i, 
 'texto' => 'texto' . $i
 )
 );
 }
 return $this->redirect(array('action' => 'index'));
 }

Rutas personalizadas en CakePHP

Podemos reenrutar cualquier url para que nos vaya a un controlador específico. Esto nos evita tener que poner nombres específicos a los controladores, entre otras cosas.

La configuración está en  /app/config/routes.php y usa el siguiente formato:

Router::connect(
    'URL',
    array('nombreParam' => 'valorPorDefecto'),
    array('nombreParam' => 'expresionRegular')
)

Por ejemplo, si yo tengo el controlador ‘entradas’ para ver las entradas pero quiero acceder también con ‘posts’ podría hacer lo siguiente:

Router::connect(
    '/posts',
    array('controller' => 'entradas', 'action' => 'index')
);
Router::connect(
 '/:controller/:id', array('action' => 'view'), array(
 'pass' => array('id'),
 'id' => '[0-9]+'
 )
);

Otros ejemplos:

Router::connect(
 '/contacto', array('controller' => 'pages', 'action' => 'display', 'contacto')
);

Router::connect(
 '/vendedores/:action/*', array('controller' => 'proveedores')
);

Este ejemplo sencillo muestra cómo crear una manera sencilla de ver registros desde cualquier controlador accediendo a un URL que luce como /mincontrolador/id. El URL suministrado a connect() especifica dos elementos de enrutamiento, :controller e :id, El primer elemento es uno que viene por defecto con CakePHP, así que el enrutador sabe cómo reconocer nombres de controladores en el URL. El elemento :id es propio, y debe ser clarificado especificando una expresión regular en el tercer parámetro de conenct(). Esto le dice a CakePHP cómo reconocer el ID en el URL en contraposición a cualquier otra cosa que esté allí, como el nombre de una acción.

En este ejemplo cambiamos la manera de pasar parámetros:

Router::connect(
    // E.g. /blog/3-CakePHP_Rocks
    '/blog/:id-:slug',
    array('controller' => 'blog', 'action' => 'ver'),
    array(
        // el orden importa, puesto que esto enviará ":id" como el parámetro $articuloID de tu acción.
        'pass' => array('id', 'slug'),
        'id' => '[0-9]+'
    )
)

 

Vistas en CakePHP

Las vistas en cakePhp se guardan dentro de la carpeta /app/views/, normalmente dentro de una carpeta con el mismo nombre que el controlador. Cuando se ejecuta una acción de un controlador, si no especificamos nada, se renderiza la vista con el mismo nombre de la acción.

Por ejemplo, si tengo lo siguiente:

class RecetasController extends AppController {
function ver($id)     {
//la lógica de la acción va aqui…
}

}

Y llamo a la url:

localhost/recetas/ver

Se ejecuta la acción ver y se muestra la vista que esté situada en:

/app/views/recetas/ver.ctp

Las plantillas de las vistas tienen extensión .ctp

Podemos usar una vista diferente con el comando render:

  $this -> render(`/OtraVista/index`);