Kurmix es un Framework donde las funcionalidades y la estructura son muy similares de un lenguaje de programación a otro. Kurmix permite crear aplicaciones web de forma rápida y sencilla, es muy fácil aprender a usarlo.

Se pueden realizar aplicaciones web monolíticas con la versión MVC y también microservicios con la versión Back.

Aprender kurmix es bastante sencillo

Instalación

Aprender kurmix es bastante sencillo

Hola Mundo

Una vez instalado, podemos ejecutar la url: http://localhost:80/kurmix/

Si abrimos el fichero que se ubica en app/controller/IndexController.ext (donde .ext es la extención dependiendo del lenguaje.) observamos el codigo:

class IndexController extends Controller
{ 
	function index(){
		$this->write('Hola Mundo..!');
	}
}

from _libs.kurmix.Controller import *
class IndexController(Controller):
   def index(this):
      this.write("Hola mundo..! ")

import kurmix.Controller;
public class IndexController extends Controller
{ 
	public void index(){
		this.write("Hola Mundo..!");
	}
}

Nuestro simple y facil "Hola mundo" lo ha generado la accion index desde el controlador index, entenderemos el funcionamiento siguiendo el manual.

Ejercicio operaciones

Vamos a resolver el siguiente ejercicio: Se necesita crear una acción donde se envie dos numeros y nos retorne el la suma de estos.

Solución: Creamos un nuevo controlador al que llamamos OperadorController y dentro de ella creamos la acción suma.

class OperadorController extends Controller
{ 
	function suma($a,$b){
		$c = $a+$b;
		$this->write($c);
	}
}

Como podemos notar, desde la url llamamos al controlador operador y la acción suma y además como parámetros 8 y 4 y este realiza la suma y retorna la suma de ambos.

En la siguiente sección vamos a entender como funciona las url en kurmix.

Las urls de kurmix tienen la siguiente nomenclatura:

http://localhost:8081/ kurmix ?k= operaciones/ sumar/ 12/ 4

Como regla general se tiene:

http://dominio:puerto/proyecto/?k=controlador/accion/parametro1/parametro2/.../parametroN

En el ejemplo del 'Hola Mundo' notamos que la url invocada http://localhost:8081/kurmix no llama a una acción ni a un controlador, esto es por que kurmix considera que si no se envia el controlador y/o la acción, se esta llamando al index.

Se puede considera las sigueintes equivalencias:

http://localhost:8081/kurmix equivale a http://localhost:8081/kurmix/?k=index/index

http://localhost:8081/kurmix/?k=operador equivale a http://localhost:8081/kurmix/?k=operador/index

Kurmix permite el uso de reescrituras de url, donde se puede ocultar la variable ?k= quedando de la forma:

http://localhost:8081/kurmix/operaciones/sumar/12/4

Las urls de kurmix siempre tendran la siguiente nomenclatura:

libs/
  └── kurmix/
  └── util/
      ├── index.html
app/
  └── _config/
  └── controller/
  └── model/
  └── view/
      │   ├── _templates/
      │   ├── _partials/
      │   ├── index/
      ├── apps/
      ├── docs/

El controlador es la capa que contiene las acciones donde se ejecutarán las peticiones, estos deben heredar de la clase Controller y se deben crear dentro del paquete/carpeta controller.

class EjemploController extends Controller
{ 

}

La acción

La acción es un método de la clase controlador, es decir es la función que se ejecuta al invocarlo desde la url, en un microservicio estas vienen a ser los endpoints.

Preferentemente se deben utilizar palabras minúsculas para el nombre de la acción, existen palabra reservadas que no pueden ser utilizadas, y son las siguientes:

* Estas dos últimas (view y template) son reservadas solo para la version MVC.

Dependiento del lenguaje a usar, Kurmix permite uso de decoradores o pseudodecoradores para definir el tipo de metodo a usar.

class IndexController extends Controller
{ 
	/* @Get */
	function index(){
		$this->write('Hola Mundo..!');
	}
}

Como se muestra en la linea 3, al llamar a la acción solo permitira el método GET, Si se intenta llamar con otro método, como en el ejemplo con POST, notamos que nos retorna un error.

Si no se utilizar el decorador se podra invocar la acción con cualquier método.

Los decoradores que se pueden utilizar son los siguientes:

Estos decoradores tambien permiten el renombrar las acciones con un alias, con la siguiente notación:

class IndexController extends Controller
{ 
	/* @Get('hola-mundo') */
	function index(){
		$this->write('Hola Mundo..!');
	}
}

Se debe tener en cuenta que no se debe usar caracteres especiales, tampoco espacios, ni los caracteres '/' o '#'.

