Funciones globales

Éstas son las funciones globales disponibles en CakePHP. Muchas de ellas simplemente facilitan la llamada a funciones de PHP con nombres largos, pero otras (como vendor() y uses()) se pueden usar para incluir código o realizar otras funciones útiles. Lo más probable es que si estás buscando una función para realizar una tarea con mucha frecuencia, la encuentres aquí.

__

__(string $string_id, boolean $return =  false)

Esta función gestiona la localización en las aplicaciones CakePHP. El parámetro $string_id identifica la ID de una traducción, mientras que el segundo parámetro indica si se debe mostrar automáticamente la cadena (por defecto), o devolverla para su procesamiento (pasar el valor true para que esto suceda).

Visita la sección Localización e Internacionalización para más información.

am

am(array $uno, $dos, $tres...)

Combina todos los arrays pasados como parámetros y devuelve el array resultante.

config

Puede ser usado para cargar archivos desde el directorio config mediante include_once. La función checa si existe el archivo antes de incluir y regresa un booleano. Toma un número opcional de argumento.

Ejemplo: config('some_file', 'myconfig');

convertSlash

convertSlash(string $cadena)

Sustituye las barras (“/”) por subrayados (“_”) y elimina el primer y el último subrayados en una cadena. Devuelve la cadena convertida.

debug

debug(mixed $var, boolean $showHtml = false)

Si el nivel de depuración, variable de configuración DEBUG, es distinto de cero, se muestra $var. Si $showHTML es true, los datos se formatean para mostrarlos adecuadamente en los navegadores web.

env

env(string $key)

Obtiene una variable de entorno a partir de las fuentes disponibles. Alternativa si las variables $_SERVER o $_ENV están deshabilitadas.

También permite emular las variables PHP_SELF y DOCUMENT_ROOT en los servidores que no permitan su uso. De hecho, es una buena práctica usar env() en lugar de $_SERVER o getenv() (sobretodo si pensamos distribuir el código), ya que ofrece la misma funcionalidad y es totalmente compatible.

fileExistsInPath

fileExistsInPath(string $archivo)

Comprueba que el fichero $archivo está en el include_path actual de PHP. Devuelve un valor booleano.

h

h(string $texto, string $charset)

Alias de la función htmlspecialchars().

pr

pr(mixed $var)

Alias de la función print_r(), añadiendo la etiqueta <pre> a la salida.

stripslashes_deep

stripslashes_deep(array $valor)

Elimina recursivamente las barras invertidas de $valor. Devuelve el array modificado.

Traducción en cakePHP

CakePHP usa los archivos ‘po’ para manejar las traducciones. Para poder realizar las traducciones es conveniente usar un editor:

https://poedit.net/download

Lo primero que debemos hacer es obtener las cadenas de texto susceptibles de ser traducidas. Nos colocamos en la carpeta ‘app’ de nuestra aplicación y ejecutamos lo siguiente:

Console/cake i18n extract

Nos hace una serie de preguntas a las que podemos contestar con ‘intro’ escogiendo siempre la opción por defecto. En Locale nos va a generar varios archivos ‘.pot’ con las cadenas de las traducciones. A nosotros nos interesa ‘default.pot’.

En el poedit generamos un archivo nuevo, le llamaremos ‘default.po’. Añadimos las cadenas desde el default.pot y las traducimos. El archivo resultante lo podemos guardar en:

\app\Locale\eng\LC_MESSAGES\default.po

O bien en la carpeta local correspondiente, por ejemplo:

/app/Locale/esp/LC_MESSAGES/default.po

Para indicarle que estamos usando otra traducción debemos indicarlo con la siguiente línea en \app\Config\core.php:

Configure::write('Config.language', 'esp');

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'));
 }