Download - Manual CakePhp
Guía de CakePhp Manual sobre cómo implementar el framework CakePhp Aquí se darán pautas generales sobre como iniciar en CakePhp, así de cómo hacer para crear controladores, modelos, vistas, configurar el framework y crear servicios web
2013
Jorge Andrés Moreno Jaimes
24/09/2013
Contenido Descargar CakePhp .............................................................................................................................. 3
Instalar CakePhp .................................................................................................................................. 3
Configurar CakePhp:............................................................................................................................ 4
Configuraciones de seguridad: ........................................................................................................ 5
Security.salt: ................................................................................................................................ 5
Security.cipherSeed: .................................................................................................................... 5
Configurar Base Datos: .................................................................................................................... 6
Características de CakePhp: .............................................................................................................. 10
Convenios de nombres: ................................................................................................................. 10
Modelos: ....................................................................................................................................... 10
Consultas a la base de datos: .................................................................................................... 11
Find (tipo, parámetros): ........................................................................................................ 11
FindBy<Campo> (valor): ........................................................................................................ 12
Query(sql): ............................................................................................................................. 12
Almacenamiento de información: ............................................................................................. 13
Save(data): ............................................................................................................................ 13
Eliminación de Información: ..................................................................................................... 13
Del(id): ................................................................................................................................... 13
Controladores:............................................................................................................................... 14
Pasar datos a la vista: ................................................................................................................ 14
Set(nombre,valor): ................................................................................................................ 14
Vistas: ............................................................................................................................................ 15
Desarrollo de una Aplicación: ........................................................................................................... 16
Base de datos ................................................................................................................................ 16
Modelos: ....................................................................................................................................... 16
Controladores:............................................................................................................................... 17
Vistas: ............................................................................................................................................ 17
Controladores de la Aplicación ......................................................................................................... 18
EstudiantesController: .................................................................................................................. 18
Index: ......................................................................................................................................... 18
Add: ........................................................................................................................................... 19
Edit: ........................................................................................................................................... 20
Remove: .................................................................................................................................... 21
Descargar CakePhp
Para poder empezar con CakePhp, debemos ir a la página oficial y descargar la última versión.
Vamos a http://cakephp.org/ y damos clic en la zona seleccionada
Esperamos que la descarga finalice
Instalar CakePhp
Después de descargar CakePhp, descomprimimos la carpeta en nuestro servidor, quedándonos la
siguiente estructura:
Una vez descomprimido, podemos ir a la dirección de la página para comprobar si quedo bien la
instalación.
Como se ve en la imagen, muestra algunos errores, pero esto es debido a que nos falta configurar
el CakePhp para que todo ande bien. Si la página no les carga o les muestra algo como esto:
Asegúrense de haber escrito la dirección bien, y de haber descomprimido en el servidor. Si no
saben cómo instalar un servidor, o como hacer pruebas, pueden ver la siguiente guía.
Configurar CakePhp: Tras haber instalado el CakePhp, ahora procederemos a configurar algunas opciones básica de
seguridad y conectividad a la base de datos.
Configuraciones de seguridad:
Security.salt:
Para realizar esto abriremos el archivo core.php que se encuentra en la ruta app/Config/core.php
Buscamos la línea que contiene el siguiente texto: Configure::write('Security.salt',”textolargo”),
es algo como la imagen que sigue
Cambiamos el valor que tenía por defecto, por alguno de nuestro gusto.
Security.cipherSeed:
Buscamos en el mismo archivo el siguiente texto: Configure::write('Security.cipherSeed',
'numero');, es algo como la imagen que sigue
Cambiamos el valor que tenía por defecto, por alguno de nuestro gusto, pero en este caso, solo
serán números.
Luego, guardamos, y recargamos la página, y podremos ver que dichas advertencias han
desaparecido
Configurar Base Datos:
Copiamos el archivo app/config/database.php.default , y lo pegamos en la misma carpeta
Ahora renombramos el archivo copiado anteriormente por database.php
Nos quedara algo como lo que sigue
Abrimos el archivo database.php y buscamos el siguiente código
En donde modificaremos los parámetros necesarios para nuestra base de datos. Los datos a
modificar se describen a continuación:
Datasource: Es el driver para conectar a la base de datos
Persistent: Si la conexión a la base de datos va a ser persistente. Las conexiones
persistentes son enlaces que no se cierran cuando la ejecución del script termina.
Host: Es la url donde se encuentra el host o la dirección ip del host de la base de datos.
Login: El usuario para acceder a la base de datos.
Password: La contraseña del usuario escrito en Login.
Database: El nombre de la base de datos a consultar.
Prefix: Si las tablas traen algún prefijo, por default está vacío.
Quedando, en este ejemplo así:
Guardamos los cambios y recargamos la página y veremos que una notificación ha desaparecido
Características de CakePhp:
Convenios de nombres: CakePhp, nos va a facilitar muchas tareas si seguimos algunos parámetros que ellos establecieron
(dichas ventajas se verán más adelante al momento de realizar consultas a la base de datos). Las
convenciones más importantes se listan a continuación.
Los nombre de las tablas en la base de datos deben ir en plural, ejemplo: posts, noticias,
carros, usuarios, etc.
Las tablas deben tener una columna obligatoria que será la PrimariKey, que es de tipo
numérico y debe llamarse id
Los nombres de los controladores deben empezar en mayúscula y el nombre debe ser el
plurar de la tabla y terminar en Controller, ejemplo:
Nombre Controlador Nombre de la Tabla
PostsController posts NoticiasController noticias CarrosController carros UsuariosController usuario
Los nombres de los modelos es el singular de la tabla y empiezan con mayúscula, ejemplo
Nombre Modelo Nombre Controlador Nombre Tabla
Post PostsController posts Noticia NoticiasController noticias Carro CarrosController carros Usuario UsuariosController usuario
Modelos: Los modelos de la aplicación se localizan en la
carpeta app/Model y respetando los convenios
explicados con anterioridad. Los modelos son los
que nos permite interactuar con la base de datos,
realizar consultas (select), actualizaciones de
campos (update), borrado de registros (delete).
Para crear un Modelo debemos crear el archivo con
las convenciones descritas con anterioridad,
terminado en php. Para ejemplificar crearemos un
modelo de la tabla estudiantes.
Dentro del documento, se crea una clase PHP del mismo nombre del archivo que hereda de la
clase AppModel
Consultas a la base de datos:
Lo interesante de los modelos de CakePhp, es que al heredar de la clase AppModel, trae consigo
unas funciones que nos facilitaran mucho la vida, y nos permitirán realizar las consultas más
comunes sin escribir una sola línea de sql.
Find (tipo, parámetros):
Esta función nos permite realizar consultas a la base de datos, paramándole dos parámetros:
1. Tipo:
Tipo Descripción
all Busca todos los registros de la tabla, cumpliendo las condiciones declaradas en el vector parámetros
firts Devuelve el primer registro encontrado en la tabla, cumpliendo las condiciones declaradas en el vector parámetros
count Nos devuelve la cantidad de registro que hay en la base de datos, cumpliendo las condiciones declaradas en el vector parámetros
Para encontrar más información sobre este parámetro y todo los valores que puede
tomar, pueden ir a la documentación oficial
2. Parámetros:
Este es un vector opcional, que se le puede pasar a la función Find, dicho vector tiene el
siguiente esquema:
array(
'conditions' => array('Tabla.Campo' => $valor),
'recursive' => 1,
'fields' => array('Tabla.Campo1', 'Tabla.Campo2'),
'order' => 'Tabla.Campo ',
'group' => array('Tabla.Campo1'),
'limit' => n,
'page' => n
)
En donde:
o Conditions: Es un vector que contendrá las condiciones de la consultas, estas
condiciones son aquellas que en sql irán después de la cláusula WHERE.
o Fields: Es un vector donde se especifican en los campos que retornara la consulta,
estos campos son los que se declaran en sql después de la cláusula SELECT.
o Order: Es el elemento por el cual se ordenara la consulta, en sql es la columna que
va después de la cláusula ORDER BY
o Group: Es un vector donde se especifican los elementos a agrupar.
o Limit: Es un valor para determinar cuántos registros serán devueltos
Si desea consultar información adicional de todos los elementos del array parámetros, no
dude en consultar la documentación oficial.
FindBy<Campo> (valor):
Estas funciones nos permiten buscar en nuestras tablas aquellas cuyo valor de campo coincida con
el dado como parámetro. Si por ejemplo tenemos una tabla estudiantes con 3 campos (id,
nombre, apellido), podremos usar esta función de la siguiente manera:
CakePhp Sql
this->Estudiante->findById(3) Select * from estudiantes where id=3 this->Estudiante->findByNombre(“Oscar”) Select * from estudiantes where nombre=’oscar’ this->Estudiante->findByApellido(“Perez”) Select * from estudiantes where apellido=’perez’
Nótese, como ahorramos código de una manera sorprendente, pues esas funciones, no las
debemos de crear, solamente se implementan y nos ahorran una cantidad grande de código.
Query(sql):
Esta función será llamada, cuando una consulta sql sea tan compleja, que no pueda ser
solucionada por las anteriores funciones. Hay escribiremos el código sql que deseemos, ejemplo
$this->Estudiante->query("SELECT * FROM estudiantes LIMIT 2;");
Almacenamiento de información:
Save(data):
Para guardar información en la base de datos, debemos llamar a la función sabe de nuestro
modelo y esta función recibe como parámetro un array con los datos a almacenar.
Array
(
[NombreTabla] => Array
(
[nombrecampo1] => 'valor'
[nombrecampo2] => 'valor'
)
)
Pero si estamos enviamos es datos de un formulario, desde una página web, esto no nos debe
preocupar, pues con el simple hecho de llamar a la variable data ($this->data), tendremos todos
los datos del formulario ya ingresados en un vector.
Eliminación de Información:
Del(id):
Esta función se encarga de eliminar aquel registro cuyo campo id concuerde con el parámetro
recibido
CakePhp Sql
this->Estudiante->del(3) Delete from estudiantes where id=3
Para obtener más información sobre métodos de eliminación de datos, pueden consultar la
documentación oficial
Controladores: Los controladores de la aplicación se localizan en la
carpeta app/Controller y respetando los convenio
explicados con anterioridad. Los controladores nos
permiten escribir código para interactuar con la
base de datos (mediante los Modelos) y la interfaz
gráfica de nuestra aplicación (View). Cada
controlador tiene en su interior función que
representan una acción, cada acción tiene asociado
una vista, todo esto será explicado de mejor
manera en las siguientes secciones.
Para crear los controladores en la aplicación,
debemos crear un nuevo archivo en la carpeta
especificada cuyo nombre seguirá los lineamientos
de CakePhp y terminara en .php. Para ejemplificar crearemos un modelo de la tabla estudiantes.
Dentro del documento, se crear una clase del mismo nombre del archivo que hereda de la clase
AppController.
Pasar datos a la vista:
Set(nombre,valor):
Para pasar datos a la vista, lo que debemos hacer es llamar al método set y pasarle dos
parametros, el primero será el nombre con el cual podrá ser accedió los datos desde la vista, y el
segundo, son los datos que recibirá la vista
$this->set("estudiantes",$estudiantes);
Vistas: Las vistas de la aplicación se localizan en la carpeta app/View/nombreControlador/acción.ctp. Las
vistas son aquellas que nos permite generar código HTML basado en los datos recibido del
controlador.
En la imagen anterior se puede apreciar las vistas del controlador HistoriasController, dicho
controlador tiene en su interior 4 acciones, las cuales son: index, index2, today e history.
Desarrollo de una Aplicación:
Base de datos En esa sección se desarrollara una aplicación para inscribir alumnos a unos grupos específicos. La
aplicación cuenta con la siguiente base de datos.
Modelos:
Ahora crearemos 3 modelos para realizar este
ejemplo. Los modelos serán:
Estudiante.php
EstudiantesGrupo.php
Grupo.php
Controladores: Ahora crearemos 3 controladores para realizar
este ejemplo. Los Controladores serán:
EstudiantesController.php
EstudiantesGruposController.php
GruposController.php
Vistas: Para las vistas, crearemos tres carpetas dentro
de la carpeta View, el nombre de cada carpeta
debe ser el mismo del controlador, sin la
terminación Controller, para este ejemplo
quedaría así:
Estudiantes
EstudiantesGrupos
Grupos.
Controladores de la Aplicación
EstudiantesController: En este controlador nos encargaremos de realizar las 4 acciones básicas:
Listar Estudiantes
Agregar Estudiantes
Editar estudiantes
Eliminar Estudiante
Para poder realizar todas estas acciones, crearemos cuatro funciones en el controlador, cada
función (acción) realizara una tarea específica
Función Acción Descripción
index Listar Estudiante Esta función se encargara de listar todos los estudiantes registrador en la base de datos, así como proveer links para acceder a las demás acciones del controlador (actualizar, editar, eliminar)
add Agregar Estudiante Esta función se encargara de agregar un nuevo estudiante a la base de datos
edit Editar Estudiante Esta función se encargara de editar un estudiante dado, para actualizar sus datos en la base de datos
remove Eliminar Estudiante Esta función se encargara de eliminar un estudiante dado, de tal manera que se elimine su registro de la base de datos
Index:
Como se describía con anterioridad,
aquí listaremos los estudiante que ya
se encuentra en la base de datos,
para eso crearemos una función en el
controlador llamada index. Esta
función no recibe parámetro alguno.
Para poder listar los estudiantes, debemos realizar una consulta a la base de datos, por lo general,
lo que haríamos, sería establecer un código sql, que luego ejecutaríamos y recorreríamos, para
luego poderlo “pintar”. El código sql que crearíamos sería algo como:
select * from estudiantes
Pero gracias a las facilidades (y siguiendo las convenciones de CakePhp) no debemos realizar todo
ese trabajo completo; lo único que debemos hace es lo siguiente:
$this->Estudiante->find("all");
Ahora lo que debemos hacer, es pasar toda esa información a la vista.
$this->set("estudiantes",$this->Estudiante->find("all"));
Quedando la función de la siguiente manera
Add:
Esta función se encargara de recibir datos de un estudiante desde un formulario web e insertarlo
en la base de dato. Para poder realizar esto, la función verificara si se están enviando datos desde
un formulario web, si esto es correcto, intentara almacenar los datos en la base de datos y
mostrara un mensaje de confirmación, en caso contrario, mostrara un mensaje de error.
Para obtener todos los datos de un formulario se usa el atributo data de la clase
$this->data
Para almacenar los datos en la base de datos, se usa la función “save” del modelo, pasando los
datos del formulario.
$this->Estudiante->save($this->data)
Para mostrar un mensaje en la vista, usamos la función SetFlash de la sesión.
$this->Session->setFlash('Estudiante almacenado con exito.',
'default', array(), 'good');
Quedando la función de la siguiente manera
Edit:
Esta función se encargara, que dado un id de un estudiante (recibido como parámetro), buscara su
información y la mostrara en un formulario web para que el estudiante la pueda modificar. Al
momento del cliente enviar el formulario, la información se enviara a la base de datos para
actualizar el registro. Al finalizar, se le mostrara un mensaje al usuario notificando el resultado de
la operación.
Al igual que en la acción anterior (add), se verifica si se están enviando datos desde la vista (primer
condicional).
$this->Estudiante->id = $id;
Se actualiza el id en el modelo, con el fin de indicarle cual fila se va a actualizar.
$this->Estudiante->save($this->data)
Actualiza todos los campos que le llegaron del formulario
Remove:
Esta función recibirá un parámetro, el cual es el id del estudiante a eliminar. Al finalizar, se le
mostrara un mensaje al usuario notificando el resultado de la operación.
$this->Estudiante->delete($id)
En este caso se isa la función delete del modelo para poder eliminar un registro de la base de
datos, el registro a eliminar será aquel cuyo id sea igual al recibido como parámetro.