Parámetros de una acción

Como se vio en el ejercio de operaciones, los parámetros enviados en la url lo recibe directamente la acción.

class OperadorController extends Controller
{ 
	function suma($a,$b){
		$c = $a+$b;
		$this->write($c);
	}
}

Vamos a crear una nueva acción en controlador operador llamado saludo, donde se ingrese el nombre de una persona y retorne un saludo.

class OperadorController extends Controller
{ 
	function saludo($nombre){
		$texto = 'Hola '.$nombre;
		$this->write($texto);
	}
}

El método body

Algunas veces es necesario enviar mayor cantidad de información desde un cuerpo, esta forma es muy utilizada en el uso de fomularios y apis. Para recuperar la informacion del body, se debe utilizar la funcion body()

class OperadorController extends Controller
{ 
	function saludo(){
		$data = $this->body();
		$texto = 'Hola '.$data['nombre'];
		$this->write($texto);
	}
}

Observe que en la linea 4 se invoca al metodo $this->body() quien retorna la información en un objeto o array dependiendo del lenguaje utilizado.

El método write

Anteriormente ya utilizamos la función write() para imprimir textos, pero esta función tiene otros usos.

Con el uso de write, tambien se puede imprimir código html, por ejemplo:

class OperadorController extends Controller
{ 
   function saludo(){
      $html = '<div style="color:red">Hola Luis</div>';
      $this->write($html);
   }
}

Para el usos de apis, es usual imprimir json, write permite la conversion enviando un objeto o array dependiendo del lenguaje utilizado.

class OperadorController extends Controller
{ 
	function saludo(){
		$x['nombre'] = 'Luis';
		$x['apellido'] = 'Perez';
		$this->write($x);
	}
}

Tener en cuenta que la respuesta es de tipo application/json.

Write tambien permite el usos de status de respuesta, muy util para uso de apis. Por ejemplo:

class OperadorController extends Controller
{ 
	function saludo(){
		$x['nombre'] = 'Luis';
		$this->write($x,200);
	}
}

class OperadorController extends Controller
{ 
	function saludo(){
		$x['nombre'] = 'Luis';
		$this->write($x,400);
	}
}

Si no se envia el parametro, por defecto se toma el 200 Ok.

También se pueden enviar headers en la respuesta. Por ejemplo:

class OperadorController extends Controller
{ 
	function saludo(){
		$x['nombre'] = 'Luis';
		$header['client_id'] = 'abc-123';
		$this->write($x,200,$header);
	}
}

Note que la variable headers es un array, es decir se pueden enviar mas de un header en el response.

El método headers

En la sección anterior vimos cmo escribir un header, en esta sección veremos como leer los header de los request. El uso de header pueder ser muy util a la hora de utilizar token de autorización.

Para poder obtener el valor de un header, existe el metodo header() donde al enviar el nombre del header este retorna el valor de este.

class OperadorController extends Controller
{ 
	function saludo(){
		$clientId = $this->headers('client_id');
		$this->write($clientId);
	}
}

El método header() tiene una sobrecarga, donde si no se le envia ningun parametro, este retorna un arreglo de los headers.

class OperadorController extends Controller
{ 
	function saludo(){
		$headers = $this->headers();
		$this->write($headers);
	}
}

Los métodos before y after

Se tiene reservado dos acciones para ser invocadas antes y despues de ejecutar un acción, el método before() se ejecuta antes de que se ejecute la acción dentro de un controlador. Ejemplo:

class OperadorController extends Controller
{ 
	function before(){
		$this->write('Bienvenido ');
	}

	function saludo(){
		$this->write('Luis');
	}
}

El método after() se ejecuta despúes de que se ejecute la acción. Ejemplo:

class OperadorController extends Controller
{ 
	function saludo(){
		$this->write('Hola Luis.');
	}

	function after(){
		$this->write(' Adios!');
	}
}

Ambos métodos no soportan parámetros.

Estos metodos son utiles por ejemplo para validar las credenciales de acceso antes de ejecutar una accion, o dejar un registro despues de ejecutar una accion.

Los métodos get set

Los método get() y set() permiten disponibilizar informacion dentro de un controlador, como tambien con el modelo y para el caso de MVC para la vista.

Si bien estos métodos son muy utiles en la capa de la vista, pueden usarse dentro desde el mismo controlador, por ejemplo:

class OperadorController extends Controller
{ 
	function before(){
		$this->set('nombre','Luis');
	}

	function saludo(){
		$nombre = $this->get('nombre');
		$this->write('Hola '.$nombre);
	}
}

