Características avanzadas

De KumbiaPHP Framework Wiki
Saltar a: navegación, buscar

¡Parámetros con Nombre![editar]

¡Wow!, Algo muy importante en Kumbia es la aplicación de los parámetros con nombre, ésta es una característica muy importante usada a lo largo del framework y que es muy útil. Ésta permite enviar los parámetros en un orden independiente sin que esto impida que funcione bien. Los parámetros con nombre son una característica utilizada en otros lenguajes como Ruby en donde son ampliamente usados. La implementación nos permite de forma sencilla enviar los valores de los parámetros de todo tipo de funciones sin preocuparnos por el orden correcto de estos.

El uso es 'nombre: valor', es muy importante mantener el orden sintáctico para que funcionen bien: No espacios delante del nombre del parámetro y éste no debe contener espacios. Los dos puntos ‘:’ deben ir a continuación del nombre del parámetro, sin espacios entre éste y el nombre. Un espacio obligatorio después de los ‘:’

El valor puede ser cualquier valor

Obtener valores en una aplicación Kumbia[editar]

Las URLs de Kumbia están caracterizadas por tener varias partes cada una de ellas con una función conocida. Para obtener desde un controlador los valores que vienen en la URL podemos usar algunas propiedades útiles en el controlador:

Ejemplo1:

http://www.kumbiaphp.com/aplicacion/productos/buscar/12

El sitio es: kumbiaphp.com La aplicación es: aplicacion El controlador es: productos La acción es: buscar El valor para id es: 12

Nuestro controlador aplicación/productos_controller.php luce así:

  1. <?php
  2.     class ProductosController extends ApplicactionController {
  3.         public function buscar($id){
  4.             /* */
  5.         }
  6.     }
  7. ?>

Dentro del método buscar podemos obtener el valor de id osea 12 en nuestro ejemplo colocando un parámetro al controlador $id podemos recoger este valor y utilizarlo internamente.

Otras formas de hacer esto es utilizar los métodos post, get o request así:

  1. <?php
  2.     public function buscar(){
  3.         $id = $this->request("id");
  4.         // o también
  5.         $id = $this->id;
  6.     }
  7. ?>

¿Cómo saber el nombre del controlador actual?

  1. public function buscar(){
  2.           $controlador = $this->controller_name;
  3. }

¿Cómo saber el nombre de la acción actual?

  1. public function buscar(){
  2.           $controlador = $this->action_name;
  3. }

Ahora veamos el siguiente ejemplo:

http://www.kumbia.org/aplicacion/registro/buscar_fecha/2006/12/01

El sitio es: kumbia.org La aplicación es: aplicacion El controlador es: registro La acción es: buscar_fecha

La mejor forma de recoger estos valores es de la siguiente forma:

  1. <?php
  2.   class RegistroController extends ApplicactionController {
  3.       public function buscar_fecha($anio, $mes, $dia){
  4.           /* */
  5.       }
  6.   }
  7. ?>

Como vemos los valores adicionales en la URL son automáticamente agregados como parámetros en la acción del controlador.

¿Que pasa con id en este ejemplo? $id es el valor del primer parámetro siempre así que si nos referimos a éste, encontramos que tiene el valor 2006.

¿Cómo puedo obtener los parámetros extra si no sé cuántos son? Aquí usamos la propiedad del controlador $parameters que contiene estos valores así que el ejemplo podríamos reescribirlo así:

  1. <?php
  2.   class RegistroController extends ApplicactionController {
  3.       public function buscar_fecha(){
  4.           $anio = $this->parameters[0]; 
  5.           $mes = $this->parameters[1];
  6.           $dia = $this->parameters[2];
  7.            /* ... */
  8.       }
  9.   }
  10. ?>

Por último podemos ver todos los parámetros que vienen en una url de Kumbia usando la propiedad del controlador $this->all_parameters. Una salida de esta variable en el ejemplo anterior con print_r muestra:

  1. Array
  2. (
  3.     [0] => registro
  4.     [1] => buscar_fecha
  5.     [2] => 2006
  6.     [3] => 12
  7.     [4] => 01
  8. )

Uso de Paquetes (Namespaces)[editar]

PHP5 no soporta el uso de paquetes, lo cual es una gran desventaja ya que no podemos apoyarnos en estos para agrupar clases buscando cierto tipo de independencia para administrarlas a nivel lógico.

Kumbia permite emular el concepto de paquetes (a nivel físico) muy conocido en Java e integrarlo a nuestras aplicaciones.

Los paquetes son grupos relacionados de clases e interfaces y proporcionan un mecanismo conveniente para manejar un gran juego de clases e interfaces y evitar los conflictos de nombres.

Los paquetes permiten hacer una organización de clases mediante directorios.

En el siguiente ejemplo tenemos una serie de archivos con clases y que contienen cierta funcionalidad en la cual no vamos a profundizar y llamaremos clases de usuario.

Este directorio está ubicado en la raíz del framework y contiene subdirectorios con clases que deben integrarse a nuestra aplicación.

Kumbia proporciona un método para incluir los archivos en forma de paquetes de esta forma:

1.kumbia::import('app.lib.*');

Así incluiríamos todos los archivos php que están en app/lib. La función también puede hacer una importación recursiva. Por ejemplo:

1.kumbia::import('app.com.*');

Importaría el contenido de com y sus sub-directorios.

1.kumbia::import('app.com.os.*');

y así solo los de app/com/os/

Programación modular[editar]

Kumbia en la versión 0.5 incorpora una nueva forma de programar que hace nuestras aplicaciones mas profesionales y mantenibles en el tiempo y es que ahora puedes agrupar controladores por módulos con la intención de minimizar los niveles de entropía que se puede generar al momento de desarrollar nuestros sistemas.

Entendamos esta nueva forma de programar en el kumbia mediante un ejemplo sencillo, por lo general todos los sistemas cuentan con un modulo de usuario, donde este se debe encargar de realizar las tareas relacionado con el usuario podemos nombrar algunas de estas tareas:

Autenticar Usuarios. Registrar Usuarios. Listar Usuarios. Eliminar Usuarios. Etc.

Estas pueden ser las funcionalidades mas básicas que pueden existir, de la forma como se venia haciendo por lo general se creaba un controller apps/default/controllers/usuarios_controller.php y este se encargaba de toda esta gestión, esta practica hace que tengamos controladores muy largo y difícil de entender.

Ahora si hacemos un cambio tendremos nuestro codigo muchas mas ordenado y es lo que propone Kumbia con la Programación Modular, donde en vez de reposar todas las acciones en el mismo controlador tener un directorio apps/default/controllers/Usuarios/ y en este se encuentren controladores para cada accion de la que encarga el modulo Usuarios, por ejemplo se podria tener un controlador autenticar_controller.php y este tal como su nombre indica se encargaria de autenticar un usuario otra ventaja que se nos presenta en este momento es que con solo ver el nombre del archivo podemos identicar de que se encarga.

Las URL's se siguen comportando de la misma manera, solo que tendremos un nivel adicional. http://localhost/0.5/Usuarios/autenticar/index localhost → Dominio 0.5 → Nombre de la aplicación. Usuarios → Modulo autenticar → controller index → acción

En el directorio views debemos agrupar nuestras vistas de la misma forma, siguiendo el ejemplo deberiamos tener una estructura como la siguiente.

views/Usuarios/autenticar/

views → Directorio de las Vistas Usuarios → Nombre del Modulo autenticar → Todas lsa Vistas del controller autenticar