Manual clasa a x-a fizica . Electricitate, Termodinamica
Descripción completa
Geometrie si trigonometrie clasa XFull description
Manual X lite
Descripción: Memoria de calculo alcantarilla tipo marco método aashto lrfd
Descripción: Número 3 de la revista Ocho x Ocho
Noten Singen macht SpassFull description
russian squat cycle
base zincromato , detalleDescripción completa
Descrição completa
Manual compreloDescripción completa
Manual de Servicio de Digitalizador Agfa CR30XDescripción completa
manual de despiece de la moto kawasaki kmx 125Descripción completa
Manual CakePHP Ver. 1.3.x
Fuente: http://book.cakephp.org Compilador por: Ing. Luis Diaz
Agosto de 2010
Índice de contenido Manual CakePHP.......................................................................................................................................1 1 Comenzando con CakePHP..............................................................................................................18 1.1 ¿Qué es CakePHP y por qué hay que utilizarlo?......................................................................18 1.2 Dónde obtener ayuda................................................................................................................19 1.3 Entendiendo Modelo-Vista-Controlador..................................................................................21 2 Principios básicos de CakePHP........................................................................................................23 2.1 Estructura de CakePHP.............................................................................................................23 2.1.1 Extensiones de los Controladores ("Componentes")........................................................23 2.1.2 Extensiones de las Vistas..................................................................................................24 2.1.3 Extensiones de los Modelos..............................................................................................24 2.1.4 Extensiones de la Aplicación............................................................................................25 2.2 Una petición típica de CakePHP...............................................................................................25 2.3 Estructura de archivos de CakePHP.........................................................................................28 2.4 Convenciones de CakePHP .....................................................................................................30 2.4.1 Convenciones de los nombres de archivos y clases..........................................................30 2.4.2 Convenciones de Modelo y de la Base de datos...............................................................30 2.4.3 Convenciones de Controladores.......................................................................................31 2.4.3.1 Consideraciones de URL para nombres de controladores.........................................32 2.4.4 Convenciones de Vistas....................................................................................................33 3 Desarrollando con CakePHP............................................................................................................34 3.1 Requerimientos.........................................................................................................................34 3.2 Preparándose para Instalar........................................................................................................34 3.2.1 Obteniendo CakePHP.......................................................................................................35 3.2.2 Permisos............................................................................................................................35 3.3 Instalación.................................................................................................................................35 3.3.1 Desarrollo..........................................................................................................................36 3.3.2 Producción........................................................................................................................36 3.3.3 Instalación Avanzada.........................................................................................................37 3.3.3.1 Rutas de Clase Adicionales.......................................................................................38 3.3.4 Apache y mod_rewrite (y .htaccess).................................................................................39 3.3.5 Lighttpd y mod_magne.....................................................................................................41 3.3.6 Pretty URLs en nginx........................................................................................................42 3.3.7 URL Rewrites on IIS7 (Windows hosts)...........................................................................43 3.3.8 Enciéndelo.........................................................................................................................44 3.4 Configuración...........................................................................................................................45 3.4.1 Configuración de Base de Datos.......................................................................................45 3.4.2 Configuración del Core.....................................................................................................46 3.4.3 La Clase de Configuración................................................................................................46 3.4.3.1 Métodos de la Clase Configure.................................................................................47 3.4.3.1.1 write...................................................................................................................47 3.4.3.1.2 read....................................................................................................................47 3.4.3.1.3 delete..................................................................................................................48 3.4.3.1.4 load....................................................................................................................48 3.4.3.1.5 version...............................................................................................................48 3.4.3.2 Variables de Configuración Principales de CakePHP...............................................48 3.4.3.3 Constantes de Configuración....................................................................................50
3.4.4 La Clase App.....................................................................................................................50 3.4.4.1 Usando App::import()...............................................................................................50 3.4.4.2 Importando librerías del Core...................................................................................50 3.4.4.3 Importando Controladores, Modelos, Ayudantes, Comportamientos y Componentes ...............................................................................................................................................51 3.4.4.3.2 Cargando Modelos [Model]...............................................................................51 3.4.4.3.3 Cargando Componentes [Components].............................................................51 3.4.4.3.4 Cargando Comportamientos [Behaviors]..........................................................51 3.4.4.3.5 Cargando Ayudantes[Helpers]...........................................................................51 3.4.4.4 Cargando desde Plugins............................................................................................51 3.4.4.5 Cargando Archivos de Terceros.................................................................................52 3.4.4.5.1 Ejemplos de archivos de terceros......................................................................52 3.4.5 Configuración de Rutas.....................................................................................................52 Enrutamiento por Defecto.....................................................................................................52 Parámetros con Nombre.............................................................................................................53 Definir Rutas..............................................................................................................................53 Pasando parámetros a la acción.................................................................................................56 Rutas con prefijos......................................................................................................................57 3.4.5.1 Enrutamiento por defecto..........................................................................................58 3.4.5.2 Passed arguments......................................................................................................58 3.4.5.4 Defining Routes.........................................................................................................59 3.4.5.5 Pasando parámetros a las acciones............................................................................62 3.4.5.6 Prefix Routing...........................................................................................................62 3.4.5.7 Rutas y plugins..........................................................................................................63 3.4.5.8 Extensiones de archivo..............................................................................................64 3.4.5.9 Custom Route classes................................................................................................64 3.4.6 Inflexiones Propias............................................................................................................65 3.4.7 Haciendo Bootstrap de CakePHP.....................................................................................66 3.5 Controladores............................................................................................................................67 3.5.1 The App Controller...........................................................................................................68 3.5.2 The Pages Controller.........................................................................................................68 3.5.3 Atributos del Controlador.................................................................................................69 3.5.3.1 $name........................................................................................................................69 3.5.3.2 $components, $helpers y $uses.................................................................................69 3.5.3.3 Atributos Relacionados con la Página: "$layout" y "$pageTitle".............................70 3.5.3.4 El Atributo de Parámetros ("$params").....................................................................71 3.5.3.4.1 form...................................................................................................................71 3.5.3.4.2 admin.................................................................................................................71 3.5.3.4.4 isAjax.................................................................................................................71 3.5.3.4.5 controller............................................................................................................72 3.5.3.4.6 action.................................................................................................................72 3.5.3.4.7 pass....................................................................................................................72 3.5.3.4.8 url ......................................................................................................................72 3.5.3.4.9 data....................................................................................................................72 3.5.3.4.10 prefix................................................................................................................73 3.5.3.4.11 named...............................................................................................................73 3.5.3.5 Otros Atributos..........................................................................................................73 3.5.3.6 persistModel..............................................................................................................74 3.5.4 Métodos del Controlador..................................................................................................75
3.5.4.1 Interactuando con Vistas...........................................................................................75 3.5.4.1.1 set.......................................................................................................................75 3.5.4.1.2 render.................................................................................................................75 3.5.4.2 Control de Flujo........................................................................................................76 3.5.4.2.1 redirect...............................................................................................................76 3.5.4.2.2 flash...................................................................................................................77 3.5.4.3 Retrollamadas ("Callbacks").....................................................................................77 3.5.4.4 Otros Métodos Útiles................................................................................................78 3.5.4.4.1 constructClasses................................................................................................78 3.5.4.4.2 referer................................................................................................................79 3.5.4.4.3 disableCache......................................................................................................79 3.5.4.4.4 postConditions...................................................................................................79 3.5.4.4.5 paginate..............................................................................................................80 3.5.4.4.6 requestAction.....................................................................................................80 3.5.4.4.7 loadModel..........................................................................................................82 3.6 Componentes............................................................................................................................83 3.6.1 Configuración de componentes.........................................................................................83 3.6.2 Creando Componentes a medida......................................................................................84 3.6.2.1 Añadiendo Componentes a tus Controladores..........................................................84 3.6.2.2 Acceso a clases MVC dentro de componentes..........................................................85 3.6.2.3 Usando Componentes en tu Componente.................................................................86 3.7 Modelos....................................................................................................................................88 3.7.1 La Comprensión de Modelos............................................................................................88 3.7.2 Creando Tablas de Bases de Datos...................................................................................90 3.7.2.1 Asociaciones de Tipo de Dato por Base de Datos.....................................................91 3.7.2.1.1 MySQL..............................................................................................................91 3.7.2.1.2 MySQLi.............................................................................................................91 3.7.2.1.3 ADOdb...............................................................................................................92 3.7.2.1.4 DB2....................................................................................................................92 3.7.2.1.5 Firebird/Interbase..............................................................................................92 3.7.2.1.6 MS SQL.............................................................................................................93 3.7.2.1.7 Oracle................................................................................................................93 3.7.2.1.8 PostgreSQL........................................................................................................94 3.7.2.1.9 SQLite................................................................................................................94 3.7.2.1.10 Sybase..............................................................................................................94 3.7.2.2 Titulos........................................................................................................................95 3.7.2.3 Creado y modificado ("created" y "modified").........................................................95 3.7.2.4 Utilizando UUIDs como Claves Primarias...............................................................95 3.7.3 Recuperando tus Datos.....................................................................................................96 3.7.3.1 find............................................................................................................................96 3.7.3.1.1 find('first')..........................................................................................................97 3.7.3.1.2 find('count')........................................................................................................98 3.7.3.1.3 find('all').............................................................................................................98 3.7.3.1.4 find('list')............................................................................................................99 3.7.3.1.5 find('threaded').................................................................................................101 3.7.3.1.6 find('neighbors')...............................................................................................103 3.7.3.2 findAllBy.................................................................................................................104 3.7.3.3 findBy......................................................................................................................104 3.7.3.4 query........................................................................................................................105
3.7.3.5 field..........................................................................................................................106 3.7.3.6 read().......................................................................................................................106 3.7.3.7 Condiciones Complejas de Búsqueda.....................................................................107 3.7.4 Guardando Tus Datos......................................................................................................110 3.7.4.1 Guardando Datos de Modelos Relacionados (hasOne, hasMany, belongsTo)........114 3.7.4.1.1 counterCache - Cache your count().................................................................116 3.7.4.2 Guardando Datos de Modelos Relacionados (HABTM)........................................117 3.7.5 Borrando Datos...............................................................................................................118 3.7.5.1 del............................................................................................................................118 3.7.5.2 deleteAll..................................................................................................................118 3.7.6 Asociaciones: Enlazando Modelos..................................................................................118 3.7.6.1 Tipos de Relaciones.................................................................................................119 3.7.6.2 hasOne.....................................................................................................................120 3.7.6.3 belongsTo................................................................................................................122 3.7.6.4 hasMany..................................................................................................................124 3.7.6.5 hasAndBelongsToMany (HABTM)........................................................................126 3.7.6.6 Creando y Destruyendo Asociaciones al Vuelo......................................................132 3.7.6.7 Múltiples relaciones al mismo modelo....................................................................134 3.7.6.8 Joining tables...........................................................................................................135 3.7.7 Métodos Callback...........................................................................................................137 3.7.7.1 beforeFind...............................................................................................................137 3.7.7.2 afterFind..................................................................................................................137 3.7.7.3 beforeValidate..........................................................................................................138 3.7.7.4 beforeSave...............................................................................................................139 3.7.7.5 afterSave..................................................................................................................139 3.7.7.6 beforeDelete............................................................................................................140 3.7.7.7 afterDelete...............................................................................................................140 3.7.7.8 onError....................................................................................................................140 3.7.8 Atributos del Modelo......................................................................................................140 3.7.8.1 useDbConfig............................................................................................................140 3.7.8.2 useTable...................................................................................................................141 3.7.8.3 tablePrefix...............................................................................................................141 3.7.8.4 primaryKey..............................................................................................................142 3.7.8.5 displayField.............................................................................................................142 3.7.8.6 recursive..................................................................................................................142 3.7.8.7 order........................................................................................................................143 3.7.8.8 data..........................................................................................................................143 3.7.8.9 _schema...................................................................................................................143 3.7.8.10 validate..................................................................................................................144 3.7.8.11 virtualFields...........................................................................................................144 3.7.8.12 name......................................................................................................................144 3.7.8.13 cacheQueries.........................................................................................................144 3.7.9 Métodos Personalizados y Propiedades..........................................................................145 3.7.9.1 Using virtualFields..................................................................................................145 3.7.10 Virtual fields..................................................................................................................147 3.7.10.1 Creating virtual fields............................................................................................147 3.7.10.2 Using virtual fields................................................................................................148 3.7.10.3 Virtual fields and model aliases.............................................................................149 3.7.10.4 Limitations of virtualFields...................................................................................149
3.7.11 Transactions..................................................................................................................150 3.8 Comportamientos....................................................................................................................150 3.8.1 Utilizando Comportamientos..........................................................................................151 3.8.2 Creando Comportamientos Personalizados....................................................................153 3.8.3 Creating behavior methods.............................................................................................153 3.8.4 Behavior callbacks..........................................................................................................154 3.8.5 Creating a behavior callback...........................................................................................154 3.9 DataSources (fuentes de datos)...............................................................................................155 3.9.1 API básica para DataSources..........................................................................................156 3.9.2 Un ejemplo......................................................................................................................157 3.10 Vistas.....................................................................................................................................160 3.10.1 Plantillas de la Vista......................................................................................................160 3.10.2 Layouts..........................................................................................................................160 3.10.3 Elementos......................................................................................................................163 3.10.3.1 Pasar Variables a un elemento...............................................................................163 3.10.3.2 Cache de Elements................................................................................................165 3.10.3.3 Utilizar Elements de un Plugin..............................................................................165 3.10.4 Métodos de la vista.......................................................................................................165 3.10.4.1 set()........................................................................................................................166 3.10.4.2 getVar()..................................................................................................................166 3.10.4.3 getVars()................................................................................................................166 3.10.4.4 error()....................................................................................................................166 3.10.4.5 element()................................................................................................................166 3.10.4.6 uuid........................................................................................................................167 3.10.4.7 addScript().............................................................................................................167 3.10.5 Temas............................................................................................................................167 3.10.5.1 Increasing performance of plugin and theme assets..............................................168 3.10.6 Vistas de Medios...........................................................................................................169 3.11 Helpers..................................................................................................................................170 3.11.1 Usando Helpers.............................................................................................................170 3.11.2 Creando Helpers............................................................................................................170 3.11.2.1 Including other Helpers.........................................................................................171 3.11.2.2 Callback method....................................................................................................172 3.11.2.3 Usando tu Helper...................................................................................................172 3.11.3 Creando Funcionalidad para todos los Helpers.............................................................172 3.11.4 Helpers del Core............................................................................................................173 3.12 Scaffolding............................................................................................................................174 3.12.1 Creating a simple admin interface with scaffolding.....................................................175 3.12.2 Personalizando Vistas Scaffold ....................................................................................176 3.13 La consola de CakePHP........................................................................................................177 3.13.1 Creando Shells y Tasks.................................................................................................178 3.13.1.1 Creando tus Propios Shells....................................................................................178 3.13.1.2 Tasks (Tareas)........................................................................................................180 3.13.2 Running Shells as cronjobs...........................................................................................181 3.14 Plugins..................................................................................................................................182 3.14.1 Crear un Plugin.............................................................................................................183 3.14.2 Controladores del Plugin...............................................................................................183 3.14.3 Modelos del Plugin.......................................................................................................184 3.14.4 Vistas del Plugin............................................................................................................185
4.1.4.13 ip............................................................................................................................205 4.1.4.14 isUnique................................................................................................................205 4.1.4.15 minLength.............................................................................................................206 4.1.4.16 maxLength.............................................................................................................206 4.1.4.17 money....................................................................................................................206 4.1.4.18 multiple..................................................................................................................207 4.1.4.19 inList......................................................................................................................207 4.1.4.20 numeric..................................................................................................................207 4.1.4.21 notEmpty...............................................................................................................208 4.1.4.22 phone.....................................................................................................................208 4.1.4.23 postal.....................................................................................................................208 4.1.4.24 range......................................................................................................................209 4.1.4.25 ssn..........................................................................................................................209 4.1.4.26 url..........................................................................................................................209 4.1.5 Reglas de Validación Personalizadas..............................................................................210 4.1.5.1 Validación Personalizada Mediante Expresiones Relugares...................................210 4.1.5.2 Validación Mediante Métodos Personalizados........................................................210 4.1.6 Validando datos desde el Controlador.............................................................................211 4.2 Limpieza de Datos..................................................................................................................212 4.2.1 paranoid...........................................................................................................................212 4.2.2 html.................................................................................................................................212 4.2.3 escape..............................................................................................................................213 4.2.4 clean................................................................................................................................213 4.3 Manejo de Errores...................................................................................................................214 4.4 Depuración..............................................................................................................................215 4.4.1 Depuración básica...........................................................................................................215 4.4.2 Usando la clase Debugger...............................................................................................216 4.4.3 Clase Debugger...............................................................................................................218 4.5 Caching...................................................................................................................................219 4.6 Logging...................................................................................................................................219 4.6.1 Uso de la función log......................................................................................................219 4.6.2 Using the default FileLog class.......................................................................................220 4.6.3 Creating and configuring log streams.............................................................................221 4.6.4 Interacting with log streams............................................................................................222 4.6.5 Error logging...................................................................................................................222 4.7 Testing.....................................................................................................................................222 4.7.1 Preparándose para el testing............................................................................................222 4.7.1.1 Installing SimpleTest...............................................................................................223 4.7.1.2 Ejecutando los test-cases incorporados...................................................................223 4.7.2 Introducción a los test - Unit testing vs. Web testing......................................................224 4.7.3 Preparando datos de prueba............................................................................................224 4.7.3.1 Acerca de las fixtures..............................................................................................224 4.7.3.2 Creando fixtures......................................................................................................224 4.7.3.3 Importar información de tabla y registros...............................................................226 4.7.4 Creando los tests.............................................................................................................228 4.7.4.1 CakeTestCase Callback Methods............................................................................229 4.7.5 Testing models................................................................................................................229 4.7.5.1 Creating a test case..................................................................................................229 4.7.5.2 Creating a test method.............................................................................................231
4.7.6 Testing controllers...........................................................................................................231 4.7.6.1 Creando un test case................................................................................................231 4.7.6.2 El método testAction...............................................................................................233 4.7.6.3 Pitfalls......................................................................................................................234 4.7.7 Testing Helpers...............................................................................................................234 4.7.7.1 Creating Helper test, part I......................................................................................234 4.7.8 Probando componentes...................................................................................................235 4.7.8.1 Initializing the component.......................................................................................236 4.7.8.2 Creando un método de prueba.................................................................................236 4.7.9 Web testing - Testeando las vistas...................................................................................237 4.7.9.1 About CakeWebTestCase........................................................................................237 4.7.9.2 Creando un test........................................................................................................237 4.7.9.3 Walking through a page...........................................................................................238 4.7.10 Testing plugins..............................................................................................................239 4.7.11 Miscellaneous................................................................................................................240 4.7.11.1 Customizing the test reporter................................................................................240 4.7.11.2 Test Reporter methods...........................................................................................240 4.7.11.3 Grouping tests........................................................................................................241 4.7.12 Running tests in the Command Line.............................................................................242 4.7.13 Test Suite changes in 1.3...............................................................................................243 4.8 Internacionalización & Localización......................................................................................245 4.8.1 Internacionalizando su aplicación...................................................................................245 4.8.2 Localización en CakePHP...............................................................................................246 4.9 Paginación...............................................................................................................................248 4.9.1 Preparación del controlador............................................................................................248 4.9.2 Pagination in Views........................................................................................................250 4.9.3 Paginación AJAX............................................................................................................251 # Configuring the PaginatorHelper to use a custom helper................................................252 4.9.4 Custom Query Pagination...............................................................................................252 4.10 REST....................................................................................................................................253 4.10.1 The Simple Setup..........................................................................................................254 4.10.2 Custom REST Routing..................................................................................................256 5 Componentes del Núcleo................................................................................................................257 5.1 Listas de Control de Acceso...................................................................................................257 5.1.1 Entendiendo cómo funciona ACL...................................................................................258 5.1.2 Definiendo Permisos: ACL basado en INI......................................................................263 5.1.3 Definiendo Permisos: ACL en la base de datos..............................................................265 5.1.3.1 Comenzando............................................................................................................265 5.1.3.2 Creando Access Request Objects (AROs) y Access Control Objects (ACOs).......266 5.1.3.3 Asignando Permisos................................................................................................272 5.1.3.4 Verificando Permisos: El Componente ACL...........................................................274 5.2 Autenticación..........................................................................................................................275 5.2.1 Configurando las variables del componente Auth..........................................................277 5.2.2 Mostrando Mensajes de Error en la Autenticación.........................................................278 5.2.3 Problemas comunes con Auth.........................................................................................278 5.2.4 Cambiar la Función Hash................................................................................................279 5.2.5 Métodos de AuthComponent..........................................................................................280 5.2.5.1 action.......................................................................................................................280 5.2.5.2 allow........................................................................................................................280
5.2.5.3 deny.........................................................................................................................281 5.2.5.4 hashPasswords.........................................................................................................281 5.2.5.5 mapActions..............................................................................................................282 5.2.5.6 login.........................................................................................................................282 5.2.5.7 logout.......................................................................................................................283 5.2.5.8 password..................................................................................................................283 5.2.5.9 user..........................................................................................................................284 5.2.6 Atributos de AuthComponent.........................................................................................285 5.2.6.1 userModel................................................................................................................285 5.2.6.2 fields........................................................................................................................285 5.2.6.3 userScope................................................................................................................285 5.2.6.4 loginAction..............................................................................................................285 5.2.6.5 loginRedirect...........................................................................................................286 5.2.6.6 logoutRedirect.........................................................................................................286 5.2.6.7 loginError................................................................................................................286 5.2.6.8 authError..................................................................................................................286 5.2.6.9 autoRedirect............................................................................................................287 5.2.6.10 authorize................................................................................................................288 5.2.6.11 sessionKey.............................................................................................................290 5.2.6.12 ajaxLogin...............................................................................................................290 5.2.6.13 authenticate............................................................................................................290 5.2.6.14 actionPath..............................................................................................................290 5.2.6.15 flashElement..........................................................................................................290 5.3 Cookies...................................................................................................................................291 5.3.1 Configuración del Controlador.......................................................................................291 5.3.2 Utilizando el Componente..............................................................................................292 5.4 Email.......................................................................................................................................294 5.4.1 Atributos y Variables de la clase.....................................................................................294 5.4.1.1 Envío múltiple de emails en bucle..........................................................................295 5.4.1.2 Debugging Emails...................................................................................................295 5.4.2 Envío de un mensaje simple...........................................................................................295 5.4.2.1 Configurando el Layout..........................................................................................295 5.4.2.2 Configurar un elemento Email para el cuerpo del mensaje....................................296 5.4.2.3 Controlador..............................................................................................................297 5.4.2.4 Attachments.............................................................................................................298 5.4.3 Enviar un mail por SMTP...............................................................................................298 5.5 Request Handling....................................................................................................................299 5.5.1 Obtaining Request Information.......................................................................................299 5.5.2 Request Type Detection..................................................................................................301 5.5.3 Obtaining Additional Client Information........................................................................302 5.5.4 Responding To Requests.................................................................................................302 5.6 El Componente Security.........................................................................................................304 5.6.1 Configuración.................................................................................................................304 5.6.2 Métodos...........................................................................................................................306 5.6.2.1 requirePost()............................................................................................................306 5.6.2.2 requireSecure()........................................................................................................306 5.6.2.3 requireAuth()...........................................................................................................306 5.6.2.4 requireLogin().........................................................................................................306 5.6.2.5 loginCredentials(string $type).................................................................................306
5.6.2.6 loginRequest(array $options)..................................................................................306 5.6.2.7 parseDigestAuthData(string $digest)......................................................................307 5.6.2.8 generateDigestResponseHash(array $data).............................................................307 5.6.2.9 blackHole(object $controller, string $error)............................................................307 5.6.3 Uso..................................................................................................................................307 5.6.4 Basic HTTP Authentication............................................................................................308 5.7 Sesiones..................................................................................................................................309 5.7.1 Métodos...........................................................................................................................310 5.7.1.1 write.........................................................................................................................310 5.7.1.2 setFlash....................................................................................................................310 5.7.1.3 read..........................................................................................................................311 5.7.1.4 check........................................................................................................................311 5.7.1.5 delete.......................................................................................................................311 5.7.1.6 destroy.....................................................................................................................312 5.7.1.7 error.........................................................................................................................312 6 Core Behaviors (Comportamientos Basicos).................................................................................313 6.1 ACL........................................................................................................................................313 6.1.1 Using the AclBehavior....................................................................................................313 6.1.2 node()..............................................................................................................................315 6.2 Containable.............................................................................................................................315 # Using Containable.................................................................................................................316 # Containing deeper associations.............................................................................................318 6.2.1 Using Containable with pagination.................................................................................320 # ContainableBehavior options................................................................................................321 6.3 Translate..................................................................................................................................322 6.3.1 Inicializando las tablas de la Base de datos i18n............................................................322 6.3.2 Adjuntando el Comportamiento de Traducción a tus Modelos.......................................322 6.3.3 Definiendo los Campos...................................................................................................323 6.3.4 Conclusiones...................................................................................................................323 6.3.5 Obtener todos los registros de traducción para un campo determinado.........................324 6.3.5.1 Using the bindTranslation method..........................................................................325 6.3.6 Saving in another language.............................................................................................326 6.3.7 Multiple Translation Tables............................................................................................327 6.3.7.1 Create the TranslateModel......................................................................................328 6.3.7.2 Changing the Table..................................................................................................328 6.4 Arboles (Tree).........................................................................................................................329 6.4.1 Requerimientos...............................................................................................................329 6.4.2 Uso Básico......................................................................................................................329 6.4.2.1 Agregando datos......................................................................................................331 6.4.2.2 Modificando datos...................................................................................................332 6.4.2.3 Borrando datos........................................................................................................333 6.4.2.4 Haciendo consultas y usando tus datos...................................................................334 6.4.2.4.1 El método children..........................................................................................334 6.4.2.4.2 Contando los hijos...........................................................................................335 6.4.2.4.3 generatetreelist.................................................................................................335 6.4.2.4.4 getparentnode..................................................................................................336 6.4.2.4.5 getpath.............................................................................................................336 6.4.3 Uso Avanzado.................................................................................................................337 6.4.3.1 moveDown..............................................................................................................337
6.4.3.2 moveUp...................................................................................................................338 6.4.3.3 removeFromTree.....................................................................................................339 6.4.3.4 reorder.....................................................................................................................340 6.4.4 Data Integrity..................................................................................................................340 6.4.4.1 Recover....................................................................................................................340 6.4.4.2 Reorder....................................................................................................................341 6.4.4.3 Verify.......................................................................................................................342 7 Ayudantes del Core.........................................................................................................................343 7.1 AJAX......................................................................................................................................343 7.1.1 AjaxHelper Options........................................................................................................344 7.1.1.1 General Options.......................................................................................................344 7.1.1.2 Opciones de retrollamadas (Callback Options).......................................................344 7.1.2 Métodos...........................................................................................................................345 7.1.2.1 link...........................................................................................................................345 7.1.2.2 remoteFunction........................................................................................................347 7.1.2.3 remoteTimer............................................................................................................348 7.1.2.4 form.........................................................................................................................348 7.1.2.5 submit......................................................................................................................349 7.1.2.6 observeField............................................................................................................350 7.1.2.7 observeForm............................................................................................................350 7.1.2.8 autoComplete..........................................................................................................351 7.1.2.9 isAjax......................................................................................................................352 7.1.2.10 drag & drop...........................................................................................................352 7.1.2.11 slider......................................................................................................................353 7.1.2.12 editor......................................................................................................................354 7.1.2.13 sortable..................................................................................................................355 7.2 Cache......................................................................................................................................356 7.2.1 Generalidades en Caching...............................................................................................356 7.2.2 Motores de Cache en Cake.............................................................................................356 7.2.3 Configuracion del Cache Helper.....................................................................................357 7.2.4 Caching en los Controllers..............................................................................................357 7.2.5 Marking Non-Cached Content in Views.........................................................................358 7.2.6 Clearing the Cache..........................................................................................................359 7.3 Formularios.............................................................................................................................359 7.3.1 Creando Formularios......................................................................................................359 7.3.1.1 $options[‘type’].......................................................................................................361 7.3.1.2 $options[‘action’]....................................................................................................361 7.3.1.3 $options[‘url’].........................................................................................................362 7.3.1.4 $options[‘default’]...................................................................................................362 7.3.1.5 7.3.1.5 $options['inputDefaults'].............................................................................362 7.3.2 Closing the Form.............................................................................................................363 7.3.3 Automagic Form Elementos...........................................................................................363 7.3.3.1 Field naming convention.........................................................................................365 7.3.3.2 $options[‘type’].......................................................................................................366 7.3.3.3 $options[‘before’], $options[‘between’], $options[‘separator’] and $options[‘after’] .............................................................................................................................................366 7.3.3.4 $options[‘options’]..................................................................................................367 7.3.3.5 $options[‘multiple’]................................................................................................369 7.3.3.6 $options[‘maxLength’]............................................................................................369
8.8.1 get....................................................................................................................................481 8.8.2 post..................................................................................................................................481 8.8.3 request.............................................................................................................................481 9 Aplicaciones de Consola Principales..............................................................................................483 9.1 Generación de Código con Bake............................................................................................483 9.1.1 Bake improvements in 1.3..............................................................................................484 9.2 Gestión del Esquema de la BBDD y Migraciones..................................................................487 9.2.1 Generando y Usando Archivos de Esquemas.................................................................487 9.2.2 Migrations with CakePHP schema shell.........................................................................488 9.3 Modificando el HTML producido por defecto del script bake...............................................489 10 Deployment..................................................................................................................................489 11 Ejemplo de Aplicación.................................................................................................................490 11.1 Blog.......................................................................................................................................490 11.1.1 Obteniendo Cake...........................................................................................................491 11.1.2 Creando la Base de Datos del Blog...............................................................................491 11.1.3 Configuración de la Base de Datos en Cake.................................................................492 11.1.4 Configuración Opcional................................................................................................493 11.1.5 Una aclaración para mod_rewrite.................................................................................494 11.1.6 Crear un modelo Post....................................................................................................495 11.1.7 Crear un controlador para Post......................................................................................496 11.1.8 Creando las Vistas(Views) de los Post .........................................................................497 11.1.9 Agregando Posts............................................................................................................501 11.1.10 Validación de Datos.....................................................................................................502 11.1.11 Borrando Posts............................................................................................................504 11.1.12 Editando Posts.............................................................................................................505 11.1.13 Rutas............................................................................................................................507 11.1.14 Conclusión..................................................................................................................508 11.2 Simple Acl controlled Application........................................................................................509 11.2.1 Preparando nuestra aplicación.......................................................................................509 11.2.2 Preparándose para agregar Autentificación (Auth).......................................................511 11.2.3 Inicializar las tablas Acl en la BD.................................................................................512 11.2.4 Act as a Requester (Solicitante)....................................................................................513 11.2.4.1 11.2.4.1 Group-only ACL......................................................................................515 11.2.5 Creando ACOs..............................................................................................................516 11.2.6 Una herramienta automática para crear ACOs..............................................................517 11.2.7 Configurando los permisos...........................................................................................521 11.2.8 Logueo de Usuarios......................................................................................................523 11.2.9 Logout (deslogueo).......................................................................................................523 11.2.10 Todo hecho..................................................................................................................524 12 Apendices.....................................................................................................................................525 12.1 Migrando desde CakePHP 1.2 a 1.3.....................................................................................525 # Removed Constants..............................................................................................................525 # Configuration and application bootstrapping........................................................................525 # File renames and internal changes........................................................................................527 12.1.1 Controller & Components.............................................................................................528 # Library Classes......................................................................................................................529 12.1.2 Model Databases and Datasources................................................................................533 # View and Helpers..................................................................................................................535 # Console and shells.................................................................................................................538
12.1.3 Vendors, Test Suite & schema.......................................................................................539 12.2 Nuevas características en CakePHP 1.3...............................................................................540 # Componentes.........................................................................................................................540 # View & Helpers.....................................................................................................................541 12.2.1 Logging.........................................................................................................................542 # Caching.................................................................................................................................542 # Models, Behaviors and Datasource.......................................................................................543 # Console.................................................................................................................................545 # Router and Dispatcher...........................................................................................................546 # Library classes......................................................................................................................546 # Miscellaneous.......................................................................................................................548
1 Comenzando con CakePHP ¡Bienvenido al Cookbook, el manual para el framework CakePHP que convierte el desarrollo de aplicaciones web en un juego de niños! Este manual supone que posees conocimientos generales de PHP y conocimientos básicos de programación orientada a objetos (POO). Las diferentes funciones del framework utilizan varias tecnologías -por ejemplo, SQL, JavaScript o XML—. El manual no pretende explicar dichas tecnologías, sino cómo se utilizan en este contexto.
1.1 ¿Qué es CakePHP y por qué hay que utilizarlo?
CakePHP es un marco de desarrollo [framework] rápido para PHP, libre, de código abierto. Se trata de una estructura que sirve de base a los programadores para que éstos puedan crear aplicaciones Web. Nuestro principal objetivo es que puedas trabajar de forma estructurada y rápida, sin pérdida de flexibilidad. Con CakePHP el desarrollo web ya no es monótono porque ofrecemos las herramientas para que empieces a escribir el código que realmente necesitas: la lógica específica de tu aplicación. Consigue una copia de CakePHP, empieza con lo verdaderamente importante y no reinventes la rueda cada vez que te incorpores a un nuevo proyecto. CakePHP tiene un equipo de desarrolladores y una comunidad activos, lo que añade valor al proyecto. Con CakePHP, además de no tener que reinventar la rueda, el núcleo de tu aplicación se mejora constantemente y está bien probado. Esta es una lista breve con las características de las que disfrutarás al utilizar CakePHP: • Comunidad activa y amistosa • Licencia flexible • Compatible con PHP4 y PHP5 • CRUD integrado para la interacción con la base de datos • Soporte de aplicación [scaffolding] • Generación de código
• Arquitectura Modelo Vista Controlador (MVC) • Despachador de peticiones [dispatcher], con URLs y rutas personalizadas y limpias • Validación integrada • Plantillas rápidas y flexibles (sintaxis de PHP, con ayudantes[helpers]) • Ayudantes para AJAX, Javascript, formularios HTML y más • Componentes de Email, Cookie, Seguridad, Sesión y Manejo de solicitudes • Listas de control de acceso flexibles • Limpieza de datos • Caché flexible • Localización • Funciona en cualquier subdirectorio del sitio web, con poca o ninguna configuración de Apache
1.2 Dónde obtener ayuda # El sitio oficial CakePHP - http://www.cakephp.org El sitio web oficial de CakePHP es siempre un gran lugar para visitar. Cuenta con enlaces a herramientas de desarrollo frecuentemente utilizadas, videos, oportunidades de donar, y descargas. # El Cookbook - http://book.cakephp.org Este manual (y la API) es probablemente el primer lugar al que tienes que dirigirte para obtener ayuda. Como ocurre con muchos otros proyectos de código abierto, tenemos gente nueva con regularidad, por lo que, para reducir nuestra carga de trabajo, intenta primero buscar respuestas por tí mismo. Las respuestas pueden demorarse, pero una vez obtenidas las recordarás durante mucho tiempo. Tanto el manual como la API tienen una versión en línea. # El Bakery - http://bakery.cakephp.org La Panadería de CakePHP (CakePHP Bakery) es un almacén de cosas relacionadas con CakePHP. Consúltalo si estás buscando tutoriales, casos de estudio o ejemplos de código. Cuando estés familiarizado con CakePHP, accede a él y comparte tus conocimientos con la comunidad.
# El API - http://api.cakephp.org/ Directo al grano y directamente de los desarrolladores de CakePHP, la API (Interfaz de Programación de Aplicaciones) CakePHP es la documentación más completa y directa que explica los detalles internos del funcionamiento del framework. Se trata de una guía de referencia de código concisa. # CakeForge - http://www.cakeforge.org CakeForge es otro recurso para desarrolladores que puedes utilizar para hospedar tus proyectos CakePHP para compartir con los demás. Si estás buscando (o quieres compartir) un componente interesante o un plugin recomendable, echa un vistazo a CakeForge. # Los Casos de Prueba - http://api.cakephp.org/tests Si crees que la información que proporciona la API no es suficiente, consulta el código de los casos de prueba que proporciona CakePHP 1.2. Estos te pueden servir de ejemplos prácticos para el uso de funciones y datos miembros de una clase. Para obtener casos de prueba necesitas bajar un paquete nightly o hacer un checkout de un branch de svn. Los casos de prueba se encuentran en: cake/tests/cases # El canal IRC • #cakephp -- Discusión General •
#cakephp-docs -- Documentación
•
#cakephp-bakery -- Bakery Si te quedas estancado en algún punto, consúltanos en el canal IRC de CakePHP. Generalmente,
algún miembro del equipo de desarrollo suele estar conectado, sobre todo durante las horas de luz solar de América del Norte y América del Sur. Nos gustaría mucho saber de tí: si necesitas ayuda, si deseas encontrar usuarios en tu área o si quieres donar tu flamante coche deportivo. • #cakephp-es -- Canal de la comunidad hispano-parlante # El Google Group Además, CakePHP tiene un grupo Google muy activo; un recurso excelente en que se encuentran respuestas archivadas, preguntas frecuentes, y donde también puedes obtener respuestas inmediatas a tus problemas.
http://groups.google.com/group/cake-php/ Si estás buscando un grupo Google en español, suscríbete al grupo de la comunidad hispanohablante. http://groups.google.com/group/cakephp-esp/
1.3 Entendiendo Modelo-Vista-Controlador Las aplicaciones CakePHP bien escritas siguen el patrón de diseño de software MVC (ModeloVista-Controlador). Programar utilizando MVC consiste en separar la aplicación en tres partes principales. El modelo representa los datos de la aplicación, la vista hace una presentación del modelo de datos, y el controlador maneja y enruta las peticiones [requests] hechas por los usuarios.
Figura 1: Una petición MVC básica La figura 1 muestra un ejemplo sencillo de una petición [request] MVC en CakePHP. A efectos ilustrativos, supongamos que un usuario llamado Ricardo acaba de hacer clic en el enlace "¡Comprar un pastel personalizado ahora!" de la página de inicial de la aplicación. 1. Ricardo hace clic en el enlace apuntando a http://www.ejemplo.com/pasteles/comprar, y su navegador hace una petición al servidor web. 2. El despachador comprueba la URL de la petición (/pasteles/comprar), y le pasa la petición al controlador adecuado. 3. El controlador realiza lógica de aplicación específica. Por ejemplo, puede comprobar si Ricardo ha iniciado sesión.
4. El controlador también utiliza modelos para acceder a los datos de la aplicación. La mayoría de las veces los modelos representan tablas de una base de datos, aunque también pueden representar entradas LDAP, canales RSS, o ficheros en el sistema. En este ejemplo, el controlador utiliza un modelo para buscar la última compra de Ricardo en la base de datos. 5. Una vez que el controlador ha hecho su magia en los datos, se los pasa a la vista. La vista toma los datos y los deja listos para su presentación al usuario. La mayoría de las veces las vistas en CakePHP vienen en formato HTML, pero una vista puede ser fácilmente un PDF, un documento XML, o un objeto JSON, dependiendo de tus necesidades. 6. Una vez que el objeto encargado de procesar vistas en CakePHP ha utilizado los datos del controlador para construir una vista completa, el contenido se devuelve al navegador de Ricardo. Casi todas las peticiones a tu aplicación seguirán este patrón básico. Más adelante, vamos a completar algunos detalles específicos de Cake, así que, por favor, ten esto en cuenta a medida que avanzamos. # Beneficios ¿Por qué utilizar MVC? Porque es un patrón de diseño de software probado y se sabe que funciona. Con MVC la aplicación se puede desarrollar rápidamente, de forma modular y mantenible. Separar las funciones de la aplicación en modelos, vistas y controladores hace que la aplicación sea muy ligera. Estas características nuevas se añaden fácilmente y las antiguas toman automáticamente una forma nueva. El diseño modular permite a los diseñadores y a los desarrolladores trabajar conjuntamente, así como realizar rápidamente el prototipado. Esta separación también permite hacer cambios en una parte de la aplicación sin que las demás se vean afectadas. Aunque lleva algún tiempo acostumbrarse a construir aplicaciones así, estamos seguros de que, una vez construyas tu primera aplicación con CakePHP, no querrás volver a hacerlo de otra forma.
2 Principios básicos de CakePHP El framework CakePHP proporciona una base robusta para tu aplicación. Puede manejar cualquier aspecto, desde la solicitud inicial del usuario hasta el renderizado final de la página web. Además, como el framework sigue los principios MVC, puedes fácilmente personalizar y extender muchos aspectos de tu aplicación. El framework también proporciona una estructura de organización básica, desde los nombres de los archivos hasta los de las tablas de la base de datos, manteniendo toda tu aplicación consistente y lógica. Este aspecto es simple pero poderoso. Sigue las convenciones y siempre sabrás exactamente dónde están las cosas y cómo están organizadas.
2.1 Estructura de CakePHP CakePHP incluye las clases Controlador [Controller], Modelo [Model] y Vista [View], pero también incluye otras clases y objetos que hacen que el desarrollo en MVC sea un poco más rápido y agradable. Los Componentes [Components], Comportamientos [Behaviors], y Ayudantes [Helpers] son clases que proporcionan extensibilidad y reusabilidad; agregan rápidamente funcionalidad a las clases base MVC de las aplicaciones. Como de momento nos vamos a mantener en este nivel de dificultad, ve preparando los detalles acerca de cómo usar estas herramientas. 2.1.1 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 quieres compartir entre varios controladores (o aplicaciones), un componente suele ser una buena elección. A modo de ejemplo, la clase del núcleo EmailComponent hace que la creación y el envío de mensajes de correo electrónico sea tan sencillo como coser y cantar. En lugar de escribir lógica en el método de un controlador, puedes empaquetarla 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. 2.1.2 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 [helpers] 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. 2.1.3 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 DataSources son una abstracción que permite a los modelos manipular diferentes tipos de datos en 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 le 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()
Los nombres de estos métodos deben ser lo suficientemente descriptivos para que sepa lo que hacen. Asegúrese de obtener los detalles en el capítulo acerca de los modelos. 2.1.4 Extensiones de la Aplicación Tanto los controladores como los ayudantes [helpers] y modelos tienen una clase padre que puede usarse para definir cambios a nivel global de la aplicación. AppController (localizado en /app/app_controller.php), AppHelper (localizado en /app/app_helper.php) y AppModel (localizado en /app/app_model.php) son magníficos lugares donde colocar métodos que desee compartir entre todos los controladores, ayudantes [helpers] o modelos. Las rutas juegan un rol en las peticiones hechas a CakePHP. Las definiciones de rutas le dicen a CakePHP cómo mapear URLs a acciones de controladores. El comportamiento por defecto asume que la URL "/controller/action/var1/var2/" mapea a Controller::action($var1, $var2), pero puede usar rutas para personalizar URLs y la forma en que éstas son interpretadas por su aplicación. Algunas características en una aplicación merecen ser empaquetadas como un todo. Un plugin es un paquete de modelos, controladores y vistas que cumplen un propósito específico que puede abarcar múltiples aplicaciones. Un sistema de administración de usuarios o un blog simplificado pueden ser buenos ejemplos para plugins de CakePHP.
2.2 Una petición típica de CakePHP Hemos cubierto los ingredientes básicos de CakePHP, así que echemos un vistazo a cómo los objetos trabajan juntos para completar una petición básica. Continuando con nuestro ejemplo de petición original, imaginemos que nuestro amigo Ricardo acaba de hacer clic en el enlace "¡Comprar un pastel personalizado ahora!" en una página de bienvenida de una aplicación CakePHP.
Figura 2. Petición típica de Cake. Negro = elemento requerido, Gris = elemento opcional, Azul = callback
•
Ricardo hace clic en el enlace apuntando a http://www.ejemplo.com/tortas/comprar, y su navegador hace una petición a su servidor Web.
• El enrutador analiza la URL para extraer los parámetros para esta petición: el controlador, la acción, y cualquier otro argumento(s) que pueda afectar a la lógica de negocio durante esta petición. • Usando las rutas, una petición URL es mapeada a una acción de controlador (un método en una clase de controlador específica). En este caso, es el método comprar() del controlador PastelesController. El callback beforeFilter() del controlador es llamado antes de que cualquier acción lógica del controlador sea ejecutada. • El controlador puede usar modelos para ganar acceso a los datos de la aplicación. En este ejemplo, el controlador usa un modelo para obtener información de la base de datos de las últimas compras de Ricardo. Cualquier callback de modelo, comportamiento [behavior], y orígenes de datos [DataSources] aplicables pueden activarse durante esta operación. Mientras que el uso del modelo no es requerido, todos los controladores de CakePHP inicialmente
requieren al menos un modelo, salvo que el desarrollador indique lo contrario. • Después que el modelo ha obtenido toda la información, ésta es devuelta al controlador. Pueden activarse callbacks del modelo. • El controlador puede usar componentes para refinar aun más los datos o realizar otras operaciones (manipulación de sesiones, autenticación, o envíos de email, por ejemplo). • Una vez que el controlador ha usado modelos y componentes para preparar suficientemente la información, ésta es entregada a la vista usando el método set() del controlador. Los callbacks de controlador pueden ser aplicados antes de que la información sea enviada. La lógica de vista es ejecutada, la cual puede incluir el uso de elementos y/o ayudantes [helpers]. Por defecto, la vista es creada dentro del diseño [layout]. • Callbacks del controlador adicionales (como afterFilter) pueden ser aplicados. El código completo creado por la vista es enviado al navegador de Ricardo.
2.3 Estructura de archivos de CakePHP Tras descargar y extraer CakePHP, estos serán los ficheros y carpetas que deberías ver: • app • cake • vendors • .htaccess • index.php • README Observarás 3 carpetas principales: • La carpeta app será donde haremos nuestra magia: es donde se ubicarán los ficheros de tu aplicación. • La carpeta cake es donde nosotros hemos hecho nuestra magia. Comprométete a no modificar los ficheros de esta carpeta. No podremos ayudarte si has modificado el núcleo. • Finalmente, la carpeta vendors es donde ubicarás las librerías PHP de terceros que necesites usar con tus aplicaciones en CakePHP.
# La Carpeta App La carpeta app de CakePHP es donde realizarás la mayor parte del desarrollo de tu aplicación. Veámos un poco más de cerca las carpetas dentro de app.
Contiene los (pocos) archivos de configuración que usa CakePHP. Detalles de config
conexión a bases de datos, arranque (bootstrapping), archivos de configuración del núcleo y demás deberían ser almacenados aquí.
controllers
Contiene los controladores de tu aplicación y sus componentes.
locale
Almacena archivos de cadenas de texto para la internacionalización.
models plugins
Contiene los modelos de tu aplicación, comportamientos (behaviors) y orígenes de datos (datasources). Contiene los paquetes de plugins. Aquí es donde CakePHP almacena datos temporales. La información que realmente se almacena depende de cómo hayas configurado CakePHP, pero normalmente esta carpeta es usada para almacenar descripciones de modelos,
tmp
registros (logs) y algunas veces información de sesiones. Asegúrate de que esta carpeta existe y tiene permisos de escritura, ya que de lo contrario el rendimiento de tu aplicación se verá muy afectado. En modo debug CakePHP te avisará si este no es el caso. Cualesquiera clases o librerías de terceros deberían ser ubicadas aquí. Hacerlo así hace que sea más fácil de acceder a ellas usando la función App::Import('vendor','nombre'). Los observadores meticulosos
vendors
notarán que esto parece redundante, ya que también existe una carpeta vendors en el nivel superior de nuestra estructura de directorios. Veremos las diferencias entre las dos cuando discutamos acerca de la administración de múltiples aplicaciones y configuraciones de sistemas más complejos.
views
Los archivos de presentación son ubicados aquí: elementos (elements), páginas de error, ayudantes (helpers), layouts y archivos de vistas. En una configuración de producción, esta carpeta debería servir como la raíz
webroot
del sitio (document root) para tu aplicación. Las carpetas aquí también sirven como lugares de almacenamiento para hojas de estilo en cascada (CSS stylesheets), imágenes y archivos JavaScript.
2.4 Convenciones de CakePHP Somos grandes fanáticos de convención sobre configuración. Aun cuando toma un poco de tiempo aprender las convenciones de CakePHP, usted ahorrará tiempo en la marcha: siguiendo las convenciones, usted obtiene libre funcionalidad, y también se libera de la pesadilla del mantenimiento del seguimiento de los archivos de configuración. Las convenciones también hacen un sistema de desarrollo muy uniforme, permitiendo a otros desarrolladores ayudar más fácilmente. Las convenciones de CakePHP han sido destiladas de años de experiencia de desarrollo web y mejores prácticas. Mientras que le sugerimos el uso de estas convenciones durante el desarrollo con CakePHP, deberíamos mencionar que muchos de estos postulados pueden ser anulados, esto es especialmente útil cuando se trabaja con sistemas heredados. 2.4.1 Convenciones de los nombres de archivos y clases En general, los nombres de archivo llevan el símbolo underscore "_", mientras que los nombres de las clases usan CamelCase. La clase MyNiftyClass puede ser encontrada en el archivo my_nifty_class.php, por ejemplo. Sin embargo, el nombre de la clase que contiene un archivo puede no necesariamente ser encontrada en el nombre de archivo. La clase EmailComponent es encontrada en un archivo llamado email.php, y la clase HtmlHelper es encontrada en un archivo llamado html.php. 2.4.2 Convenciones de Modelo y de la Base de datos Los nombres de las clases de modelos están en singular y en formato CamelCase. Persona, PersonaGrande, y PersonaMuyGrande son todos ejemplos de nombres de modelos convencionales. Los nombres de las tablas correspondientes a modelos de CakePHP están en plural y usando guión bajo. Las tablas subyacentes para los modelos arriba mencionados serían: personas, personas_grandes, y personas_muy_grandes respectivamente. Puedes utilizar la librería de utilidades "Inflector" para verificar las palabras singulares/plurales. Consulta la documentación de Inflector para más información. Los nombres de los campos con dos o más palabras se definen con guiones bajos: nombre_y_apellidos.
El nombre por defecto de las claves foráneas en relaciones hasMany, belongsTo o hasOne, es el nombre de la tabla relacionada (en singular) seguido de _id. Así, si Panadero hasMany Tarta, la tabla tartas referenciará la tabla panaderos mediante la clave foránea panadero_id. Para una tabla compuesta por varias palabras como tipos_categorias, la clave foránea sería tipo_categoria_id. El nombre de las tablas de unión entre modelos, usadas en relaciones hasAndBelongToMany (HABTM), debería estar formado por el nombre de las tablas que une puestos en orden alfabético (cebras_manzanas en vez de manzanas_cebras). Todas las tablas con las que interaccionan los modelos de CakePHP (con excepción de las de unión de tablas) necesitan una clave primaria simple que identifique inequívocamente cada fila. Si deseas modelar una tabla que no tiene una clave primaria de un sólo campo, como por ejemplo las filas de una tabla de unión posts_tags, la convención de CakePHP dicta que se añada una clave primaria de un solo campo a la tabla. CakePHP no soporta claves primarias compuestas. Si deseas manipular directamente los datos de tu tabla de unión, usa llamadas directas a query o añade una clave primaria para que actue como un modelo normal. Por ejemplo: CREATE TABLE posts_tags (
);
id INT(10) NOT NULL AUTO_INCREMENT, post_id INT(10) NOT NULL, tag_id INT(10) NOT NULL, PRIMARY KEY(id)
En vez de utilizar una clave autoincremental como clave primaria, puedes utilizar char(36). De este modo CakePHP utilizará un uuid(String::uuid) único de 36 caracteres siempre que grabes un nuevo registro utilizando el método Model::save. 2.4.3 Convenciones de Controladores Los nombres de las clases de los controladores son en plural, con formato CamelCased, y Terminan en Controller. PersonasController y UltimosArticulosController son ejemplos de nombres convencionales de controladores. El primer método que escribas para un controlador debe de ser el método index(). Cuando la petición especifica un controlador pero no una acción, el comportamiento por defecto de CakePHP es
ejecutar
el
método
index()
de
dicho
controlador.
Por
ejemplo,
una
petición
de
http://www.example.com/apples/ se corresponde con la llama al método index() del controlador ApplesController, mientras que http://www.example.com/apples/view se corresponde con una llamada al método view() del controlador ApplesController. También puedes cambiar la visibilidad de los métodos de los controladores en CakePHP anteponiendo al nombre del método guiones bajos. Si un método de un controllador comienza por un guión bajo, el método no será accesible diretamente desde la web, sino que estará disponible sólo para uso interno. Por ejemplo: _buscaNuevosArticulos(); } function _buscaNuevosArticulos() { //Lógica para encontrar los nuevos articulos. } } ?>
Mientras que la página http://www.example.com/noticias/ultimas/ está accesible de manera normal,
si
alguien
intenta
acceder
a
la
página
http://www.example.com/noticias/_buscaNuevosArticulos/ obtendrá un error porque el nombre del método está precedido por un guión bajo. 2.4.3.1 Consideraciones de URL para nombres de controladores
Como se puede ver, los controladores con un nombre simple (de una sola palabra) pueden ser fácilmente mapeados a una url en minúsculas. Por ejemplo, ApplesController (que se define en el archivo 'apples_controller.php') y accedido desde http://example.com/apples. Por otro lado múltiples combinaciones de palabras pueden ser transformadas automáticamente en un mismo nombre de controlador: •
/redApples
•
/RedApples
•
/Red_apples
•
/red_apples
Todas resuelven la acción index de controlador RedApples. sin embargo, la convención es que las urls sean en minúsculas y separadas con guión bajo, por lo tanto /red_apples/go_pick es la forma correcta de acceder a la acción. RedApplesController::go_pick. Para mas información sobre CakePHP URLs y sus parametros, ver Configuración de Rutas. 2.4.4 Convenciones de Vistas Los archivos de plantillas de Vistas (Views) deben ser nombradas después de las funciones de los controladores con guión bajo "_". La funcion getReady() del controlador PeopleController se visualizara con la plantilla de vista en /app/views/people/get_ready.ctp por ejemplo. El patrón básico es: /app/views/controller/underscored_function_name.ctp Al nombrar las piezas de su aplicación utilizando las convenciones de CakePHP, usted adquiere funcionalidad sin mucho mantenimiento de la configuración. Aquí encontramos un ejemplo final de las convenciones •
Tabla de Base de Datos: ‘people’
•
Clase de Modelo: ‘Person’, encontrada en /app/models/person.php
•
Clase de Controlador: ‘PeopleController’, encontrada en /app/controllers/people_controller.php
•
Plantilla de Vista, encontrada en /app/views/people/index.ctp
Usando estas convenciones, CakePHP entiende que la peticion http://example.com/people/ apunta a la llamada de funcion index() en el controlador , PeopleController, donde el modelo Person esta disponible automaticamente (y apunta automaticamente a la tabla ‘people’ en la base de datos), y se renderiza en el archivo. Ninguna de estas relaciones han sido configuradas por otra razon que crear clases y archivos que usted necesita crear. Ahora que usted ya se ha involucrado con los fundamentos de CakePHP, puede revisar el tutorial para realizar un Blog en CakePHP, que se encuentra al final de este manual.
3 Desarrollando con CakePHP Y ahora, a cocinar.
3.1 Requerimientos •
Servidor HTTP. Por ejemplo: Apache. Preferiblemente con mod_rewrite, pero no requerido.
•
PHP 4.3.2 o superior. Si, CakePHP funciona genial en PHP 4 y 5. Técnicamente no se requiere un motor de base de datos, pero nos imaginamos que la mayoría de
las aplicaciones usarán uno. CakePHP soporta una gran variedad de motores de almacenamiento: •
MySQL (4 o superior)
•
PostgreSQL
•
Firebird DB2
•
Microsoft SQL Server
•
Oracle
•
SQLite
•
ODBC
•
ADOdb
3.2 Preparándose para Instalar CakePHP es rápido y fácil de instalar.Los requisitos mínimos son un servidor web y una copia de Cake, ¡solo eso! Aunque este manual se enfoca primariamente en la configuración sobre Apache (por que es el usado comúnmente), Tu puedes configurar Cake para correr sobre la mayoría de servidores web, tales como, LightHTTPD o bien Microsoft IIS. Preparar la instalación consta de los siguientes pasos: •
Descargue CakePHP
•
Configure su servidor para manejar php si es necesario
•
Chequee los permisos de los archivos
3.2.1 Obteniendo CakePHP Hay dos principales maneras de obtener una copia limpia de CakePHP. Puedes descargar una copia comprimida (zip/tar.gz/tar.bz2) de la página web principal, o puedes obtener el código desde el repositorio git. Para descargar la última release principal de CakePHP, dirígete a la página web http://www.cakephp.org y haz clic en el enlace “Download Now”. Todas las releases actuales están alojadas en CakeForge. Este site también contiene enlaces a muchos otros proyectos en CakePHP, incluyendo plugins y aplicaciones para CakePHP. Las releases de CakePHP estásn disponibles en http://cakeforge.org/projects/cakephp. Se crean nightly builds alternativas que incluyen parches y mejoras al minuto (bueno, al día). Estas
pueden
ser
accedidas
desde
la
página
principal
de
descargas
aquí:
http://cakephp.org/downloads/index/nightly. Para actualizaciones realmente al minuto, puedes obtener el código directamente de la rama de desarrollo del repositorio git aquí: http://code.cakephp.org/source. 3.2.2 Permisos CakePHP usa el directorio /app/tmp para diferentes operaciones, como almacenar descripciones de los modelos, vistas en cache, información de sesiones, entre otros. Por ello, asegúrate que el directorio /app/tmp de tu instalación de Cake tenga permisos de escritura por el usuario del servidor web
3.3 Instalación Instalar CakePHP puede ser tan simple como colocar el directorio en el servidor, o tan complejo y flexible como necesites. Esta sección cubrirá los tres tipos principales de instalación para CakePHP: desarrollo, producción y avanzado •
Desarrollo: fácil para iniciar, los URL de la aplicación incluyen el nombre del directorio, y es menos seguro.
•
Producción: Requiere la capacidad de configurar el servidor web para definir el "document root", muy seguro.
•
Avanzado: Con cierta configuración, permite ubicar los directorios clave de CakePHP en diferentes partes del sistema de archivos, para compartir una misma instalación de CakePHP
para varias aplicaciones. 3.3.1 Desarrollo Usar una instalación de desarrollo es el método más rápido para montar Cake. Este ejemplo te ayudará
a
instalar
una
aplicación
de
CakePHP
y
hacerla
disponible
en
http://www.ejemplo.com/cake_1_2/. Asumimos para el fin de este ejemplo que tu raíz de documentos está establecido a /var/www/html. Descomprime los contenidos del archivo Cake en /var/www/html. Ahora tienes una carpeta en tu raíz de documentos con un nombre dependiente de la versión que te has descargado (p.ej. cake_1.2.0.7962). Renombra esta carpeta a cake_1_2. Tu configuración de desarrollo será como la siguiente en el sistema de archivos: •
/var/www/html • cake_1_2 • /app • /cake • /vendors • .htaccess • /index.php • README Si tu servidor web está configurado correctamente, deberías encontrar tu aplicación de Cake
accesible en http://www.ejemplo.com/cake_1_2/. 3.3.2 Producción Una instalación de producción es una manera más flexible de instalar Cake. Usar este método permite que un dominio entero se comporte como una aplicación CakePHP única. Este ejemplo te ayudará a installar Cake en cualquier sitio de tu sistema de ficheros y ponerlo disponible en http://www.ejemplo.com. Tener en cuenta que esta instalación puede requerir los privilegios para cambiar el DocumentRoot (raíz de documentos) en servidores web Apache. Descomprime los contenidos del archivo Cake en un directorio a tu elección. Por motivos de ejemplo, asumimos que escoges instalar Cake en /cake_install. Tu configuración de producción se verá de la siguiente manera en el sistema de ficheros: •
/cake_install/
• /app • /webroot (este directorio es el establecido con la directiva DocumentRoot) • /cake • /vendors • /.htaccess • /index.php • /README Los desarrolladores que usan Apache deberán establecer la directiva DocumentRoot para el dominio a: DocumentRoot /cake_install/app/webroot
Si tu servidor web está configurado correctamente, deberías encontrar tu aplicación Cake accesible en http://www.ejemplo.com. 3.3.3 Instalación Avanzada Existen situaciones en las que querrás colocar los directorios de CakePHP en lugares diferentes del sistema de archivos. Esto puede ser debido a restricciones de un servidor compartido, o quizás simplemente deseas que algunas de tus aplicaciones compartan las mismas librerías de Cake. Esta sección describe cómo esparcir los directorios de CakePHP sobre un sistema de archivos. En primer lugar, date cuenta que existen tres partes principales de una aplicación Cake: 1. Las librerías principales(core) de CakePHP, en /cake. 2. El código de tu aplicación, en /app. 3. El webroot de la aplicación, normalmente en /app/webroot. Cada uno de estos directorios puede ser ubicado en cualquier lugar de tu sistema de archivos, a excepción del webroot, que debe ser accesible por el servidor web. Incluso puedes mover el directorio webroot fuera de tu carpeta app siempre que le indiques a Cake en donde lo has puesto. Para
configurar
tu
instalación
de
Cake,
necesitarás
hacer
algunos
cambios
a
/app/webroot/index.php. Hay tres constantes que deberás editar: ROOT, APP_DIR, y CAKE_CORE_INCLUDE_PATH. •
ROOT debe contener la ruta del directorio que contiene la carpeta app (es decir, el padre de APP_DIR).
•
APP_DIR debe ser establecida con el nombre(base) de tu carpeta app.
•
CAKE_CORE_INCLUDE_PATH debe contener la ruta al directorio que contiene las librerías de Cake. Vamos a mostrar un ejemplo para ver cómo quedaría una instalación avanzada en la práctica.
Imagina que quiero configurar CakePHP para que funcione de esta manera: •
Las Librerías de CakePHP serán ubicadas en /usr/lib/cake.
•
El webroot de mi aplicación será /var/www/misitio/.
•
El directorio app de mi aplicación estará en /home/yo/misitio. Dada esta configuración, necesitaré editar mi webroot/index.php (el cual terminará
ubicado en /var/www/misitio/index.php, en este ejemplo) para que sea así: // /app/webroot/index.php (codigo parcial, sin comentarios) if (!defined('ROOT')) { define('ROOT', DS.'home'.DS.'yo'); } if (!defined('APP_DIR')) { define ('APP_DIR', 'misitio'); } if (!defined('CAKE_CORE_INCLUDE_PATH')) { define('CAKE_CORE_INCLUDE_PATH', DS.'usr'.DS.'lib'); }
Es recomendable utilizar la constante DS en lugar de barras inclinadas para delimitar las rutas de los archivos. Esto evita errores por falta de archivo como resultado de usar el delimitador equivocado, y además hace tu código más portable. 3.3.3.1 Rutas de Clase Adicionales
Ocasionalmente es útil compartir clases MVC entre aplicaciones en el mismo sistema. Si quieres el mismo controler en dos aplicaciones, puedes usar el archivo bootstrap.php de CakePHP para traer estas clases adicionales a la escena. En el archivo bootstrap.php, define algunas variables especiales para que CakePHP sepa otros lugares en donde buscar clases MVC: $viewPaths
Cada una de estas variables especiales pude ser establecida a un array de rutas absolutas en el sistema de archivos donde las clases adicionales pueden ser encontradas cuando se solicite. Asegúrate que cada ruta contenga una barra inclinada (o preferiblemente la constante DS) al final. 3.3.4 Apache y mod_rewrite (y .htaccess) A pesar de que CakePHP está hecho para funcionar con mod_rewrite sin tocar nada, y normalmente así es, hemos notado que algunos usuarios tienen dificultades para lograr que todo funcione correctamente en sus sistemas. Aquí hay unas cuantas cosas que puedes probar para conseguir que funcione correctamente. Primero mira en tu httpd.conf (asegúrate de estar editando el httpd.conf del sistema y que no es httpd.conf específico de un usuario o del site). 1. Asegúrate que la reescritura .htaccess esté permitida y que AllowOverride esté establecido a All para el DocumentRoot adecuado. Deberías ver algo similar a: # Cada directorio al que tiene acceso Apache puede ser configurado en # función de qué servicios y características están permitidas y/o # desactivadas en dicho directorio (y sus subdirectorios). # # Primero, configuramos "por defecto" para que sea un conjunto de # características muy restrivo. # Options FollowSymLinks AllowOverride All # Order deny,allow # Deny from all
2. Asegúrate de estar cargando el módulo mod_rewrite correctamente. Debes ver algo como: LoadModule rewrite_module libexec/apache2/mod_rewrite.
En muchos sistemas esto estará comentado (comenzando la línea con #) por defecto, así que sólo tendrás que quitar los símbolos # del principio.
Tras realizar los cambios reinicia Apache para estar seguro de que las opciones de configuración están activas. Asegúrate de que tus ficheros .htaccess están en los directorios correctos. Esto puede pasar durante la copia porque algunos sistemas operativos consideran los archivos que comienzan por '.' como ocultos y por lo tanto no los copian. 3. Asegúrate de que tu copia de CakePHP es de las sección de descargas de nuestro site o nuestro repositorio GIT, y que ha sido desempaquetado correctamente verificando que existen los ficheros .htaccess:
En el directorio raíz de Cake (necesita ser copiado al directorio, esto redirige todo a tu aplicación de Cake): RewriteEngine on RewriteRule ^$ app/webroot/ [L] RewriteRule (.*) app/webroot/$1 [L]
En el directorio app de Cake (será copiado por bake): RewriteEngine on RewriteRule ^$ webroot/ RewriteRule (.*) webroot/$1
[L] [L]
En el directorio webroot de Cake (será copiado a tu webroot de la aplicación por bake): RewriteEngine On RewriteCond %{REQUEST_FILENAME} !-d RewriteCond %{REQUEST_FILENAME} !-f RewriteRule ^(.*)$ index.php?url=$1 [QSA,L]
En muchos servicios de hosting (GoDaddy, 1and1), tu servidor web está realmente siendo servido desde un directorio de usuario que ya utiliza mod_rewrite. Si estás instalando CakePHP en un directorio de usuario (http://ejemplo.com/~nombreusuario/cakephp), o en cualquier otra estructura que ya utilice mod_rewrite necesitarás añadir sentencias RewriteBase a los archivos .htaccess que utiliza CakePHP (/.htaccess, /app/.htaccess, /app/webroot/.htaccess) Esto puede ser añadido a la misma sección con la directiva RewriteEngine, así, por ejmplo,
tu archivo .htaccess en el webroot devería ser así: RewriteEngine On RewriteBase / RewriteCond %{REQUEST_FILENAME} !-d RewriteCond %{REQUEST_FILENAME} !-f RewriteRule ^(.*)$ index.php?url=$1 [QSA,L]
RewriteEngine On RewriteBase / RewriteCond %{REQUEST_FILENAME} !-d RewriteCond %{REQUEST_FILENAME} !-f RewriteRule ^(.*)$ index.php?url=$1 [QSA,L] Los detalles de esos cambios dependen de tu configuración, y pueden incluir cosas adicionales que no están relacionadas con Cake. Consulta la documentación online de Apache para más información. 3.3.5 Lighttpd y mod_magne Aunque Lighttpd cuenta con un módulo de reescritura, no es equivalente al mod_rewrite de Apache. Las funcinalidades completas de mod_rewrite se reparten entre el mod_rewrite de Lighttp, el mod_magnet y el mod_proxy. Sin embargo, CakePHP, mayoritariamente necesita mod_magnet para redirigir las solicitudes a fin de trabajar con bastantes URLs Para utilizar bastantes URLs con CakePHP y Lighttp, sustituye este lua script en /etc/lighttpd/cake. -- pequeña funcion helper function file_exists(path) local attr = lighty.stat(path) if (attr) then return true else return false end end function removePrefix(str, prefix) return str:sub(1,#prefix+1) == prefix.."/" and str:sub(#prefix+2) end
-- prefijo sin la barra local prefix = '' -- la magia ;) if (not file_exists(lighty.env["physical.path"])) then -- fichero aún desaparecido, pasarlo al fastcgi Backend request_uri = removePrefix(lighty.env["uri.path"], prefix) if request_uri then lighty.env["uri.path"] = prefix .. "/index.php" local uriquery = lighty.env["uri.query"] or "" lighty.env["uri.query"] = uriquery .. (uriquery ~= "" and "&" or "") .. "url=" .. request_uri lighty.env["physical.rel-path"] = lighty.env["uri.path"] lighty.env["request.orig-uri"] = lighty.env["request.uri"] lighty.env["physical.path"] = lighty.env["physical.doc-root"] .. lighty.env["physical.rel-path"] end end -- fallthrough pondrá de nuevo la solucititud en el bucle lighty -- eso significa que tenemos la manipulación 304 de forma gratuita. ;)
Then tell Lighttpd about your vhost: $HTTP["host"] =~ "example.com" { server.error-handler-404
= "/index.php"
magnet.attract-physical-path-to = ( "/etc/lighttpd/cake.lua" ) server.document-root = "/var/www/cake-1.2/app/webroot/" # además piensa como coger los ficheros vim tmp fuera url.access-deny = ( "~", ".inc", ".sh", "sql", ".sql", ".tpl.php", ".xtmpl", "Entries", "Repository", "Root", ".ctp", "empty" ) }
3.3.6 Pretty URLs en nginx nginx es un servidor popular que, del mismo modo que Lighttpd, consume menos recursos del sistema. Su inconveniente es que no utiliza ficheros .htaccess como Apache y Lighttpd, por lo que es necesario crear esas reescrituras de URLs en la configuración de site-available. Dependiendo de tu configuración, necesitarás modificar esto, pero como mínimo necesitarás que PHP se ejecute como instancia de FastCGI. server { listen 80; server_name www.ejemplo.com; rewrite ^(.*) http://ejemplo.com$1 permanent;
3.3.7 URL Rewrites on IIS7 (Windows hosts) IIS7 does not natively support .htaccess files. While there are add-ons that can add this support, you can also import htaccess rules into IIS to use CakePHP's native rewrites. To do this, follow these steps: 1. Use Microsoft's Web Platform Installer to install the URL Rewrite Module 2.0. 2. Create a new file in your CakePHP folder, called web.config 3. Using Notepad or another XML-safe editor, copy the following code into your new web.config file...
negate="true" />
It is also possible to use the Import functionality in IIS's URL Rewrite module to import rules directly from CakePHP's .htaccess files in root, /app/, and /app/webroot/ - although some editing within IIS may be necessary to get these to work. When Importing the rules this way, IIS will automatically create your web.config file for you. Once the web.config file is created with the correct IIS-friendly rewrite rules, CakePHP's links, css, js, and rerouting should work correctly. 3.3.8 Enciéndelo Muy bien, ahora veamos a CakePHP en acción. Dependiendo de la configuración que hayas usado, deberías apuntar tu navegador a http://example.com/ o http://example.com/mi_aplicacion/. En este punto, se te presentará la vista de bienvenida de CakePHP por omisión, y un mensaje que indica el estado de conexión con la base de datos. ¡Felicidades! Ya estás listo para crear tu primera aplicación CakePHP.
3.4 Configuración Configurar aplicaciones CakePHP es pan comido. Despues de instalar CakePHP, crear una aplicación web básica solo requiere aplicar la configuración de una base de datos. Existen, otras configuraciones opcionales, que puedes realizar con el objetivo de aprovechar las ventajas de la arquitectura flexible de CakePHP. Tu puedes agregar facilmente elementos al núcleo de CakePHP, configurar URL personalizadas y definir inflexiones. 3.4.1 Configuración de Base de Datos CakePHP espera que los detalles de configuración de la base de datos estén en app/config/database.php.
Un ejemplo
de configuración
puede encontrarse en el archivo
app/config/database.php.default. Esta configuración debería verse como sigue: var $default = array('driver' 'persistent' 'host' 'login' 'password' 'database' 'prefix'
El arreglo de configuración $default es el utilizado a menos que se especifique algún otro en la propiedad $usDbConfig de los modelos. Por ejemplo, si mi aplicación tiene aplicaciones legadas adicionales a la que se va a utilizar por defecto, podría utilizarla en mis modelos creando un nuevo arreglo de configuración $legada que sea similar a $default, y asignado var $useDbConfig = 'legada'; en los modelos correspondientes. Rellena cada para clave/valor en el arreglo de configuración, como mejor se ajuste a tus necesidades Clave
Valor
driver
El nombre del controlador de base de datos que se desea utilizar. Ejemplo: mysql, postgres, sqlite, pear-nombrededriver, adodb-nombrededriver, mssql, oracle, odbc.
persistent
Si se debe usar o no una conexión persistente a la base de datos.
host
El nombre de servidor de la base de datos (o dirección IP).
login
El nombre de usuario para la cuenta.
password
La contraseña para la cuenta.
database
Nombre de la base de datos a usar para la conexión
prefix (opcional)
El texto que prefija cada nombre de tabla en la base de datos. Útil si se comparte la base de datos con varias aplicaciones. Dejar vacío si no se desea ninguno.
port (opcional)
El puerto TCP o socket Unix a usarse para la conexión con el servidor de base de datos.
encoding
Indica la codificación de caracteres a usar para enviar las sentencias SQL al servidor.
schema
Usado en la configuración de PostgreSQL para especificar el esquema a utilizar.
Nota que los prefijos son para las tablas, no para los modelos. Por ejemplo, si creaste una tabla join
para
tus
modelos
Torta
y
Sabor,
esta
debe
llamarse
prefijo_sabor_torta
(no
prefijo_sabor_prefijo_torta), y asignar la clave prefix con ‘prefijo_’. A este punto, pudieras querer echar un vistazo a las Convenciones de CakePHP, enunciadas en el apéndice de este manual. Nombrar correctamente tus tablas (y algunas columnas) según las convenciones puede librarte de mucho trabajo de configuración. Por ejemplo, si nombras una tabla como tortas, el modelo Torta y el controller TortasController, todo funcionará automáticamente si necesidad de tu intervención. Por convención, utiliza guiones bajos, minúsculas, y nombres en plural para los nombres de tus tablas - por ejemplo: reposteros, reposterias, sabores. 3.4.2 Configuración del Core La configuración de la aplicación en CakePHP se encuentra en /app/config/core.php. Este archivo es una colección de definiciones de variables Configure y definiciones de constantes que determinan como ha de comportarse la aplicación. Antes de sumergirse en cada una de estas directivas, necesitarás familiarizarte con Configure, la clase de registro de configuraciones de CakePHP 3.4.3 La Clase de Configuración A pesar de que muy pocas cosas necesitan configuración en CakePHP, a veces es útil tener tus propias reglas de configuración para tu aplicación. En el pasado seguramente habrías definido alguno de estos valores creando constantes en varios archivos. Hacerlo de esa manera te obligaría a incluir estos archivos cada vez que desees utilizarlos. La nueva clase Configure de CakePHP puede ser utilizada para guardar y recuperar valores específicos de la aplicación o de tiempo de ejecución. Se cuidadoso, esta clase permite almacenar cualquier cosa en ella, para luego usarla en cualquier lugar de tu código: una tentación segura para
romper el patrón MVC con el cual fue diseñado CakePHP. El objetivo principal de la clase Configure es mantener centralizadas las variables que pueden ser compartidas entre varios objetos. Recuerda tratar de mantener la filosofía de "convención sobre configuración" y así no terminarás rompiendo la estructura MVC que se ha diseñado. Esta clase actúa como un singletón, y sus métodos pueden ser llamados desde cualquier lugar en tu aplicación, en un contexto estático.
3.4.3.1 Métodos de la Clase Configure 3.4.3.1.1 write write(string $clave, mixed $valor)
Utiliza write() para almacenar datos en la configuración de la aplicación Configure::write('Empresa.nombre','Pizza, Inc.'); Configure::write('Empresa.lema','Pizza para tu cuerpo y alma');
Nota el uso de la notación punto en el parámetro $clave. Puedes utilizar esta notación para organizar tus configuraciones dentro de grupos lógicos. El ejemplo anterior pudo ser escrito en una sola llamada: Configure::write( 'Empresa',array('nombre'=>'Pizza, Inc.','lema'=>'Pizza para tu cuerpo y alma') );
Puedes utilizar Configure::write(‘debug’, $int) para cambiar entre desarrollo y producción dentro de la ejecución de tu programa. Esto es especialmente útil para interacciones AMF o SOAP donde la información de depuración puede ocasionar problema de parseo. 3.4.3.1.2 read read(string $clave = 'debug') Se usa para leer datos de configuración de la aplicación. Por defecto
devuelve
el
importante
valor
de
"debug"
(nivel
de
depuración). Si se especifica una clave, los datos correspondientes
son
devueltos.
Usando
nuestros
anteriores
ejemplos
de
write(),
podemos leer esos datos de vuelta: Configure::read('Empresa.nombre');
//devuelve: 'Pizza, Inc.'
Configure::read('Empresa.lema');
//devuelve: 'Pizza para tu cuerpo y alma'
Configure::read('Empresa'); //devuelve: array('nombre' => 'Pizza, Inc.', 'lema' => 'Pizza para tu cuerpo y alma');
3.4.3.1.3 delete delete(string $clave) Se usa para borrar información de configuración de la aplicación. Configure::delete('Empresa.nombre');
3.4.3.1.4 load load(string $path) Usa este método para cargar información de configuración desde una archivo específico. // /app/config/mensajes.php:
3.4.3.1.5 version version() Devuelve la versión de CakePHP de la aplicación actual. 3.4.3.2 Variables de Configuración Principales de CakePHP La clase Configure se usa para manejar un conjunto de variables de configuración de CakePHP. Estas variables pueden ser encontradas en app/config/core.php. Abajo se encuentra una descripción de
cada variable y cómo afecta tu aplicación CakePHP. Variable de Configuración
Descripción Cambia el nivel de depuración de cake
debug
0 = Modo produción. No produce ninguna salida. 1 = Muestra los error y warnings. 2 = Muestra los error, warnings, y consultas SQL
App.baseUrl
Descomenta esta definición si no deseas utilizar el mod_rewrite de Apache. No te olvides de eliminar los archivos .htaccess también.
Routing.admin
Descomenta esta definición si deseas utilizar las rutas admin de CakePHP. Asigna la variable al nombre de la ruta que te gustaría utilizar. Más adelante se explicará en detalle.
Cache.disable
Cuando se asigna true, el cache se deshabilita para toda la aplicación.
Cache.check
Si se asigna true, habilita el cache de las vistas. También es necesario activar el cache en los controllers, pero esta variable habilita la detección de dichas configuraciones. Le indica a CakePHP qué mecanismo de almacenamiento de sesiones se debe utilizar
Session.save
php = Utiliza el almacenamiento por defecto de php cake = Guarda los datos de sesión en /app/tmp database = Guarda los datos en una tabla de la base de datos. Asegúrate de cargar el archivo SQL ubicado en /app/config/sql/sessions.sql.
Session.table
El nombre de la tabla (sin incluir el prefijo) que guarda los datos de la sesión.
Session.database
El nombre de la base de datos que guarda los datos de sesión.
Session.cookie
El nombre del cookie utilizado para hacer seguimiento de las sesiones.
Session.timeout
El tiempo base de validez de la sesión en segundos. El valor real depende de la variable Security.level
Session.start
Inicia automáticamente la sesión cuando se asigna true.
Session.checkAgent
Cuando se asigna false, Las sesiones de CakePHP no se asegurarán de que el "user agent" del usuario no cambie entre peticiones. El nivel de seguridad de CakePHP. El tiempo de validez de la sesión definido en 'Session.timeout' se multiplica de acuerdo a lo siguiente.
Security.level
Valores válidos: 'high' = x 10 'medium' = x 100 'low' = x 300
Security.salt
Una palabra aleatoria usada en sumas de seguridad.
Acl.classname, Acl.database
Variables usadas para las Listas de Control de Acceso de CakePHP. Lee el capítulo de listas de control de acceso para más información.
Nota: La configuración de Cache también puede ser encontrada en el archivo core.php — Más adelante cubriremos este tema.
La clase Configure puede ser utilizada para leer y escribir valores durante la ejecución del programa. Esto puede ser especialmente útil si desea deshabilitar el nivel de deburacion ("debug") para una sección limita de lógica en tu aplicación.
3.4.3.3 Constantes de Configuración A pesar de que la mayoría de las opciones de configuración se manejan con la clase Configure, existen unas pocas constantes que utiliza CakePHP durante su ejecución. Constante
Descripción
LOG_ERROR
Constante de error. Usada para diferenciar entre registros de depuración y registros de error. Actualmente PHP solo soporta LOG_DEBUG.
3.4.4 La Clase App Cargar clases adicionales se ha vuelto mucho más sencillo con CakePHP. En versiones anteriores existían funciones diferentes para cargar una clase dependiendo de su tipo. Estas funciones han sido reemplazadas, ahora toda la carga de clases debería hacerse a través de el método App::import(). Éste método te asegura que una clase ha sido cargada sólo una vez, que las clases que extiende se hayan cargado apropiadamente, y resuelve las rutas de ubicación automáticamente en la gran mayoría de los casos. 3.4.4.1 Usando App::import() App::import($type, $name, $parent, $search, $file, $return); A primera vista App::import parece complejo, sin embargo, en la mayoría de los casos es suficiente con tan sólo dos parámetros. 3.4.4.2 Importando librerías del Core Las librerías del Core, como Sanitize y Xml pueden ser cargadas mediante: App::import('Core', 'Sanitize'); Lo anterior hará que la clase Sanitize esté disponible para su uso.
3.4.4.3 Importando Controladores, Modelos, Ayudantes, Comportamientos y Componentes App::import('Controller', 'MyController'); Llamando a App::import es equivalente a require. Es importante darse cuenta que la clase posteriormente necesita ser inicializada. constructClasses(); ?>
3.4.4.3.2 Cargando Modelos [Model] App::import('Model', 'MyModel'); 3.4.4.3.3 Cargando Componentes [Components] App::import('Component', 'Auth'); 3.4.4.3.4 Cargando Comportamientos [Behaviors] App::import('Behavior', 'Tree'); 3.4.4.3.5 Cargando Ayudantes[Helpers] App::import('Helper', 'Html'); 3.4.4.4 Cargando desde Plugins Cargar clases en plugins funciona casi igual que cargar clases ubicadas en el Core o en la aplicación principal, a excepción de que debe especificarse el nombre del plugin donde reside la clase a cargar. App::import('Modelo', 'NombrePlugin.Comentario');
3.4.4.5 Cargando Archivos de Terceros La función vendor() ha sido reemplazada. Los archivos de terceros deben ser cargados también mediante App::import(). La sintaxis y los argumentos adicionales son levemente diferentes, debido a que los archivos de terceros y su estructura pueden variar inmensamente, y no todos los archivos de terceros contienen clases. Los siguientes ejemplos ilustran cómo cargar archivos de terceros en diferentes rutas y estructuras. Los archivos de terceros deben estar ubicados en cualquiera de los directorios vendor. 3.4.4.5.1 Ejemplos de archivos de terceros Para cargar vendors/geshi.php App::import('Vendor', 'geshi'); Para cargar vendors/flickr/flickr.php App::import('Vendor', 'flickr/flickr'); Para cargar vendors/cierto.nombre.php App::import('Vendor', 'CiertoNombre', array('file' => 'cierto.nombre.php')); Para cargar vendors/services/well.named.php App::import('Vendor', 'WellNamed', array('file' => 'services'.DS.'well.named.php'));
3.4.5 Configuración de Rutas El enrutamanieto permite hacer una relación entre URLs y acciones de los controller. Fue añadido a CakePHP para hacer más bonitos los URLs, más configurables, y más flexibles. Usar el mod_rewrite de Apache no es un requisito para utilizar el enrutamiento, pero hará lucir mucho mejor tu barra de direcciones. Las rutas en CakePHP 1.2 han sido mejoradas y pueden llegar a ser muy poderosas. Enrutamiento por Defecto Antes de que aprendas a configurar tus propias rutas, deberías saber que CakePHP viene configurado con un conjunto de rutas por defecto. Estas rutas te llevarán bastante lejos en cualquier aplicación. Puedes acceder a una acción directamente desde el URL colocando su nombre en la
petición. También puedes pasar parámetros a las acciones de tus controladores usando el URL. Patron URL de las rutas por defecto: http://example.com/controlador/accion/param1/param2/param3
El
URL /articulos/ver
dirige
a
la
acciónver()
action
del ArticulosController,
y
/productos/listaCompleta dirige a la accion to the lista_completa() de ProductosController. Si no se especifica ninguna acción en el URL, se asume que se trata de la acción index(). La configuración inicial de enrutamiento permite pasar parámetros a tus acciones usando el URL. Una petición para /articulos/ver/25 sería equivalente a llamar ver(25) en el ArticulosController, por ejemplo. Parámetros con Nombre Algo novedoso en CakePHP 1.2 es la habilidad de usar parámetros con nombre (named parameters). Puedes nombrar parámetros y enviar sus valores usando el URL. Una petición para /articulos/ver/titulo:primer+articulo/categoria:general resultaría en una llmada a la accion view() de ArticulosController. En dicha acción, puedes encontrar los valores del título y la categoría dentro de $this->passedArgs['titulo'] and $this->passedArgs['categoria'] respectivamente. Algunos ejemplos que resuman las rutas por defecto puede resultar útil.
Definir Rutas Definir tus propias rutas te permite definir cómo va a responder tu aplicación cuando se solicite un URL determinado. Tus rutas deben ser definidas en el archivo /app/config/routes.php usando el método Router::connect().
El método connect() toma hasta tres parámetros: el patron de URL que deseas hacer coindicir, los valores por defecto para los elementos de enrutamient propios, y expresiones regulares que ayuden al enrutador a hacer coincidir elementos en el URL. El formáto básico para una definición de ruta es: Router::connect(
El primer parámetro es usado para decirle al enrutador qué tipo de URL estás tratando de controlar. El URL es una cadena de caracteres separadas por barras inclinadas (slash), pero también pueden contener el un comodín comodín (*) o elementos de enrutamiento propios (Elementos de URL prefijados con el caracter dos puntos ":"). Usar un comodín le indica al enrutador qué tipos de URL quieres hacer coincidir, y especificar elementos de enrutamiento te permite recolectar parámetros para las acciones de tus controladores Una vez que hayas especificado un URL, debes utilizar los últimos dos parámetros del método connect() para decirle a CakePHP que hacer con esa petición una vez que ha sido seleccionada la regla adecuada. El segundo parámetro es una arreglo asociativo. Las claves de este arreglo deben ser nombradas como los elementos de enrutamiento en el URL, o los elementos por defecto, que son, :controller, :action y :plugin. Los valores en este arreglo son los valores por omisión para cada una de las claves. Veamos algunos ehjemplos básicos antes de empezar a usar el tercer parámetro de connect() Router::connect( '/pages/*', array('controller' => 'pages', 'action' => 'display') );
Esta ruta se encuentra en el archivo routes.php distribuido con CakePHP (linea 40). Esta ruta coincide con los URL que comienzan con /pages/ y delega a la acción display() de PagesController el manejo de la petición. La petición /pages/productos puede sería dirigida a PagesController>display('productos'), por ejemplo. Router::connect(
Este segundo ejemplo muestra como usar el segundo parámetro de connect() para definir parámetros por omisión. Si construiste un sitio que muestra productos para diferentes categorías de clientes, puedes considerar el hacer una ruta. Esto te ayuda a crear el enlace /mujeres en lugar de /productos/mostrar/5 Para tener flexibilidad adicional, puedes especificar elementos de enrutamiento propios. Hacer esto te da el poder de definir lugares en el URL donde los parámentros para las acciones deben residir. Cuando se hace una petición, los valores para estos elementos propios se encuentran en $this-gt;params del controlador. Estos son diferentres de los parametros con nombre, y esta es la diferencia: los parmámetros con nombre (/controlador/accion/nombre:valor) se encuentran en $this->passedArgs, mientras que los elementos propios de enrutamiento se encuentran en $this->params. Cuando defines un elemento propio de enrutamiento, también necesitas especificar una expresión regular. Esto le indica a CakePHP cómo reconocer si el URL está bien formado o no. Router::connect(
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. Una vez que hayas definido esta ruta, solicitar /manzanas/5, sería lo mismo que solicitar /manzanas/ver/5. Ambos harán una llamada al método ver() de ManzanasController. Dentro del método ver(), podrías acceder al id en $this->params['id']. Un ejemplo más y serás un profesional del enrutador. Router::connect( '/:controller/:year/:month/:day', array('action' => 'listar', 'day' => null), array( 'year' => '[12][0-9]{3}', 'month' => '(0[1-9]|1[012])', 'day' => '(0[1-9]|[12][0-9]|3[01])'
) );
Puede parecer un poco enredado, pero muestra lo poderosas que pueden ser las rutas. El URL suministrado tiene cuatro elemento. El primero ya debe resultarte familiar: el elemento que le dice a CakePHP que se trata de un nombre de controlador. A continuación, vamos a especificar algunos valores por defecto. Sin importar el controlador, queremos que la acción listar() sea llamada. Asignamos el parámetro day (día, que es el cuarto elemento en el URL) a null, para marcarlo como opcional. Finalmente especificamos algunas expresiones regulares que coindidiran con años, meses y días en su forma numérica. Una vez definda, esta ruta coindcidirá con /articulos/2007/02/01, /escritos/2004/11/16 y /productos/2001/05 (¿recuerdas que el parametro day era opcional?), enviando la petición a listar() de sus respectivos controladores, con los parámetros de fecha definidos en $this->params. Pasando parámetros a la acción Asumiendo que tu acción fue definida como se muestra a continuación, y que desea acceder a los argumentos usando $articuloID en lugar de $this->params['id'], simplemente agrega el tercer parámetro de Router::connect(). // some_controller.php function ver($articuloID = null, $slug = null) { // mi codigo aqui... } // routes.php 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]+' ) )
Y ahora, gracias a las capacidades de enrutamiento inverso, puedes usar el arreglo de url que se muestra a continuación y Cake sabrá cómo formar el URL tal como fue definido en las rutas. // ver.ctp
// Esto va a devolver un lik a /blog/3-CakePHP_Rocks link('CakePHP Rocks', array( 'controller' => 'blog', 'action' => 'view', 'id' => 3, 'slug' => Inflector::slug('CakePHP Rocks') )) ?>
Rutas con prefijos Muchas cplicaciones requieren una zona administrativa donde los usuarios privilegiados puedan hacer
cambios.
Estos
es
comunment
hecho
a
través
de
un
URL
especial
como
/admin/usuarios/editar/5. En CakePHP, las rutas admin pueden ser habilitadas en el archivo core.php asignando la ruta para Routing.admin. Configure::write('Routing.admin', 'admin');
En tu controlador, cualquier acción que empiece por admin_ será llamada. Usando nuestro ejemplo de usuarios, el nombre de la acción de nuestro UsuariosController debe ser admin_editar Puedes usar el enrutador para usar prefijos propios para usos más allá de la administración. Router::connect('/perfiles/:controller/:action', array('prefix' => 'perfiles'));
Cualquier llamada a la sección de perfiles buscará el prefijo perfiles_ en las llamadas a métodos. Nuestro ejemplo de usuarios tendría una estructura de URL que luciría como /perfiles/usuarios/editar/5, lo cual invocaría el método perfiles_editar del UsuariosController. también es importante reordar que usar el Ayudante HTML para construir tus enlaces te ayudará a mantener los prefijos. Este es un ejemplo de un enlace usando el ayudante HTML . echo $html->link('Editar tu perfil', array('controller' => 'usuarios', 'action' => 'perfiles_editar'));
Puedes utilizar múltiples prefijos de ruta para crar una muy flexible estructura de URL para tu aplicación.
3.4.5.1 Enrutamiento por defecto
Antes de que leas como configurar tus rutas, deberías saber que CakePHP incluye algunas por defecto. El enrutamiento en CakePHP te ofrece mucho más que cualquier otra aplicación. Puedes acceder directamente a cualquier acción poniéndola solo en la URL. Puedes enviar también variables a la acción a través de la URL. Patrones de enrutamiento por defecto: http://example.com/controller/action/param1/param2/param3
La URL /posts/view enruta hacia la accion view() del controlador PostsController y /products/viewClearance enruta hacia la accion view_clearance() del controlador ProductsController. Si la acción no esta definida en la URL, el método index() es asumido por defecto. El enrutamiento por defecto te permite enviar parámetros a la acción a través de la URL. Una petición hacia /posts/view/25 sería equivalente a llamar a la acción view(25) en el controlador PostsController. 3.4.5.2 Passed arguments
Una nueva característica en CakePHP 1.2 es la posibilidad de setear nombres de parámetros y su valor por la URL. Una petición a /posts/view/title:first+post/category:general resultaría en una llamada a la acción view() del controlador PostsController. En esta acción, podrás encontrar los valores para
title
y
category
dentro
de
$this->passedArgs['title']
y
$this->passedArgs['category']
respectivamente. Algunos ejemplos que pueden ser de utilidad. Acceder a la acción jump() del controlador MonkeysController desde la URL: URL: /monkeys/jump Enrutado: MonkeysController->jump(); URL: /products Enrutado: ProductsController->index(); URL: /tasks/view/45 Enrutado: TasksController->view(45); URL: /donations/view/recent/2001 Enrutado: DonationsController->view('recent', '2001'); URL: /contents/view/chapter:models/section:associations Enrutado: ContentsController->view(); $this->passedArgs['chapter'] = 'models';
$this->passedArgs['section'] = 'associations';
3.4.5.4 Defining Routes
Defining your own routes allows you to define how your application will respond to a given URL.
Define
your
own
routes
in
the
/app/config/routes.php
file
using
the
Router::connect() method. The connect() method takes up to three parameters: the URL you wish to match, the default values for your route elements, and regular expression rules to help the router match elements in the URL. The basic format for a route definition is: Router::connect( 'URL', array('paramName' => 'defaultValue'), array('paramName' => 'matchingRegex') )
The first parameter is used to tell the router what sort of URL you're trying to control. The URL is a normal slash delimited string, but can also contain a wildcard (*) or route elements (variable names prefixed with a colon). Using a wildcard tells the router what sorts of URLs you want to match, and specifying route elements allows you to gather parameters for your controller actions. Once you've specified a URL, you use the last two parameters of connect() to tell CakePHP what to do with a request once it has been matched. The second parameter is an associative array. The keys of the array should be named after the route elements in the URL, or the default elements: :controller, :action, and :plugin. The values in the array are the default values for those keys. Let's look at some basic examples before we start using the third parameter of connect(). Router::connect( '/pages/*', array('controller' => 'pages', 'action' => 'display') );
This route is found in the routes.php file distributed with CakePHP (line 40). This route matches any URL starting with /pages/ and hands it to the display() method of the PagesController();
The
request
/pages/products
PagesController->display('products'), for example.
This second example shows how you can use the second parameter of connect() to define default parameters. If you built a site that features products for different categories of customers, you might consider creating a route. This allows you link to /government rather than /products/display/5. Another common use for the Router is to define an "alias" for a controller. Let's say that instead of accessing our regular URL at /users/someAction/5, we'd like to be able to access it by /cooks/someAction/5. The following route easily takes care of that: Router::connect( );
This is telling the Router that any url beginning with /cooks/ should be sent to the users controller. When generating urls, routes are used too. Using array('controller' => 'users', 'action' => 'someAction', 5) as a url will output /cooks/someAction/5 if the above route is the first match found. If you are planning to use custom named arguments with your route, you have to make the router aware of it using the Router::connectNamed function. So if you want the above route to match urls like /cooks/someAction/type:chef we do: Router::connectNamed(array('type')); Router::connect( '/cooks/:action/*', array('controller' => 'users', 'action' => 'index') );
Router::connectNamed(array('type')); 1. Router::connect( 2. '/cooks/:action/*', array('controller' => 'users', 'action' => 'index') 3. ); You can specify your own route elements, doing so gives you the power to define places in the URL where parameters for controller actions should lie. When a request is made, the values for these route elements are found in $this->params of the controller. This is different than named parameters are handled, so note the difference: named parameters (/controller/action/name:value) are found in $this-
>passedArgs, whereas custom route element data is found in $this->params. When you define a custom route element, you also need to specify a regular expression - this tells CakePHP how to know if the URL is correctly formed or not. Router::connect(
This simple example illustrates how to create a quick way to view models from any controller by crafting a URL that looks like /controllername/id. The URL provided to connect() specifies two route elements: :controller and :id. The :controller element is a CakePHP default route element, so the router knows how to match and identify controller names in URLs. The :id element is a custom route element, and must be further clarified by specifying a matching regular expression in the third parameter of connect(). This tells CakePHP how to recognize the ID in the URL as opposed to something else, such as an action name. Once this route has been defined, requesting /apples/5 is the same as requesting /apples/view/5. Both would call the view() method of the ApplesController. Inside the view() method, you would need to access the passed ID at $this->params['id']. One more example, and you'll be a routing pro. Router::connect( '/:controller/:year/:month/:day', array('action' => 'index', 'day' => null), array( 'year' => '[12][0-9]{3}', 'month' => '0[1-9]|1[012]', 'day' => '0[1-9]|[12][0-9]|3[01]' ) );
This is rather involved, but shows how powerful routes can really become. The URL supplied has four route elements. The first is familiar to us: it's a default route element that tells CakePHP to expect a controller name. Next, we specify some default values. Regardless of the controller, we want the index() action to be called. We set the day parameter (the fourth element in the URL) to null to flag it as being optional. Finally, we specify some regular expressions that will match years, months and days in
numerical form. Note that parenthesis (grouping) are not supported in the regular expressions. You can still specify alternates, as above, but not grouped with parenthesis. Once
defined,
this
route
will
match
/articles/2007/02/01,
/posts/2004/11/16,
and
/products/2001/05 (as defined, the day parameter is optional as it has a default), handing the requests to the index() actions of their respective controllers, with the date parameters in $this->params. 3.4.5.5 Pasando parámetros a las acciones
Asumiendo que tu action fue definida así y quieres acceder los argumentos usando $articleID en vez de $this->params['id'], tan solo agrega un array extra en el 3er parámetro de Router::connect(). // some_controller.php function view($articleID = null, $slug = null) { // some code here... } // routes.php Router::connect( // E.g. /blog/3-CakePHP_Rocks '/blog/:id-:slug', array('controller' => 'blog', 'action' => 'view'), array( // el orden es importante ya que esto va a mapear ":id" con $articleID en tu action 'pass' => array('id', 'slug'), 'id' => '[0-9]+' ) );
Y ahora, gracias a la capacidad de enrutamiento inverso podrás pasar la url como se muestra abajo y Cake sabrá como formar la URL como se definió en los routers. // view.ctp // esto devolverá un link a /blog/3-CakePHP_Rocks link('CakePHP Rocks', array( 'controller' => 'blog', 'action' => 'view', 'id' => 3, 'slug' => Inflector::slug('CakePHP Rocks') )); ?>
3.4.5.6 Prefix Routing
Muchas aplicaciones necesitan una sección administrativa donde los usuarios con privilegios puedan
hacer
cambios.
Con
frecuencia,
esto
se
hace
con
una
URL especial
como
/admin/users/edit/5. En CakePHP, el admin routing puede activarse dentro del archivo de configuración del core ajustando la ruta de administración para Routing.admin. Configure::write('Routing.admin', 'admin'); En tu controlador, será llamada cualquier acción con un prefijo admin_. Recurriendo a nuestro ejemplo de usuarios, acceder a la URL /admin/users/edit/5 debería llamar al método admin_edit de nuestro UsersController pasando 5 como primer parámetro. Puedes mapear la URL /admin a tu acción admin_index del pages controller usando la ruta. Router::connect('/admin',
array('controller'
=>
'pages',
'action'
=>
'index',
'admin' => true));
Puedes configurar el Router usado múltiples prefijos: Router::connect('/profiles/:controller/:action/*',
array('prefix'
=>
'profiles',
'profiles' => true));
Cualquier llamada a la sección Profiles buscaría el prefijo profiles_ en las llamadas a los métodos. Nuestro ejemplo tendría una URL como /profiles/users/edit/5 que llamaría al método profiles_edit en el UsersController. Es también importante recordar que usar el HTML helper para construir tus enlaces, te ayudará a mantener las llamadas a los prefijos. He aquí cómo construir este enlace usando el HTML helper: echo $html->link('Edit your profile', array('profiles' => true, 'controller' => 'users', 'action' => 'edit', 'id' => 5));
Puedes ajustar múltiples rutas con prefijos usando esta metodología para crear una estructura de URL flexible para tu aplicación.
3.4.5.7 Rutas y plugins
Las rutas a Plugins utilizan la clave plugin. Puedes crear enlaces que apunten a un plugin siempre que añadas la clave plugin al array de la url.
echo
$html->link('New
todo',
array('plugin'
=>
'todo',
'controller'
=>
'todo_items', 'action' => 'create'));
Por el contrario, si la petición activa es un plugin y quieres crear un enlace que no tiene plugin, puedes hacerlo como sigue. echo
$html->link('New
todo',
array('plugin'
=>
null,
'controller'
=>
'users',
'action' => 'profile'));
Al poner plugin => null le estás diciendo al Router que quieres crear un enlace que no forma parte de un plugin. 3.4.5.8 Extensiones de archivo
Para manejar diferentes extensiones de archivo con tus rutas, necesitas una línea extra en el archivo de configuración de rutas: Router::parseExtensions('html', 'rss');
Esto le dirá al router que retire las extensiones de archivo coincidentes y que procese entonces el resto.. Si quieres crear una url como /page/title-of-page.html podrías crear tu ruta como se explica a continuación: Router::connect(
Para crear enlaces que se mapeen a esas rutas simplemente usamos: $html->link('Link
title',
array('controller'
=>
'pages',
'action'
=>
'view',
'title' => Inflector::slug('text to slug', '-'), 'ext' => 'html'))
3.4.5.9 Custom Route classes
Custom route classes allow you to extend and change how individual routes parse requests and handle reverse routing. A route class should extend CakeRoute and implement one or both of match() and parse(). Parse is used to parse requests and match is used to handle reverse routing.
You can use a custom route class when making a route by using the routeClass option, and loading the file containing your route before trying to use it. Router::connect( '/:slug', array('controller' => 'posts', 'action' => 'view'), array('routeClass' => 'SlugRoute') );
This route would create an instance of SlugRoute and allow you to implement custom parameter handling 3.4.6 Inflexiones Propias Las convenciones de nomenclatura de CakePHP pueden ser muy buenas. Nombras la tabla de base de datos "usuarios", tu modelo "Usuario", tu controlador "UsuariosController" y todo funcionará automáticamente. La forma en que CakePHP sabe como atar unas cosas a otras es a través de las inflexiones de palabras entre formas en singular y plural. Hay ocasiones, sobre todo para usuarios de habla hispana, en que encontrarás situaciones donde el inflector de CakePHP no funcione como lo esperas. Si CakePHP no es capaz de reconocer tu Reloj o Ciudad, editar el archivo de inflexiones propias es la manera de indicarle a CakePHP que existen otros casos especiales. Este archivo se encuentra en /app/config/inflections.php. En este archivo encontrarás seis variables. Cada una de ellas te permite definir a un grado muy fino el comportamiento de inflexiones de CakePHP. Variable de inflections.php
Descripción
$pluralRules
Este arreglo contienen las expresiones regulares para pluralizar los casos especiales. Las claves del arreglo son los patrones y los valores los reemplazos.
$uninflectedPlural
Un arreglo que contiene palabras que no han de ser modificadas para obtener su plural, como la palabra gente o dinero.
$irregularPlural
Un arreglo que contiene palabras y su respectivo plural. Las claves de este arreglo contienen la forma singular y los valores la forma plural. Este arreglo debe ser utilizado para colocar palabras que no sigan las reglas definidas en $pluralRules.
$singularRules
Igual que $pluralRules, solo que contiene las reglas para singularizar palabras.
$uninflectedSingular
Igual que $uninflectedPlural, solo que este arreglo contiene las palabras que no tienen singular. Por defecto es igual que $uninflectedPlural.
Variable de inflections.php
Descripción
$irregularSingular
Igual que $irregularPlural, solo que con palabras en forma singular.
3.4.7 Haciendo Bootstrap de CakePHP Si tienes necesidades de configuración adicionales, usa el archivo de bootstrap de CakePHP que se encuentra en /app/config/bootstrap.php. Este archivo es ejecutado inmediatamente después de el bootstrap propio de CakePHP. Este archivo es ideal para un número de tareas comunes: • Definir funciones de conveniencia • Definir constantes globales • Definir rutas adicionales para modelos, controladores, vistas, plugins... Sé cuidadoso de mantener el patrón de diseño MVC cuando agregues cosas al archivo bootstrap, puede resultar tentador colocar funciones para dar formato a texto allí para luego usarlas en controladores. Resiste la tentación. Te lo agradecerás más adelante a ti mismo. Podrías considerar colocar cosas en la clase AppController. Esta clase en poder de todos los controladores de la aplicación. AppController es útil para colocar funciones que se ejecutan antes o después de eventos definidos (callbacks), que serán usados en todos tus controladores.
3.5 Controladores # Introducción Un controlador (Controller) se usa para manejar la lógica de cierta sección de su aplicación. Comúnmente, los controladores (Controllers) son usados para manejar la lógica de un solo modelo (Model). Por ejemplo, si estás construyendo un sitio de una pastelería, podrías tener un RecetasController y un IngredientesController para manejar las recetas y sus ingredientes. En CakePHP, los controladores se nombran según el modelo que manejan, y se ponen siempre en plural. El modelo Receta es manejado por el RecetasController, el modelo Producto es manejado por el ProductosController, y así sucesivamente. Los controladores de su aplicación son sub-clases de la clase AppController de CakePHP, que a su vez extiende la clase principal Controller. La clase AppController puede ser definida en /app/app_controller.php y debe contener métodos que son compartidos entre todos los controladores de su aplicación. AppController es una sub-clase de Controller que es una clase de la biblioteca estándar de Cake. Los controladores pueden tener cualquier cantidad de métodos a los que normalmente se les llama acciones. Las acciones son métodos de controladores en tu aplicación web para mostrar vistas. Una acción es un único método de un controlador. El Dispatcher de CakePHP ejecuta acciones cuando una solicitud entrante contiene en su URL el nombre de una acción del controlador. El controlador estaría ubicado en /app/controllers/recetas_controller.php con el siguiente contenido:
Para que puedas usar un controlador de manera productiva en tu propia aplicación, repasaremos algunos de los atributos y métodos provistos por los controladores de CakePHP. 3.5.1 The App Controller Como se comentó en la introducción, la clase AppController es la clase superior a todos los controladores de tu aplicación. AppController extiende la clase Controller incluida en la libreria base de CakePHP. Así, AppController es definida en /app/app_controller.php como:
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 controladpres de tu aplicación. Los Componentes (los cuales veremos después) son lo más utilizado para el código que se utiliza en la mayoría (pero no necesariamente en todos) los controladores. Cuando se aplica la herencia a los objetos, CakePHP también realiza un trabajo extra cuando existen atributos especiales en el controlador, como una lista de componentes o ayudantes utilizados por un controlador. En estos casos, los arrays del AppControler son combinados con los arrays de la clase hijo. Por favor, recuerda realizar las llamadas a los callbacks de AppController desde los controladores de tu aplicación para que todo funcione correctamente: function beforeFilter(){ parent::beforeFilter(); }
3.5.2 The Pages Controller El núcleo de CakePHP viene con un controlador por defecto llamado the Pages Controller (el Controlador de Páginas) (cake/libs/controller/pages_controller.php). La página de inicio que ves luego de la instalación, es generada utilizando este controlador. Por ejemplo: Sí creas un archivo de vista app/views/pages/about_us.ctp puedes accesarlo utilizando la url http://example.com/pages/about_us Cuando "cocinas" una aplicación utilizando la consola de CakePHP el controlador de páginas es copiado a tu carpeta app/controllers/ y puedes modificarla a tus necesidades si es
necesario. O simplemente puedes copiar el archivo page_controller.php del núcleo a tu app. 3.5.3 Atributos del Controlador Para
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.
$name Ejemplo de uso del atributo $name
class RecetasController extends AppController { var $name = 'Recetas'; } ?>
3.5.3.2 $components, $helpers y $uses
Los siguientes atributos más comunmente utilizados del controlador indican a CakePHP qué ayudantes (helpers), componentes (components), y modelos (models) utilizarás en conjunción con el controlador actual. Utilizar esos atributos hace que las clases MVC estén disponibles al controlador como variable de clase($this->ModelName, por ejemplo). Los controladores tienen acceso a su modelo primario disponible por defecto. Nuestro RecipesController tendrá disponible la clase modelo Recipe en $this->Recipe, y nuestro ProductsController también posee el modelo Product en $this->Product. Los ayudantes (Helpers) Html, Form, y Session están siempre disponibles por defecto, como lo es SessionComponent. Para aprender más sobre estas clases, no olvides leer sus respectivas secciones más adelante en este manual. Veamos cómo decirle a un controlador de CakePHP que planeas utilizar clases MVC adicionales.
Cada una de estas variables es fusionada con sus valores heredados, por lo tanto no es necesario (por ejemplo) declarar le ayudante (helper) Form, o cualquier cosa que es declarada en tu controlador App. 3.5.3.3 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). Al atributo $layout se le puede asignar el nombre de un diseño (layout) guardado en /app/views/layouts. Especificas un diseño al igualar $layout al nombre del archivo con el diseño excluyendo la extensión .ctp. Si este atributo no ha sido definido, CakePHP renderiza el diseño
por
defecto,
default.ctp.
Si
no
has
definido
un
diseño
en
/app/views/layouts/default.ctp, el diseño por defecto del núcleo de CakePHP’s será renderizado.
Usando $layout para definir un diseño alternativo
class RecipesController extends AppController { function quickSave() { $this->layout = 'ajax'; } } ?>
También puedes cambiar el título de la página (que está localizado en la barra en la parte superior de tu navegador) utilizando $pageTitle. Para que esto funcione apropiadamente, tu diseño (layout) necesita incluir la variable $title_for_layout como mínimo entre las etiquetas y en la cabecera del documento HTML.
//
Usando $pageTitle para definir el título de la página
class RecipesController extends AppController { function quickSave() { $this->pageTitle = 'Mi título del motor de búsquedas optimizado'; } } ?>
También puedes establecer el título desde la vista (view) usando $this->pageTitle (Has de incluir la parte $this->; se recomienda, ya que separa la lógica del diseño y el contenido). Para una página estática has de usar $this->pageTitle en la vista si quieres un título personalizado. Si $this->pageTitle no está establecido, se generará automáticamente un título basado en el nombre del controlador, o el nombre del fichero de la vista en el caso de una página estática. 3.5.3.4 El Atributo de Parámetros ("$params")
Los parámetros del controlador están disponibles en $this->params en tu controlador de CakePHP. Esta variables 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. 3.5.3.4.1 form
$this->params['form'] Cualquier dato POST de cualquier formulario se almacena aquí, incluyendo información también hallada en $_FILES. 3.5.3.4.2 admin
$this->params['admin'] Almacena un 1 si el diseño (layout) actual está vacío; 0 si no. 3.5.3.4.4 isAjax
$this->params['ajax'] Almacena un 1 si la petición actual es una llamada ajax; 0 si no. Esta variables sólo se establece si el componente RequestHandler es usado en el controlador.
3.5.3.4.5 controller
$this->params['controller'] Almacena el nombre del controlador actual que está sirviendo la petición. Por ejemplo, si fue pedida la URL /posts/view/1, $this->params['controller'] será igual a "posts". 3.5.3.4.6 action
$this->params['action'] 3.5.3.4.7 pass
$this->params['pass'] Almacena la cadena de consulta GET enviada con la petición actual. Por ejemplo, si fue pedida la URL /posts/view/?var1=3&var2=4, entonces $this->params['pass'] será igual a "?var1=3&var2=4". 3.5.3.4.8 url
$this->params['url'] Almacena la URL actual pedida, junto con los pares clave-valor de variables get. Por ejemplo, si se llamó a la URL /posts/view/?var1=3&var2=4, entonces $this->params['url'] debería contener: [url] => Array ( [url] => posts/view [var1] => 3 [var2] => 4 )
3.5.3.4.9 data
$this->data Usado para manejar datos POST enviados desde los formularios de FormHelper al controlador. // El helper FormHelper es usado para crear un elemento de formulario: $form->text('User.first_name');
El cual al ser renderizado, se ve parecido a:
Cuando el formulario es enviado al controlador mediante POST, los datos aparecen en this->data // El valor first_name enviado se puede encontrar aquí: $this->data['User']['first_name'];
3.5.3.4.10 prefix
$this->params['prefix'] Establecido al prefijo de enrutado. Por ejemplo, este atributo contendría la cadena "admin" durante una petición a /admin/posts/someaction. 3.5.3.4.11 named
$this->params['named'] Almacena cualquier parámetro con nombre /clave:valor/ de la cadena de petición de la URL. Por ejemplo, si se pidió la URL /posts/view/var1:3/var2:4, entonces $this>params['named'] debería contener el array: [named] => Array ( [var1] => 3 [var2] => 4 )
3.5.3.5 Otros Atributos
Aunque puedes ojear todos los detalles para todos los atributos del controlador en el API, hay otros atributos del controlador que merecen sus propias secciones en el manual. El atributo $cacheAction ayuda en el "cacheado" (caching) de vistas (views), y el atributo $paginate es usado para establecer las opciones por defecto de paginado para el controlador. Para más información sobre cómo utilizar esos atributos, écha un vistazo a sus respectivas secciones más adelante en este manual.
3.5.3.6 persistModel
Usado para crear instancias almacenadas en caché de modelos (Models) un uso de Controlador (Controller). Cuando se coloca en verdadero (true), todos los modelos relacionados con el controlador (Controller) se almacenan en caché. Esto puede incrementar el desempeño en muchos casos.
3.5.4 Métodos del Controlador Para una lista completa de los métodos del controlador y sus descripciones visita el API de CakePHP. Echa un vistazo a http://api.cakephp.org/1.2/class_controller.html. 3.5.4.1 Interactuando con Vistas 3.5.4.1.1 set
set(string $variable, mixed $valor) El método set() es la principal manera de enviar datos desde tu controlador a tu vista (view). Una vez que has utilizado set(), la variable puede ser accedida en tu vista. set('color', 'azul'); // Despueś, en las vista, puedes utilizar el dato: ?> Has seleccionado ar la tarta.
El método set() también toma una array asociativo como primer parámetro. A menudo, esto puede ser una manera rápida de asignar un conjunto de información a la vista. Las claves (keys) serán flexionadas (inflected) antes de ser asignadas a la vista ('clave_con_subrayado' se convierte en 'claveConSubrayado', etc.): 'pink', 'type' => 'sugar', 'base_price' => 23.95 ); // hace que $color, $type, y $basePrice // estén disponibles a la vista: $this->set($data); ?>
El método render() es llamado automáticamente al final de cada acción de controlador pedida. Este método lleva a cabo toda la lógica de la vista (usando los datos que has proporcionado con el método set()), coloca la vista (view) dentro de su diseño (layout) y lo sirve de vuelta al usuario final. El fichero de vista por defecto utilizado por render es determinado por convenio. Por ejemplo, si se pide la acción search() del controlador RecipesController, será renderizado el fichero de vista en /app/views/recipes/search.ctp. class RecipesController extends AppController { function search() { // Render the view in /views/recipes/search.ctp $this->render(); } ... }
A pesar de que CakePHP lo llamará automáticamente (a menos que hayas establecido $this>autoRender a falso) después de cada lógica de las acciones, puedes utilizar render para especificar un fichero de vista alternativo indicando un nombre de acción en el controlador usando $action. Si $action comienza por '/' se asume que es un fichero de vista o elemento relativo a la carpeta /app/views. Esto permite el renderizado inmediato de elementos, algo muy útil en las llamadas ajax. // Render the element in /views/elements/ajaxreturn.ctp $this->render('/elements/ajaxreturn');
También puedes especificar un fichero de vista alternativo usando el tercer parámetro, $file. Cuando estés usando $file, no olvides utilizar unas pocas de las constantes globales de CakePHP (como VIEWS). El parámetro $layout te permite especificar el diseño en el que la vista es renderizada. 3.5.4.2 Control de Flujo 3.5.4.2.1 redirect
redirect(string $url, integer $status, boolean $exit) El método de control de flujo que más frecuentemente utilizarás es redirect(). Este método
toma su primer parámetro en forma de URL relativa de CakePHP. Por ejemplo, cuando un usuario ha hecho un pedido satisfactoriamente, probablemente desearás redirigirle a una ventana de recibo. function realizarPedidos() { // La lógina para finalizar el pedido va aquí if($satisfactorio) { $this->redirect(array('controller' => 'pedidos', 'action' => 'gracias')); } else { $this->redirect(array('controller' => 'pedidos', 'action' => 'confirmar')); } }
El segundo parámetro de redirect() te permite definir un código de estado HTTP que acompañe la redirección. Puede que desees usar 301 (movido permanentemente) o 303 (mirar otro), dependiendo de la naturaleza de la redirección. El metodo ejecutará exit() tras la redirección a menos que establezcas el tercer parámetro a false. 3.5.4.2.2 flash
flash(string $message, string $url, integer $pause) Igualmente, el método flash() es usado para redirigir un usuario a una nueva página tras una operación. El método flash() es diferente en cuanto que muestra un mensaje antes de enviar al usuario a otra URL. El primer parámetro debería contener el mensaje a mostrar, y el segundo parámetro es una URL relativa a CakePHP. CakePHP mostrará el mensaje en $message durante el número de segundos en $pause antes de reenviar al usuario a otra página. Para mensajes flash en la página, cerciónate de echarle un ojo al método setFlash() del componente SessionComponent. 3.5.4.3 Retrollamadas ("Callbacks")
Los controladores de CakePHP vienen con retrollamas (callbacks) empotradas que puedes usar para insertar lógica justo antes o después de que las acciones del controlador sean llevadas a cabo. beforeFilter() Esta función se ejecuta antes de toda acción en el controlador. Es un lugar práctico para
comprobar una sesión activa o inspeccionar los permisos del usuario. beforeRender() Llamada tras la lógica de acción del controlador, pero antes de que la vista es renderizada. Este callback no es utilizado a menudo, pero puedes necesitarlo si estás llamando a render() manualmente antes del final de una acción dada. afterFilter() Llamada tras toda acción del controlador. afterRender() Llamada tras haber sido renderizada una acción.
CakePHP también soporta callbacks relacionados con el scaffolding. _beforeScaffold($metodo) $metodo es el nombre del método llamado, por ejemplo: index, edit, etc. _afterScaffoldSave($metodo) $metodo es el nombre del método llamado tras edit o update. _afterScaffoldSaveError($metodo) $metodo es el nombre del método llamado tras edit o update. _scaffoldError($metodo) $metodo es el nombre del método llamado, por ejemplo: index, edit, etc. 3.5.4.4 Otros Métodos Útiles 3.5.4.4.1 constructClasses
Este método carga los modelos requeridos por el controlador. El proceso de carga es realizado por CakePHP normalmente, pero hay que tener a mano este método cuando se accede a los controladores desde una perspectiva diferente. Si necesitas CakePHP en un script de línea de comando o algún otro uso externo, constructClasses() será útil.
3.5.4.4.2 referer
Devuelve la URL remitente de la petición actual. Ver referer en la wikipedia para más información. 3.5.4.4.3 disableCache
3.5.4.4.4 postConditions
postConditions(array $datos, mixed $operadores, string $bool, boolean $exclusivo) Usa este método para convertir un conjunto de datos de modelo recibidor mediante POST (de inputs compatibles con HtmlHelper) en un conjunto de condiciones de búsqueda para un modelo. Esta función ofrece un atajo rápido para la construcción de la lógica de búqueda. Por ejemplo, un usuario administrativo puede querer buscar pedidos para saber qué elementos necesitan ser enviados. Puedes utilizar los ayudantes FormHelper y HtmlHelper para crear un formulario rápido basado en el modelo Pedido. Entonces, una acción de un controlador puede usar los datos recibidos desde ese formulario para encauzar las condiciones de búsqueda: function index() { $o = $this->Pedidos->findAll($this->postConditions($this->data)); $this->set('pedidos', $o); }
Si $this->data[‘Pedido’][‘destino’] es igual a “Old Towne Bakery”, postConditions convierte esa condición en un array compatible para ser usado en un método Model->findAll(). En este caso, array(“pedido.destino” => “Old Towne Bakery”). Si deseas usar un operador SQL distinto entre términos, proporciónalos usando el segundo parámetro. /* contenidos de $this->data array( 'Pedido' => array( 'num_items' => '4', 'referrer' => 'Ye Olde' ) ) */ //Obtengamos los pedidos que tiene como mínimo 4 elementos y contienen ‘Ye Olde’ $o = $this->Pedido->findAll($this->postConditions( $this->data, array('>=', 'LIKE') ));
La clave al especificar operadores es el orden de las columnas en el array $this->data. Dado que num_items está de primero, el operador >= es el que se le aplica. El tercer parámetro te permite decirle a CakePHP qué operador booleano SQL usar entre condiciones de búsqueda. Una cadena de carateres como ‘AND’, ‘OR’ y ‘XOR’ son valores válidos. Finalmente, si el último parámetro se establece a true, y el parámetro $operadores es un array, los campos no incluidos en $operadores no se incluirán en las condiciones devueltas. 3.5.4.4.5 paginate
Este método es usado para paginar resultados cargados por tus modelos. Puedes especificar tamaño de páginas, condiciones de búsqueda del modelo y más. Mira la sección paginación para más detalles sobre cómo usar paginate. 3.5.4.4.6 requestAction
requestAction(string $url, array $opciones) Esta función llama a una acción de un controlador de cualquier lugar y devuelve los datos de la acción.
La
dirección
$url
pasada
es
una
URL
relativa
de
CakePHP
(/nombrecontrolador/nombreaccion/parametros). Para pasar datos extras a la acción del controladores receptor, añádelos al array $options. Puedes usar requestAction() para obtener una vista completamente renderizada pasando 'return' en las opciones: requestAction($url, array('return')); Si se utiliza sin caché, requestAction puede llevar a un pobre rendimiento. Es ráramente apropiado usarlo en un controlador o modelo. Es mejor usar requestAction junto con elementos en caché, como una manera de obtener datos para un elemento antes de renderizar. Usemos el ejemplo de poner un elemento "últimos comentarios" en el diseño (layout). Primero necesitamos crear una función en un controlador que devolverá los datos. // controllers/comments_controller.php class CommentsController extends AppController { function latest() { return $this->Comment->find('all', array( 'order' => 'Comment.created DESC', 'limit' => 10) ); }
}
Si ahora creamos un elemento simple para llamar a esa función: // views/elements/latest_comments.ctp $comments = $this->requestAction('/comments/latest'); foreach($comments as $comment) { echo $comment['Comment']['title']; }
Podemos colocar esos elementos en cualquier sitio para obtener la salida usando: echo $this->element('latest_comments');
Escrito de esta manera, siempre que el elemento sea renderizado, se realizará una petición al controlador para obtener los datos, los datos serán procesados y devueltos. De todos modos, de acuerdo con el aviso anterior, es mejor utilizar caché de elementos para prevenir procesamiento innecesario. Modificando la llamada a element para que se vea así: echo $this->element('latest_comments', array('cache'=>'+1 hour'));
La llamada a requestAction no se realizará mientras que la el archivo de la vista del elemento en cache exista y sea válido. Además, requestAction ahora toma urls con estilo cake basadas en arrays: echo $this->requestAction( array( 'controller' => 'articles', 'action' => 'featured' ), array('return') );
Esto permite a la llamada a requestAction evitar el uso de Router::url lo que puede incrementar el rendimiento. Las urls basadas en arrays son las mismas que las que HtmlHelper:link usa, con una diferencia. Si estás usando parámetros con nombre en tu url, entonces el array de url debe envolver los parámetros con nombre en la clave 'named'. Esto es porque requestAction sólo combina los argumentos nombrados del array en el array de miembros de Controller::params y no coloca los argumentos con nombre en la clave 'named'. echo $this->requestAction('/articles/featured/limit:3');
A diferencia de otros lugares donde las urls de arrays son análogas a urls de cadenas, requestAction las trata de manera diferente. Cuando utilices una url de array junto con requestAction() has de especificar todos los parámetros que necesitarás en la acción pedida. Esto incluye parámetros como $this->data y $this->params['form'] 3.5.4.4.7 loadModel
loadModel(string $modelClass, mixed $id) La función loadModel es útil cuando se necesita usar un modelo que no es propiamente el modelo por defecto del controlador o uno de sus modelos asociados. $this->loadModel('Article'); $recentArticles
3.6 Componentes # Introducción Los componentes son paquetes de lógica que son compartidos entre los controladores. Si tiene ganas de copiar y pegar código de un controlador a otro, debería antes considerar agrupar algunas funcionalidades en un componente. CakePHP incluye un conjunto fantástico 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) Cada uno de estos componentes del núcleo (Core) son detallados en su propio capitulo. Por el momento, veremos como crear sus propios componentes. Con esto ayudará a mantener el código de los controladores limpio y le será mas sencillo reusar código entre proyectos. 3.6.1 Configuración de componentes. Muchos de los componentes básicos requieren ser configurados. Algunos ejemplos de componentes que requieren ser configurados son: Auth, Cookie e Email. Toda la configuración de estos componentes y los componentes en general se hacen en el método del controlador beforeFilter(). function beforeFilter() { $this->Auth->authorize = 'controller'; $this->Auth->loginAction = array('controller' => 'users', 'action' => 'login'); }
$this->Cookie->name = 'CookieMonster';
El código anterior sería un ejemplo de configuración de las variables de componente del controlador beforeFilter()
3.6.2 Creando Componentes a medida Supongamos que nuestra aplicación online necesita efectuar una compleja operación matemática en muchas partes de la aplicación. Creariamos un componente que albergara esa lógica compartida para poder ser usada en diferentes controladores El primer paso es crear una nueva clase y fichero de componente. Crea el fichero en /app/controllers/components/math.php. La estructura básica para el componente quedaría así.
3.6.2.1 Añadiendo Componentes a tus Controladores
Una vez finalizado nuestro componente, podemos usarlo en los controladores de la aplicación añadiendo su nombre (excepto la parte "Component" al array $components del controlador. Automáticamente, el controlador recibirá un nuevo atributo con un nombre a partir del nombre del componente, a través del cual podremos acceder a una instancia del mismo: /* Hace el nuevo componente accesible en $this->Math, al igual que el standard $this->Session */ var $components = array('Math', 'Session');
Los componentes declarados en AppController serán combinados con los de tus otros controladores, así que no hay necesidad de redeclarar el mismo componente dos veces. Cuando se incluyen Componentes a un Controlador tambien puedes declarar un conjunto de parámetros que serán pasados al método intialize() de los Componentes. Estos parámetros pueden ser manejados por el Componente. var $components = array( 'Math' => array( 'precision' => 2, 'randomGenerator' => 'srand' ), 'Session', 'Auth' );
Este código pasaría el array conteniendo precision y randomGenerator al método intialize() de
MathComponent como segundo parámetro. Por ahora, esta sintaxis no está implementada por ninguno de los Componentes Core. 3.6.2.2 Acceso a clases MVC dentro de componentes
Para acceder a la instancia del controlador desde tu recien creado componente, necesitarás implementar el método initialize() o el startup(). Estos métodos especiales llevan una referencia al controlador como primer parámetro y son llamados automáticamente. El método initialize() es llamado antes del método beforeFilter(), y el método startup() después del método beforeFilter. Si por algún motivo no deseas que el método startup() sea llamado cuando el controlador está inicializando cosas, dale el valor true a la variable $disableStartup. Si deseas insertar algún código de lógica antes de que el controlador beforeFilter() sea llamado, necesitarás usar el método initialize() del componente. controller =& $controller; } //llamado tras Controller::beforeFilter() function startup(&$controller) { }
} ?>
function redirectSomewhere($value) { // ulizando un método de controlador $this->controller->redirect($value); }
También podrias querer utilizar otros componentes dentro del componente a medida. Para ello, simplemente crea una variable de clase $components (tal como lo harías en un controlador ) como un array que contenga los nombres de los componentes que quieres utilizar. Math->doComplexOperation(1, 2); $this->Session->write('stuff', $result); }
} ?>
No es muy recomendable acceder o usar un modelo en un componente, pero si tras sopesar las posibilidades eso es lo que quieres hacer, tendrás que instanciar tu clase modelo y usarla manualmente. Aquí tienes un ejemplo: find('count'); return ($amount1 + $amount2) / $totalUsers; } } ?>
3.6.2.3 Usando Componentes en tu Componente
A veces uno de tus componentes puede depender de otro. Si las funcionalidades que estos componentes proveen no están relacionados, excepto por su dependencia el uno del otro, entonces no querrás ponerlos dentro de un solo componente. En cambio puedes hacer que tu componente sea un "Padre" e indicarle con el array $components la lista de sus "Hijos". Los componentes padres se cargan antes que sus componentes hijos, y cada componente hijo tiene acceso a su padre. Declaración del padre: Hijo->foo(); } function bar() { // ... } }
Declaración del hijo: Padre->bar(); } function foo() { // ... } }
3.7 Modelos 3.7.1 La Comprensión de Modelos Un Modelo representa tu modelo de datos y, en programación orientada a objetos, es un objeto que representa una "cosa", como un coche, una persona, o una casa. Un blog, por ejemplo, puede contener varios artículos (posts) y cada artículo puede contener varios comentarios. Los objetos Blog, Artículo (Post) y Comentario son ejemplos de modelos, cada uno asociado con el otro. Aquí presentamos un ejemplo simple de definición de modelo en CakePHP:
Simplemente con esta declaración, se le otorga al modelo Ingredient toda la funcionalidad que necesitarás para crear consultas junto con guardado y borrado de datos. Estos métodos mágicos provienen del modelo de herencia de CakePHP. El modelo Ingredient extiende el modelo de aplicaciónm AppModel, el cual extiende la clase Model, interna de CakePHP. Es esta clase Model interna la que otorga la funcionalidad a nuestro modelo pesonalizado, Ingredient. La clase intermedia AppModel está vacía y reside por defecto dentro de la carpeta /cake/. Redefinir AppModel te permitirá definir funcionalidad que debería estar disponible a todos los modelos dentro de tu aplicación. Para hacer eso, necesitas crear tu propio fichero app_model.php que reside en la raíz de la carpeta /app/. Creando un proyecto utilizando Bake, Bake generará automáticamente este fichero por ti. Crea tu fichero modelo en PHP en el directorio /app/models/ o en un subdirectorio de /app/models/. CakePHP lo encontrará en cualquier lugar en el directorio. Por convención, debería tener el mismo nombre que la clase; para este ejemplo, ingredient.php. CakePHP creará dinamicamente un objeto modelo por ti si no puede encontrar un archivo correspondiente en /app/models. Esto también significa que si, accidentalmente, nombras tu archivo de manera errónea (p.ej. Ingredient.php o ingredients.php) CakePHP utilizará AppModel en lugar de tu archivo de modelo con nombre incorrecto. Si estás tratando de utilizar un método de un modelo personalizado y estás obteniendo errores SQL, normalmente es porque CakePHP
no puede encontrar tu modelo. Ver también Comportamientos para más información sobre cómo aplicar lógica similar para múltiples modelos. La propiedad $name es necesaria para PHP4 pero opcional para PHP5. Con tu modelo definido, este puede ser accedido dentro de tu Controlador. CakePHP automaticamente hará que se pueda acceder al modelo cuando su nombre concuerde con el del controloador. Por ejemplo, un controlador llamado IngredientsController automaticamente inicializará el modelo Ingredient y será accesible por el controlador mediante $this->Ingredient. Ingredient->find('all'); $this->set('ingredients', $ingredients); } } ?>
Están disponibles los modelos asociados a través del modelo principal. En el siguiente ejemplo, el modelo Receta (Recipe) tiene una asociación con el modelo Ingrediente (Ingredient). $this->Recipe->Ingredient->find('all');
Como podrás ver en Controllers, puedes atar múltiples modelos al controlador y acceder directamente desde él. En el siguiente ejemplo, ambos modelos Recipe y User son accesibles desde el controlador actual. Recipe->find('all'); $this->User->find('all'); } } ?>
Si no has añadido el modelo a través de la propiedad $uses entonces necesitarás importar el modelo manualmente e instanciarlo dentro de la acción.
Recipe->find('all'); App::import('Model', 'User'); $user = new User(); $user->find('all'); } ?>
}
3.7.2 Creando Tablas de Bases de Datos A pesar de que CakePHP puede tener orígenes de datos (datasources) que no son manejadas por sistemas de gestión de bases de datos, la mayoría de las veces lo son. CakePHP está diseñado para ser agnóstico y funcionará con MySQL, MSSQL, Oracle, PostgreSQL y otros. Puedes crear tus tablas de base de datos como lo harías normalmente. Cuando creas tus clases del Modelo, automáticamente se mapean a las tablas que has creado. Los nombres de las tablas son, por convención, en minúsculas y en plural, con las palabras de los nombres de tablas de varias palabras separadas por guiones de subrayado (_). Por ejemplo, un nombre de Modelo de Ingredient espera el nombre de tabla ingredients. un nombre de Modelo de EventRegistration debería esperar un nombre de tabla event_registrations. CakePHP inspeccionará tus tablas para determinar el tipo de dato de cada campo y utiliza esta información apra automatizar varias características como la salida de campos de formulario en la vista. Los nombres de los campos son, por convención, en minúscula y separados por guiones de subrayado (_). Las asociaciones del modelo con el nombre de la tabla pueden ser anuladas con el atributo useTable del modelo, explicado más adelante en este capítulo. En el resto de esta sección verás cómo CakePHP "mapea" tipos de campos de bases de datos en tipos de datos PHP y cómo CakePHP puede automatizar tareas basandose en cómo tus campos están definidos. CakePHP viene preparado para el inglés. En caso de desear flexiones para el español es necesario modificar eL fichero cake/libs/inflector.php
3.7.2.1 Asociaciones de Tipo de Dato por Base de Datos
Todo RDMS define tipos de datos de manera ligeramente diferente. Dentro de la clase de origen de datos (o "fuente de datos", datasource) para cada sistema de base de datos, CakePHP "mapea" dichos tipos a algo que reconoce y crea una interfaz unificada sin importar en qué sistema de bases de datos necesitas ejecutarlo. El siguiente desglose describe cómo está "mapeado" cada uno. 3.7.2.1.1 MySQL
Tipo CakePHP Propiedades del Campo primary_key NOT NULL auto_increment string varchar(255) text text integer int(11) float float datetime datetime timestamp datetime time time date date binary blob boolean tinyint(1) Un campo de tipo tinyint(1) es considerado booleano por CakePHP. 3.7.2.1.2 MySQLi
Tipo CakePHP primary_key string text integer float datetime timestamp time date binary boolean
Propiedades del Campo DEFAULT NULL auto_increment varchar(255) text int(11) float datetime datetime time date blob tinyint(1)
3.7.2.1.3 ADOdb
Tipo CakePHP primary_key string text integer float datetime timestamp time date binary boolean
Propiedades del Campo R(11) C(255) X I(11) N T (Y-m-d H:i:s) T (Y-m-d H:i:s) T (H:i:s) T (Y-m-d) B L(1)
3.7.2.1.4 DB2
Tipo CakePHP primary_key string text integer float datetime timestamp time date binary boolean
Propiedades del Campo not null generated by default as identity (start with 1, increment by 1) varchar(255) clob integer(10) double timestamp (Y-m-d-H.i.s) timestamp (Y-m-d-H.i.s) time (H.i.s) date (Y-m-d) blob smallint(1)
3.7.2.1.5 Firebird/Interbase
Tipo CakePHP primary_key string text integer float
Propiedades del Campo IDENTITY (1, 1) NOT NULL varchar(255) BLOB SUB_TYPE 1 SEGMENT SIZE 100 CHARACTER SET NONE integer float
datetime timestamp time date binary boolean
timestamp (d.m.Y H:i:s) timestamp (d.m.Y H:i:s) time (H:i:s) date (d.m.Y) blob smallint
3.7.2.1.6 MS SQL
Tipo CakePHP primary_key string text integer float datetime timestamp time date binary boolean
Propiedades del Campo IDENTITY (1, 1) NOT NULL varchar(255) text int numeric datetime (Y-m-d H:i:s) timestamp (Y-m-d H:i:s) datetime (H:i:s) datetime (Y-m-d) image bit
3.7.2.1.7 Oracle
Tipo CakePHP primary_key string text integer float datetime timestamp time date binary boolean number inet
Propiedades del Campo number NOT NULL varchar2(255) varchar2 numeric float date (Y-m-d H:i:s) date (Y-m-d H:i:s) date (H:i:s) date (Y-m-d) bytea boolean numeric inet
3.7.2.1.8 PostgreSQL
Tipo CakePHP primary_key string text integer float datetime timestamp time date binary boolean number inet
Propiedades del Campo serial NOT NULL varchar(255) text integer float timestamp (Y-m-d H:i:s) timestamp (Y-m-d H:i:s) time (H:i:s) date (Y-m-d) bytea boolean numeric inet
3.7.2.1.9 SQLite
Tipo CakePHP primary_key string text integer float datetime timestamp time date binary boolean
Propiedades del Campo integer primary key varchar(255) text integer float datetime (Y-m-d H:i:s) timestamp (Y-m-d H:i:s) time (H:i:s) date (Y-m-d) blob boolean
3.7.2.1.10 Sybase
Tipo CakePHP primary_key string text integer float datetime timestamp
Propiedades del Campo numeric(9,0) IDENTITY PRIMARY KEY varchar(255) text int(11) float datetime (Y-m-d H:i:s) timestamp (Y-m-d H:i:s)
time date binary boolean
datetime (H:i:s) datetime (Y-m-d) image bit
3.7.2.2 Titulos
Un objeto, en sentido físico, a menudo tiene un nombre o un título con el que referirse. Una persona tiene un nombre como Juan o Ambrosio o Colega. Una entrada de un blog tiene un título. Una categoría tiene un nombre. Al especificar el campo title (título) o name (nombre), CakePHP automáticamente utilizará esta etiqueta en varias circunstancias: • Scaffolding — títulos de páginas, etiquetas de fieldset • Listas - normalmente utilizado para los desplegables