Algunos datos del request se encuntran disponibles desde el método get(), por ejemplo:

class OperadorController extends Controller
{ 
     function info(){
         $controlador = $this->get('Controller');
         $accion = $this->get('_action');
         $this->write($controlador.' - '.$accion);
     }
}

Los datos disponibles son los siguientes:

Los métodos template y view

Los métodos template() y view() estan solo disponibles en la verison MVC de Kurmix. Revisar su uso en la seccion Vista de este manual.

El método model

El metodo model() obtiene un objeto instanciado de la clase heredada de Model, esta sección se entenderá de mejor forma en la seccion Model de este manual pero se debe tener en cuenta que existe el metodo en el controlador para invocar al modelo.

class OperadorController extends Controller
{ 
	$obj = $this->model('Personas');
	$this->write($obj->listar());
}

El ejemplo muestra que se utiliza el metodo model("Personas") para obtener una instancia de esta clase Personas que hereda de la clase Model, para luego invocar al metodo listar() de esta objeto.

El modelo es la capa que interactua con la base de datos, se deben crear dentro del paquete/carpeta model y deben heredar de la clase Model.

class Personas extends Model
{ 
	function listar(){
	}
}

Se sugiere el formato camel case para el nombre de los métodos del modelo, tener en cuenta que no se pueden usar los siguientes nombres:

Para conectarse a la base de datos, es necesario realizar la configuracion de la credenciales. En el paquete/carpeta config se tiene la clase Config donde se debe registrar las credenciales de la base de datos.

class Config
{ 
	const BD_HOST		= "localhost";
	const BD_PORT		= "3306";
	const BD_DATABASE	= "kurmix";

	const BD_USERNAME	= "root";
	const BD_PASSWORD	= "";
}

Kurmix entiende que por defecto es una base de datos MySql o MariaDB, en caso de que se quiera utilizar otras BDs se puede utilizar el atributo CONNECTION donde recibe una cadena de conexion, ejemplo:

class Config
{ 
	const BD_CONNECTION	= "pgsql:host=localhost;port=5432;dbname=kurmix;"
	
	const BD_USERNAME	= "root";
	const BD_PASSWORD	= "";
}

Esta notacion permite seleccionar el tipo de BD, y ademas de agregar otras configuraciones en la cadena, por ejemplo estableser el charset: mysql:host=HOST;port=PORT;dbname=DATABASE;charset=utf8'

El método query

El método query() se conecta a la base de datos y ejecuta una query SQL. Suponiendo que tenemos la siguiente tabla personas:

Vamos a invocar el método query() a fin de listar la informacion de la tabla.

class OperadorController extends Controller
{ 
	function personas(){
		$obj = $this->model('Personas');
		$personas = $obj->listar();
		$this->write($personas);
	}
}

class Personas extends Model
{ 
   function listar(){
      return $this->query('SELECT * FROM personas');
   }
}

Como podemos notar, kurmix ha mapeado los campos de la tabla y lo ha convertido en un objeto o arreglo.

Si quisieramos solo mostrar los nombres:

class Personas extends Model
{ 
   function listar(){
     return $this->query('SELECT nombre FROM personas');
   }
}

Ahora, vamos a listar las personas que tengan menos de 18 años.

class Personas extends Model
{ 
   function listar(){
     return $this->query('SELECT * FROM personas WHERE edad < 18');
   }
}

class Personas extends Model
{ 
   function listar(){
     return $this->query('SELECT * FROM personas WHERE edad < ?',[18]);
   }
}

class Personas extends Model
{ 
    function listar(){
       return $this->query('SELECT * FROM personas WHERE edad > ? AND edad < ?',[18,30]);
    }
}

Como se puede observar, se tiene dos variables en la query, por tanto se debe enviar 2 valores por el array con el orden correspondinete.

También podemos usar el método query() para uso de otras quieries como UPDATE, INSERT, procedimientos almacenados, etc. Veamos un ejemplo de INSERT.

class Personas extends Model
{ 
	function listar(){
	   return $this->query("INSERT INTO personas (nombre, edad) VALUES (?,?)",['Eva',25]);
	}
}

Como se puede observar, query() retornó el Id Autoincrement del insert en un array, esto ya que el método siempre retornará un array o un null.

El método paginate

El controlador es la capa que contiene las acciones donde se ejecutarán las peticiones, estos deben heredar de la clase Controller y se deben crear dentro del paquete/carpeta controller.

class ejemploController extends Controller
{
	
}

Los assets

La vista por defecto

xx

class OperadorController extends Controller
{ 
	function info(){
     
	}
}

El template

El template

Los métodos get set