/**
* Maneja las excepciones no capturadas
*
* @param Exception $e
* */
public static function handleException($e)
{
self::setHeader($e);
//TODO quitar el extract, que el view pida los que necesite
extract(Router::get(), EXTR_OVERWRITE);
// Registra la autocarga de helpers
spl_autoload_register('kumbia_autoload_helper', true, true);
$Controller = Util::camelcase($controller);
ob_start();
if (PRODUCTION) {
//TODO: añadir error 500.phtml
include APP_PATH . 'views/_shared/errors/404.phtml';
return;
}
if ($e instanceof KumbiaException) {
$view = $e->view;
$tpl = $e->template;
} else {
$view = 'exception';
$tpl = 'views/templates/exception.phtml';
}
//Fix problem with action name in REST
$action = $e->getMessage() ? $e->getMessage() : $action;
include CORE_PATH . "views/errors/{$view}.phtml";
$content = ob_get_clean();
// termina los buffers abiertos
while (ob_get_level()) {
ob_end_clean();
}
include CORE_PATH . $tpl;
}
/**
* Maneja las excepciones no capturadas
*
* @param Exception $e
* */
public static function handle_exception($e)
{
if (isset($e->_view) && ($e->_view == 'no_controller' || $e->_view == 'no_action')) {
header('HTTP/1.1 404 Not Found');
} else {
header('HTTP/1.1 500 Internal Server Error');
}
extract(Router::get(), EXTR_OVERWRITE);
$Controller = Util::camelcase($controller);
ob_start();
if (PRODUCTION) {
include APP_PATH . 'views/_shared/errors/404.phtml';
return;
} else {
$Template = 'views/templates/exception.phtml';
if (isset($e->_view)) {
include CORE_PATH . "views/errors/{$e->_view}.phtml";
} else {
include CORE_PATH . "views/errors/exception.phtml";
}
}
$content = ob_get_clean();
// termina los buffers abiertos
while (ob_get_level()) {
ob_end_clean();
}
// verifica si esta cargado el View
if (class_exists('View')) {
if (View::get('template') === NULL) {
echo $content;
exit;
}
}
include CORE_PATH . $Template;
}
/**
* Ejecuta el builder
*
* @param string $name elemento a construir
* @param array $params
* @return boolean
* @throw BuilderException
*/
public static function execute($name, $params)
{
$filter = Util::camelcase($name);
$sfilter = Util::smallcase($name);
/**
* Nombre de archivo
**/
$__file__ = APP_PATH . 'filters/' . "{$sfilter}_filter.php";
/**
* Generando archivo
**/
if (!file_exists($__file__)) {
extract($params);
echo "\r\n-- Generando filter: {$filter}\r\n{$__file__}\r\n";
ob_start();
echo "<?php\n";
include CORE_PATH . 'libs/builder/base_builders/templates/filter.php';
$code = ob_get_contents();
ob_end_clean();
if (!file_put_contents($__file__, $code)) {
throw new KumbiaException("No se ha logrado generar el archivo de filter {$__file__}");
}
} else {
echo "\r\n-- El filter ya existe en {$__file__}\r\n";
}
return true;
}
/**
* Comando de consola para crear un modelo
*
* @param array $params parametros nombrados de la consola
* @param string $model modelo
* @throw KumbiaException
*/
public function create($params, $model)
{
// nombre de archivo
$file = APP_PATH . 'models';
// obtiene el path
$path = explode('/', trim($model, '/'));
// obtiene el nombre de modelo
$model_name = array_pop($path);
if (count($path)) {
$dir = implode('/', $path);
$file .= "/{$dir}";
if (!is_dir($file) && !FileUtil::mkdir($file)) {
throw new KumbiaException("No se ha logrado crear el directorio \"{$file}\"");
}
}
$file .= "/{$model_name}.php";
// si no existe o se sobreescribe
if (!is_file($file) || Console::input("El modelo existe, �desea sobrescribirlo? (s/n): ", array('s', 'n')) == 's') {
// nombre de clase
$class = Util::camelcase($model_name);
// codigo de modelo
ob_start();
include CORE_PATH . 'console/generators/model.php';
$code = '<?php' . PHP_EOL . ob_get_clean();
// genera el archivo
if (file_put_contents($file, $code)) {
echo "-> Creado modelo {$model_name} en: {$file}" . PHP_EOL;
} else {
throw new KumbiaException("No se ha logrado crear el archivo \"{$file}\"");
}
}
}
/**
* Ejecuta el destroyer
*
* @param string $name elemento a destruir
* @param array $params
* @return boolean
* @throw KumbiaException
*/
public static function execute($name, $params)
{
$path = APP_PATH . 'controllers/';
if (isset($params['module']) && $params['module']) {
$path .= "{$params['module']}/";
}
$controller = Util::camelcase($name);
$scontroller = Util::smallcase($name);
/**
* Nombre de archivo
**/
$file = $path . "{$scontroller}_controller.php";
echo "\r\n-- Eliminando controller: {$controller}\r\n{$file}\r\n";
if (!unlink($file)) {
throw new KumbiaException("No se ha logrado eliminar el archivo {$file}");
}
$path = APP_PATH . 'views/';
if (isset($params['module']) && $params['module']) {
$path .= "{$params['module']}/";
}
$path .= Util::smallcase($name) . '/';
echo "\r\n-- Eliminando directorio:\r\n{$path}\r\n";
if (!Util::removeDir($path)) {
throw new KumbiaException("No se ha logrado eliminar el directorio {$path}");
}
return true;
}
/**
* Ejecuta un destroyer
*
* @param string $destroyer nombre del destroyer (destructor) a ejecutar
* @param string $name elemento a eliminar
* @param array $params array de parametros para el destructor
* @return boolean
*/
public static function destroy($destroyer, $name = null, $params = array())
{
$success = false;
$destroyer_class = Util::camelcase($destroyer) . 'Destroyer';
if (class_exists($destroyer_class)) {
$success = call_user_func(array($destroyer_class, 'execute'), $name, $params);
} else {
throw new KumbiaException("No se ha encontrado la clase {$destroyer_class} necesaria para el destroyer");
}
return $success;
}
/**
* Obtiene la instancia de un modelo
*
* @param string $model
* @return obj model
*/
public static function model($model)
{
//Nombre de la clase
$Model = Util::camelcase(basename($model));
//Carga la clase
if (!class_exists($Model, FALSE)) {
//Carga la clase
if (!(include APP_PATH . "models/{$model}.php")) {
throw new KumbiaException("No existe el modelo {$model}");
}
}
return new $Model();
}
/**
* Obtiene la instancia de un modelo
*
* @param string $model modelo a instanciar
* @param mixed $params parámetros para instanciar el modelo
* @return obj model
*/
public static function model($model, $params = NULL)
{
//Nombre de la clase
$Model = Util::camelcase(basename($model));
//Carga la clase
if (!class_exists($Model, FALSE)) {
//Carga la clase
if (!(include_once APP_PATH . "models/{$model}.php")) {
throw new KumbiaException($model, 'no_model');
}
}
return new $Model($params);
}
/**
* Realiza el dispatch de una ruta
*
* @return Object
*/
public static function execute($route)
{
extract($route, EXTR_OVERWRITE);
if (!(include_once APP_PATH . "controllers/{$controller_path}" . '_controller.php')) {
throw new KumbiaException(NULL, 'no_controller');
}
//Asigna el controlador activo
$app_controller = Util::camelcase($controller) . 'Controller';
$cont = self::$_controller = new $app_controller($module, $controller, $action, $parameters);
View::select($action);
View::setPath($controller_path);
// Se ejecutan los filtros before
if ($cont->k_callback('initialize') === FALSE) {
return $cont;
}
if ($cont->k_callback('before_filter') === FALSE) {
return $cont;
}
//Se ejecuta el metodo con el nombre de la accion
//en la clase de acuerdo al convenio
if (!method_exists($cont, $action)) {
throw new KumbiaException(NULL, 'no_action');
}
//Obteniendo el metodo
$reflectionMethod = new ReflectionMethod($cont, $action);
//k_callback y __constructor metodo reservado
if ($reflectionMethod->name == 'k_callback' || $reflectionMethod->isConstructor()) {
throw new KumbiaException('Esta intentando ejecutar un método reservado de KumbiaPHP');
}
//se verifica que el metodo sea public
if (!$reflectionMethod->isPublic()) {
throw new KumbiaException(NULL, 'no_action');
}
//se verifica que los parametros que recibe
//la action sea la cantidad correcta
$num_params = count($parameters);
if ($cont->limit_params && ($num_params < $reflectionMethod->getNumberOfRequiredParameters() || $num_params > $reflectionMethod->getNumberOfParameters())) {
throw new KumbiaException("Número de parámetros erroneo para ejecutar la acción \"{$action}\" en el controlador \"{$controller}\"");
}
$reflectionMethod->invokeArgs($cont, $parameters);
//Corre los filtros after
$cont->k_callback('after_filter');
$cont->k_callback('finalize');
//Si esta routed volver a ejecutar
if (Router::getRouted()) {
Router::setRouted(FALSE);
return Dispatcher::execute(Router::get());
// Vuelve a ejecutar el dispatcher
}
return $cont;
}
/**
* Ejecuta el destroyer
*
* @param string $name elemento a destruir
* @param array $params
* @return boolean
* @throw KumbiaException
*/
public static function execute($name, $params)
{
$filter = Util::camelcase($name);
$sfilter = Util::smallcase($name);
/**
* Nombre de archivo
**/
$file = APP_PATH . "filters/{$sfilter}_filter.php";
echo "\r\n-- Eliminando filter: {$filter}\r\n{$file}\r\n";
if (!unlink($file)) {
throw new KumbiaException("No se ha logrado eliminar el archivo {$file}");
}
return true;
}
/**
* Ejecuta el builder
*
* @param string $name elemento a construir
* @param array $params
* @return boolean
* @throw BuilderException
*/
public static function execute($name, $params)
{
$path = APP_PATH . 'controllers/';
if (isset($params['module']) && $params['module']) {
$path .= "{$params['module']}/";
}
if (!is_dir($path)) {
if (!Util::mkpath($path)) {
throw new KumbiaException("No se ha logrado generar la ruta para controllers {$path}");
}
}
$controller = Util::camelcase($name);
$scontroller = Util::smallcase($name);
/**
* Nombre de archivo
**/
$__file__ = $path . "{$scontroller}_controller.php";
/**
* Generando archivo
**/
if (!file_exists($__file__)) {
extract($params);
echo "\r\n-- Generando controller: {$controller}\r\n{$__file__}\r\n";
ob_start();
echo "<?php\n";
include CORE_PATH . 'libs/builder/base_builders/templates/controller.php';
$code = ob_get_contents();
ob_end_clean();
if (!file_put_contents($__file__, $code)) {
throw new KumbiaException("No se ha logrado generar el archivo de controller {$__file__}");
}
$path = APP_PATH . 'views/';
if (isset($params['module']) && $params['module']) {
$path .= "{$params['module']}/";
}
$path .= $scontroller;
if (!is_dir($path)) {
echo "\r\n-- Generando directorio de vistas: \r\n{$path}\r\n";
if (!is_dir($path)) {
if (!Util::mkpath($path)) {
throw new KumbiaException("No se ha logrado generar la ruta para controllers {$path}");
}
}
}
} else {
echo "\r\n-- El controller ya existe en {$__file__}\r\n";
}
return true;
}
/**
* Comando de consola para crear un controlador
*
* @param array $params parametros nombrados de la consola
* @param string $controller controlador
* @throw KumbiaException
*/
public function create($params, $controller)
{
// nombre de archivo
$file = APP_PATH . 'controllers';
// limpia el path de controller
$clean_path = trim($controller, '/');
// obtiene el path
$path = explode('/', $clean_path);
// obtiene el nombre de controlador
$controller_name = array_pop($path);
// si se agrupa el controlador en un directorio
if (count($path)) {
$dir = implode('/', $path);
$file .= "/{$dir}";
if (!is_dir($file) && !FileUtil::mkdir($file)) {
throw new KumbiaException("No se ha logrado crear el directorio \"{$file}\"");
}
}
$file .= "/{$controller_name}_controller.php";
// si no existe o se sobreescribe
if (!is_file($file) || Console::input("El controlador existe, ¿desea sobrescribirlo? (s/n): ", array('s', 'n')) == 's') {
// nombre de clase
$class = Util::camelcase($controller_name);
// codigo de controlador
ob_start();
include __DIR__ . '/generators/controller.php';
$code = '<?php' . PHP_EOL . ob_get_clean();
// genera el archivo
if (file_put_contents($file, $code)) {
echo "-> Creado controlador {$controller_name} en: {$file}" . PHP_EOL;
} else {
throw new KumbiaException("No se ha logrado crear el archivo \"{$file}\"");
}
// directorio para vistas
$views_dir = APP_PATH . "views/{$clean_path}";
//si el directorio no existe
if (!is_dir($views_dir)) {
if (FileUtil::mkdir($views_dir)) {
echo "-> Creado directorio para vistas: {$views_dir}" . PHP_EOL;
} else {
throw new KumbiaException("No se ha logrado crear el directorio \"{$views_dir}\"");
}
}
}
}
/**
* Ejecuta el destroyer
*
* @param string $name elemento a destruir
* @param array $params
* @return boolean
* @throw KumbiaException
*/
public static function execute($name, $params)
{
$path = APP_PATH . 'models/';
if (isset($params['module']) && $params['module']) {
$path .= "{$params['module']}/";
}
$model = Util::camelcase($name);
$smodel = Util::smallcase($name);
/**
* Nombre de archivo
**/
$file = $path . "{$smodel}.php";
echo "\r\n-- Eliminando model: {$model}\r\n{$file}\r\n";
if (!unlink($file)) {
throw new KumbiaException("No se ha logrado eliminar el archivo {$file}");
}
return true;
}
/**
* Edita un Registro
*/
public function editar($id = null)
{
if ($id != null) {
View::select('crear');
$model = Util::camelcase($this->model);
//se verifica si se ha enviado via POST los datos
if (Input::hasPost($this->model)) {
$obj = Load::model($this->model);
if (!$obj->update(Input::post($this->model))) {
Flash::error('Falló Operación');
//se hacen persistente los datos en el formulario
$this->result = Input::post($this->model);
} else {
return Router::redirect("{$this->controller_path}");
}
}
//Aplicando la autocarga de objeto, para comenzar la edición
$this->result = Load::model($this->model)->find($id);
} else {
}
}
/**
* Aplica filtro de manera estatica
*
* @param mixed $s variable a filtrar
* @param string $filter filtro
* @param array $options
* @return mixed
*/
public static function get($s, $filter, $options = array())
{
if (is_string($options)) {
$filters = func_get_args();
unset($filters[0]);
$options = array();
foreach ($filters as $f) {
$filter_class = Util::camelcase($f) . 'Filter';
if (!class_exists($filter_class, false)) {
self::_load_filter($f);
}
$s = call_user_func(array($filter_class, 'execute'), $s, $options);
}
} else {
$filter_class = Util::camelcase($filter) . 'Filter';
if (!class_exists($filter_class, false)) {
self::_load_filter($filter);
}
$s = call_user_func(array($filter_class, 'execute'), $s, $options);
}
return $s;
}
/**
* Maneja las excepciones no capturadas
*
* @param Exception $e
**/
public static function handle_exception($e)
{
if (isset($e->_view) && ($e->_view == 'no_controller' || $e->_view == 'no_action')) {
header('HTTP/1.1 404 Not Found');
} else {
header('HTTP/1.1 500 Internal Server Error');
}
extract(Router::get(), EXTR_OVERWRITE);
$Controller = Util::camelcase($controller);
ob_start();
if (!PRODUCTION) {
$Template = 'views/templates/exception.phtml';
$boot = Config::read('boot');
if (isset($e->_view)) {
include CORE_PATH . "views/errors/{$e->_view}.phtml";
} else {
include CORE_PATH . "views/errors/exception.phtml";
}
} else {
include APP_PATH . 'views/errors/404.phtml';
$Template = 'views/templates/error.phtml';
}
$content = ob_get_clean();
// termina los buffers abiertos
while (ob_get_level()) {
ob_end_clean();
}
// verifica si esta cargado el dispatcher
if (class_exists('Dispatcher')) {
$controller = Dispatcher::get_controller();
if ($controller && $controller->response == 'view') {
echo $content;
exit;
}
}
include CORE_PATH . $Template;
}
/**
* Crea una instancia de la consola indicada
*
* @param string $console_name nombre de la consola
* return object
* @throw KumbiaException
**/
public static function load($console_name)
{
// nombre de la clase de consola
$Console = Util::camelcase($console_name) . 'Console';
if (!class_exists($Console)) {
// intenta carga el archivo de consola
$file = APP_PATH . "extensions/console/{$console_name}_console.php";
if (!is_file($file)) {
$file = CORE_PATH . "console/{$console_name}_console.php";
if (!is_file($file)) {
throw new KumbiaException('Consola "' . $file . '" no se encontro');
}
}
// incluye la consola
include_once $file;
}
// crea la instancia de objeto
$console = new $Console();
// inicializa la consola
if (method_exists($console, 'initialize')) {
$console->initialize();
}
return $console;
}
/**
* Paginador por sql
*
* @param string $model nombre del modelo
* @param string $sql consulta sql
*
* page: numero de pagina a mostrar (por defecto la pagina 1)
* per_page: cantidad de elementos por pagina (por defecto 10 items por pagina)
*
*
* Retorna un PageObject que tiene los siguientes atributos:
* next: numero de pagina siguiente, si no hay pagina siguiente entonces es false
* prev: numero de pagina anterior, si no hay pagina anterior entonces es false
* current: numero de pagina actual
* total: total de paginas que se pueden mostrar
* items: array de items de la pagina
* count: Total de registros
*
* Ejemplos:
* $page = paginate_by_sql('usuario', 'SELECT * FROM usuario' , 'per_page: 5', "page: $page_num");
*
* @return object
**/
public static function paginate_by_sql($model, $sql)
{
$params = Util::getParams(func_get_args());
$page_number = isset($params['page']) ? $params['page'] : 1;
$per_page = isset($params['per_page']) ? $params['per_page'] : 10;
$start = $per_page * ($page_number - 1);
/**
* Si es una cadena, instancio el modelo
**/
if (is_string($params[0])) {
$m = Util::camelcase($params[0]);
$model = ActiveRecord::get($m);
}
/**
* Instancia del objeto contenedor de pagina
**/
$page = new stdClass();
/**
* Cuento las apariciones atraves de una tabla derivada
**/
$n = $model->count_by_sql("SELECT COUNT(*) FROM ({$sql}) AS t");
$page->items = $model->find_all_by_sql($model->limit($sql, "offset: {$start}", "limit: {$per_page}"));
/**
* Se efectuan los calculos para las paginas
**/
$page->next = $start + $per_page < $n ? $page_number + 1 : false;
$page->prev = $page_number > 1 ? $page_number - 1 : false;
$page->current = $page_number;
$page->total = $n % $per_page ? (int) ($n / $per_page) + 1 : $n / $per_page;
$page->count = $n;
$page->per_page = $per_page;
return $page;
}
/**
* @param Auth $auth
*/
public function set_adapter($adapter, $auth = '', $extra_args = array())
{
if (!in_array($adapter, array('digest', 'http', 'model', 'kerberos5', 'radius'))) {
throw new kumbiaException("Adaptador de autenticación '{$adapter}' no soportado");
}
$this->adapter = Util::camelcase($adapter);
require_once __DIR__ . "/adapters/{$adapter}_auth.php";
$adapter_class = $this->adapter . 'Auth';
$this->extra_args = $extra_args;
$this->adapter_object = new $adapter_class($auth, $extra_args);
}
/**
* Realiza el dispatch de la ruta actual
*
* @return Controller
*/
private static function _dispatch()
{
// Extrae las variables para manipularlas facilmente
extract(self::$_vars, EXTR_OVERWRITE);
if (!(include_once APP_PATH . "controllers/{$controller_path}" . '_controller.php')) {
throw new KumbiaException(null, 'no_controller');
}
View::select($action);
//TODO: mover al constructor del controller base las 2 lineas
View::setPath($controller_path);
//Asigna el controlador activo
$app_controller = Util::camelcase($controller) . 'Controller';
$cont = new $app_controller($module, $controller, $action, $parameters);
// Se ejecutan los filtros initialize y before
if ($cont->k_callback(true) === false) {
return $cont;
}
//Obteniendo el metodo
try {
$reflectionMethod = new ReflectionMethod($cont, $cont->action_name);
} catch (ReflectionException $e) {
throw new KumbiaException(null, 'no_action');
//TODO: enviar a un método del controller
}
//k_callback y __constructor metodo reservado
if ($cont->action_name == 'k_callback' || $reflectionMethod->isConstructor()) {
throw new KumbiaException('Esta intentando ejecutar un método reservado de KumbiaPHP');
}
//se verifica que los parametros que recibe
//la action sea la cantidad correcta
$num_params = count($cont->parameters);
if ($cont->limit_params && ($num_params < $reflectionMethod->getNumberOfRequiredParameters() || $num_params > $reflectionMethod->getNumberOfParameters())) {
throw new KumbiaException(NULL, 'num_params');
}
try {
$reflectionMethod->invokeArgs($cont, $cont->parameters);
} catch (ReflectionException $e) {
throw new KumbiaException(null, 'no_action');
//TODO: mejor no_public
}
//Corre los filtros after y finalize
$cont->k_callback();
//Si esta routed internamente volver a ejecutar
if (self::$_routed) {
self::$_routed = FALSE;
return self::_dispatch();
// Vuelve a ejecutar el dispatcher
}
return $cont;
}
/**
* Crea un campo select que toma los valores de un array de objetos
*
* @param string $field Nombre de campo
* @param string $show Campo que se mostrara (opcional)
* @param array $data Array('modelo','metodo','param') (opcional)
* @param string $blank Campo en blanco (opcional)
* @param string|array $attrs Atributos de campo (opcional)
* @param string|array $value (opcional) Array en select multiple
* @return string
*/
public static function dbSelect($field, $show = NULL, $data = NULL, $blank = 'Seleccione', $attrs = '', $value = NULL)
{
$model = $data === NULL ? substr($field, strpos($field, '.') + 1, -3) : $data[0];
$model = Util::camelcase($model);
$model_asoc = new $model();
//por defecto el primer campo no pk
$show = $show ?: $model_asoc->non_primary[0];
$pk = $model_asoc->primary_key[0];
if ($data === NULL) {
$data = $model_asoc->find("columns: {$pk},{$show}", "order: {$show} asc");
//mejor usar array
} else {
$data = isset($data[2]) ? $model_asoc->{$data}[1]($data[2]) : $model_asoc->{$data}[1]();
}
return self::select($field, $data, $attrs, $value, $blank, $pk, $show);
}
/**
* Carga y devuelve una instancia del controllador
*/
public static function getController($param)
{
// Extrae las variables para manipularlas facilmente
extract($param, EXTR_OVERWRITE);
if (!(include_once "{$default_path}{$dir}/{$controller_path}{$suffix}")) {
throw new KumbiaException(null, 'no_controller');
}
//Asigna el controlador activo
$app_controller = Util::camelcase($controller) . 'Controller';
return new $app_controller($param);
}
/**
* Obtiene la instacia de un modelo
*
* @param string $model
* @return ActiveRecord
* @throw KumbiaException
* */
public static function get($model)
{
if (isset(self::$_models[$model])) {
return self::$_models[$model];
}
/**
* Nombre de la clase
* */
$Model = Util::camelcase(basename($model));
/**
* Verifico si esta cargada la clase
* */
if (!class_exists($Model, false)) {
/**
* Carga la clase
* */
$file = APP_PATH . "models/{$model}.php";
if (is_file($file)) {
include $file;
} else {
throw new KumbiaException(null, 'no_model');
}
}
self::$_models[$model] = $obj = new $Model();
return $obj;
}
/**
* Obtiene la instancia de un modelo
*
* @param string $model
* @return obj model
*/
public static function model($model)
{
/**
* Si se utiliza base de datos
**/
if (!class_exists('Db', false)) {
require CORE_PATH . 'libs/db/db.php';
}
/**
* Nombre de la clase
**/
$Model = Util::camelcase(basename($model));
/**
* Carga la clase
**/
if (!class_exists($Model, false)) {
/**
* Carga la clase
**/
$file = APP_PATH . "models/{$model}.php";
if (!is_file($file)) {
throw new KumbiaException("No existe el modelo {$model}");
}
include $file;
}
return new $Model();
}
/**
* Realiza el dispatch de una ruta
*
* @return Object
*/
public static function execute()
{
extract(Router::get(), EXTR_OVERWRITE);
$controllers_dir = APP_PATH . 'controllers';
if ($module) {
$controllers_dir = $controllers_dir . '/' . $module;
}
$app_controller = Util::camelcase($controller) . 'Controller';
$file = "{$controllers_dir}/{$controller}" . '_controller.php';
if (!is_file($file)) {
throw new KumbiaException(null, 'no_controller');
}
include_once $file;
/**
* Asigna el controlador activo
**/
self::$_controller = $activeController = new $app_controller($module, $controller, $action, $id, $all_parameters, $parameters);
/**
* Carga de modelos
**/
if (Config::get('config.application.database')) {
if (Config::get('config.application.models_autoload')) {
Load::models();
} elseif ($activeController->models !== null) {
Load::models($activeController->models);
}
}
/**
* Se ejecutan los filtros before
*/
if ($activeController->initialize() === false) {
return $activeController;
}
if ($activeController->before_filter() === false) {
return $activeController;
}
/**
* Se ejecuta el metodo con el nombre de la accion
* en la clase
*/
if (!method_exists($activeController, $action)) {
throw new KumbiaException(null, 'no_action');
}
call_user_func_array(array($activeController, $action), $parameters);
/**
* Corre los filtros after
*/
$activeController->after_filter();
$activeController->finalize();
/**
* Elimino del controlador los modelos inyectados
**/
foreach (Load::get_injected_models() as $model) {
unset($activeController->{$model});
}
/**
* Limpia el buffer de modelos inyectados
**/
Load::reset_injected_models();
return $activeController;
}
/**
* Carga modelos
*
* @param string $model en small_case
* @throw KumbiaException
*/
public static function models($model)
{
$args = is_array($model) ? $model : func_get_args();
foreach ($args as $model) {
$Model = Util::camelcase(basename($model));
//Si esta cargada continua con la siguiente clase
if (class_exists($Model, FALSE)) {
continue;
}
if (!(include APP_PATH . "models/{$model}.php")) {
throw new KumbiaException($model, 'no_model');
}
}
}
/**
* Carga los modelos
*
* @param string $model
*/
protected function models($model)
{
$args = func_get_args();
foreach ($args as $model) {
$file = APP_PATH . "models/{$model}.php";
if (is_file($file)) {
include_once $file;
$Model = Util::camelcase(basename($model));
$this->{$Model} = new $Model();
$this->_loaded_models[] = $Model;
} elseif (is_dir(APP_PATH . "models/{$model}")) {
foreach (new DirectoryIterator(APP_PATH . "models/{$model}") as $file) {
if ($file->isDot() || $file->isDir()) {
continue;
}
if ($file->isFile()) {
include_once $file->getPathname();
$Model = Util::camelcase(basename($file->getFilename(), '.php'));
$this->{$Model} = new $Model();
$this->_loaded_models[] = $Model;
}
}
} else {
throw new KumbiaException("Modelo {$model} no encontrado");
}
}
}
