/**
* Modelo::__construct()
*
* Genera los parametros necesarios para el procedimiento
* @param string $app
* @param string $entorno
* @param string $tipo
* @param array $modRewrite
* @return void
*/
function __construct($app = false, $entorno = false, $tipo = false, $modRewrite = false)
{
$this->app = $app;
$this->entorno = $entorno;
$this->tipo = $tipo;
$this->modReWrite = $modRewrite;
$this->directorio = ConfigAcceso::leer($app, 'fuente', 'directorio');
}
/**
* Codificar::constructorInputConfgExistencia()
*
* Genera la validacion de la existencia de la aplicacion
* y retorna la configuracion para el proceso
*
* @param string $app
* @return array
*/
private function constructorInputConfgExistencia($app = false)
{
if (ConfigAcceso::appExistencia($app) == true) {
return ConfigAcceso::leer($app, 'criptografia');
} else {
throw new Excepcion('La aplicación ingresada no existe en el archivo de configuración para la Codificación', 0);
}
}
/**
* Entidades::__construct()
*
* Genera la variable correspondiente
* de configuracion
*
* @param string $app
* @param string $entorno
* @return void
*/
function __construct($app = false, $conexion = false, $entorno = false)
{
$this->directorio = ConfigAcceso::leer($app, 'fuente', 'directorio');
$this->confg = ConfigBaseDatos::leer($conexion, $entorno);
$this->conexion = $conexion;
$this->dirEntidades = implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, $this->directorio, $entorno, 'Fuente', 'Complementos', 'ORM', 'Entidades'));
$this->dirProxy = implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, $this->directorio, $entorno, 'Fuente', 'Complementos', 'ORM', 'Proxy'));
}
/**
* Lista::listado()
*
* Genera la matriz de datos para generar
* el listado de la tabla correspondiente
*
* @param object $input
* @param object $output
* @return raw
*/
private function listado(InputInterface $input, OutputInterface $output)
{
$listado = ConfigAcceso::leer();
foreach ($listado as $nombre => $param) {
$lista[] = array($nombre, is_dir(implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, $param['fuente']['directorio']))) == true ? '<info>EXISTE</info>' : '<error>NO EXISTE</error>', $param['informacion']['creacion']);
}
return $lista;
}
/**
* AdicionalTwig::inputAppExistencia()
*
* Genera el proceso de validacion de la existencia
* de la aplicacion correspondiente
*
* @param string $app
* @return array
*/
private function inputAppExistencia($app = false)
{
if (ConfigAcceso::appExistencia($app) == true) {
return ConfigAcceso::leer($app, 'twig');
} else {
throw new Excepcion('La aplicación indicada no existe en el archivo de configuración para el proceso de la Plantilla Twig', 0);
}
}
/**
* ValidarForm::inputAppExistencia()
*
* Valida la existencia de la aplicacion correspondiente
* @param string $app
* @return string
*/
private function inputAppExistencia($app = false)
{
if (ConfigAcceso::appExistencia($app) == true) {
return $app;
} else {
throw new Excepcion(sprintf('La aplicación: %s, no existe en el archivo de configuración para el proceso de ValidarForm', $app), 0);
}
}
/**
* Nuevo::existenciaDirectorioApp()
*
* Genera la validacion de la existencia
* del directorio de archivos de la
* aplicacion
*
* @param object $input
* @param object $output
* @return raw
*/
private function existenciaDirectorioApp(InputInterface $input, OutputInterface $output)
{
$input->appDirectorio = implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, ConfigAcceso::leer($input->getArgument('app'), 'fuente', 'directorio')));
if (is_dir($input->appDirectorio) == true) {
$this->existenciaDirectorioModulo($input, $output);
} else {
throw new \RuntimeException(sprintf('El directorio de la aplicación: [ %s ] no existe', $input->getArgument('app')));
}
}
/**
* Consola::escrituraConsola()
*
* Genera la validacion de los permisos de
* escritura del directorio de consola
*
* @param object $input
* @param object $output
* @return raw
*/
private function escrituraConsola(InputInterface $input, OutputInterface $output)
{
$input->consolaDir = implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, ConfigAcceso::leer($input->getArgument('app'), 'fuente', 'directorio'), $this->entorno, 'Fuente', 'Complementos', 'Consola'));
if (is_writable($input->consolaDir) == true) {
$this->existenciaArchivo($input, $output);
} else {
throw new \RuntimeException(sprintf('El directorio de consola no tiene permisos de escritura en la aplicación: [ %s ]', $input->getArgument('app')));
}
}
/**
* ImportarModelo::__construct()
*
* Genera las variables necesarias para
* el proceso
*
* @param string $app
* @param string $modulo
* @param string $controlador
* @return void
*/
function __construct($app = false, $modulo = false, $controlador = false, $entorno = false, $tipo = false)
{
$this->app = $this->validarApp($app);
$this->modulo = $this->validarModulo($modulo);
$this->controlador = $this->validarControlador($controlador);
$this->directorio = ConfigAcceso::leer($app, 'fuente', 'directorio');
$this->entorno = $entorno;
$this->tipo = $tipo;
}
/**
* CrearEntidad::appExistencia()
*
* Genera la validacion de la existencia
* de la aplicacion para la ruta correspondiente
* de las entidades
*
* @return void
*/
private function appExistencia()
{
if (ConfigAcceso::appExistencia($this->aplicacion) == true) {
$directorio = ConfigAcceso::leer($this->aplicacion, 'fuente', 'directorio');
$this->dirEntidades = implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, $directorio, $this->entorno, 'Fuente', 'Complementos', 'ORM', 'Entidades'));
$this->dirProxy = implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, $directorio, $this->entorno, 'Fuente', 'Complementos', 'ORM', 'Proxy'));
$this->entidadesExistencia();
} else {
throw new \RuntimeException(sprintf('La aplicación: %s, no existe en la configuarción de accesos', $this->aplicacion));
}
}
/**
* Boot::appSeleccionEntorno()
*
* Genera la validacion inicial del entorno a definir
* @return void
*/
private function appSeleccionEntorno()
{
$this->confg = ConfigAcceso::leer($this->modReWrite['app']);
if ($this->confg['localhost']['habilitado'] == true) {
if (array_key_exists($_SERVER['REMOTE_ADDR'], array_flip($this->confg['localhost']['ip'])) == true) {
define('ENV_ENTORNO', 'Desarrollo');
} else {
define('ENV_ENTORNO', 'Produccion');
}
} else {
define('ENV_ENTORNO', 'Produccion');
}
$this->directorioExistencia();
}
/**
* Twig::existenciaAppEx()
*
* Valida la existencia de la aplicacion correspondiente
* @param string $plantilla
* @return string
*/
private function existenciaAppEx($plantilla = false)
{
if (ConfigAcceso::appExistencia($this->app) == true) {
return $this->existenciaRutas($plantilla);
} else {
throw new Excepcion('La aplicación no existe registrado en el archivo de configuración para el proceso de plantilla Twig', 0);
}
}
/**
* Desarrollo::appConsolaOpciones()
*
* Genera la carga de las opciones adicionales
* que se requieren para la autocarga de las diferentes
* opciones que se requieren para ejecutar el archivo
*
* @return void
*/
private function appConsolaOpciones()
{
define('ENV_ENTORNO', $this->entorno);
define('ENV_TIPO', 'MVC');
date_default_timezone_set(ConfigAcceso::leer($this->aplicacion, 'sistema', 'tiempo', 'zona'));
require implode(DIRECTORY_SEPARATOR, array($this->appRuta, $this->entorno, 'Fuente', 'Configuracion', 'Parametros.php'));
$consola = new \AutoCargador('Consola', implode(DIRECTORY_SEPARATOR, array($this->appRuta, $this->entorno, 'Fuente', 'Complementos')));
$consola->registrar();
$entidades = new \AutoCargador('Entidades', implode(DIRECTORY_SEPARATOR, array($this->appRuta, $this->entorno, 'Fuente', 'Complementos', 'ORM')));
$entidades->registrar();
$formulario = new \AutoCargador('Formularios', implode(DIRECTORY_SEPARATOR, array($this->appRuta, $this->entorno, 'Fuente', 'Complementos')));
$formulario->registrar();
$interface = new \AutoCargador('Interfaces', implode(DIRECTORY_SEPARATOR, array($this->appRuta, $this->entorno, 'Fuente', 'Complementos')));
$interface->registrar();
Autoloader::register(implode(DIRECTORY_SEPARATOR, array($this->appRuta, $this->entorno, 'Fuente', 'Complementos', 'ORM', 'Proxy')), 'Proxy');
$utilidades = new \AutoCargador('Utilidades', implode(DIRECTORY_SEPARATOR, array($this->appRuta, $this->entorno, 'Fuente', 'Complementos')));
$utilidades->registrar();
$modeloMVC = new \AutoCargador('Modelo', implode(DIRECTORY_SEPARATOR, array($this->appRuta, $this->entorno, 'Fuente', 'Sistema')));
$modeloMVC->registrarModelo();
$this->consolaObjeto();
}
/**
* WebPublico::todoArrayDirectorios()
*
* Obtiene todos los directorios fuente de
* las aplicaciones
*
* @return array
*/
private function todoArrayDirectorios()
{
$matriz = ConfigAcceso::leer();
foreach ($matriz as $app => $array) {
$lista[] = array('app' => $app, 'directorio' => $array['fuente']['directorio']);
}
unset($matriz);
return $lista;
}
/**
* contPublico::__construct()
*
* Genera la variable correspondiente al directorio
* de la aplicacion actual
*
* @return void
*/
function __construct()
{
parent::__construct();
$this->directorio = ConfigAcceso::leer(APP, 'fuente', 'directorio');
}
/**
* Excepcion::asignadoExistencia()
*
* Valida la existencia de la plantilla correspondiente
* en dado caso que no exista la plantilla se generara la
* plantilla definida por el sistema de manera autonoma
*
* @param array $array
* @return string
*/
private function asignadoExistencia($array = false)
{
$archivo = implode(DIRECTORY_SEPARATOR, array_merge(array(ROOT_APPS, ConfigAcceso::leer($this->app, 'fuente', 'directorio'), $this->entorno, 'Fuente', 'Sistema', 'Plantillas'), $array));
if (file_exists($archivo) == true) {
return $this->plantillaApp($array);
} else {
return $this->plantillaSistema();
}
}
/**
* Conexion::inputAppExistencia()
*
* Genera la validacion de la existencia
* correspondiente
*
* @param string $app
* @return string
*/
private function inputAppExistencia($app = false)
{
if (ConfigAcceso::appExistencia($app) == true) {
return ConfigAcceso::leer($app, 'fuente', 'directorio');
} else {
throw new Excepcion(sprintf('La aplicación: %s no existe en el archivo de configuración para el proceso de Conexion de la BD', $app), 0);
}
}
/**
* Desarrollo::existenciaNamespace()
*
* Se valida la existencia del archivo que
* se generara y determinar si es posible
* crearlo o no
*
* @param object $input
* @param object $output
* @return raw
*/
private function existenciaNamespace(InputInterface $input, OutputInterface $output)
{
$this->complementos = implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, ConfigAcceso::leer($this->param->app, 'fuente', 'directorio'), 'Desarrollo', 'Fuente', 'Complementos', 'Formularios'));
$namespace = explode(':', $this->param->namespace);
$archivo = $this->complementos . DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $namespace) . '.php';
if (file_exists($archivo) == false) {
$this->formatoCampos($input, $output);
} else {
throw new \RuntimeException(sprintf('El archivo: [ %s ] ya existe dentro del directorio de formularios', implode(DIRECTORY_SEPARATOR, $namespace)));
}
}
/**
* Produccion::opcionesConsola()
*
* Genera la carga de archivos
* correspondientes para el proceso de
* consola
*
* @param object $input
* @param object $output
* @return raw
*/
private function opcionesConsola(InputInterface $input, OutputInterface $output)
{
define('ENV_ENTORNO', $this->entorno);
define('ENV_TIPO', 'MVC');
date_default_timezone_set(ConfigAcceso::leer($input->getArgument('app'), 'sistema', 'tiempo', 'zona'));
require implode(DIRECTORY_SEPARATOR, array($input->appDir, 'Configuracion', 'Parametros.php'));
$consola = new \AutoCargador('Consola', implode(DIRECTORY_SEPARATOR, array($input->appDir, 'Complementos')));
$entidades = new \AutoCargador('Entidades', implode(DIRECTORY_SEPARATOR, array($input->appDir, 'Complementos', 'ORM')));
$formulario = new \AutoCargador('Formularios', implode(DIRECTORY_SEPARATOR, array($input->appDir, 'Complementos')));
$interface = new \AutoCargador('Interfaces', implode(DIRECTORY_SEPARATOR, array($input->appDir, 'Complementos')));
$utilidades = new \AutoCargador('Utilidades', implode(DIRECTORY_SEPARATOR, array($input->appDir, 'Complementos')));
$modeloMVC = new \AutoCargador('Modelo', implode(DIRECTORY_SEPARATOR, array($input->appDir, 'Sistema')));
Autoloader::register(implode(DIRECTORY_SEPARATOR, array($input->appDir, 'Complementos', 'ORM', 'Proxy')), 'Proxy');
$consola->registrar();
$entidades->registrar();
$formulario->registrar();
$interface->registrar();
$utilidades->registrar();
$modeloMVC->registrarModelo();
$this->existenciaClaseControlador($input, $output);
}
/**
* Lista::listado()
*
* Genera la matriz de datos para generar
* el listado de la tabla correspondiente
*
* @param object $input
* @param object $output
* @return raw
*/
private function listado(InputInterface $input, OutputInterface $output)
{
$listado = ConfigAcceso::leer();
$contador = 1;
foreach ($listado as $nombre => $param) {
$lista[] = array($contador, $nombre, is_dir(implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, $param['fuente']['directorio']))) == true ? '<info>EXISTE</info>' : '<error>NO EXISTE</error>', $param['informacion']['creacion']);
if ($nombre != 'Predeterminado') {
$this->comandos[$contador] = $nombre;
}
$contador++;
}
return $lista;
}
/**
* Predeterminado::listadoAplicaciones()
*
* Genera el listado de aplicaciones para
* la pregunta correspondiente
*
* @param object $input
* @param object $output
* @return raw
*/
private function listadoAplicaciones(InputInterface $input, OutputInterface $output)
{
$array = ConfigAcceso::leer();
$contador = 1;
foreach ($array as $nombre => $param) {
if ($nombre != 'Predeterminado') {
$lista[$contador] = $nombre;
$contador++;
}
}
return isset($lista) == true ? $lista : array();
}
/**
* Lista::listado()
*
* Genera la matriz de datos para generar
* el listado de la tabla correspondiente
*
* @param object $input
* @param object $output
* @return raw
*/
private function listado(InputInterface $input, OutputInterface $output)
{
$listado = ConfigModulos::leer(ConfigAcceso::leer($input->getArgument('app'), 'fuente', 'directorio'), 'Desarrollo');
foreach ($listado['modulos'] as $nombre => $param) {
$lista[] = array($nombre, $param['habilitado'] == true ? '<info>ACTIVO</info>' : '<error>INACTIVO</error>', $param['mantenimiento'] == true ? '<error>ACTIVO</error>' : '<info>INACTIVO</info>');
}
return $lista;
}
/**
* Nuevo::existenciaApp()
*
* Genera la validacion de la existencia de
* la aplicacion en el archivo de
* configuracion
*
* @param object $input
* @param object $output
* @return raw
*/
private function existenciaApp(InputInterface $input, OutputInterface $output)
{
if (ConfigAcceso::appExistencia($this->nombre) == false) {
$this->existenciaDirectorio($input, $output);
} else {
throw new \RuntimeException('La aplicación ya existe y se encuentra configurada');
}
}
/**
* ControladorModulo::escrituraControlador()
*
* Valida los permisos de lectura y
* escritura del directorio de
* modelos para poder realizar el
* proceso de creacion del modelo
*
* @param object $input
* @param object $output
* @return raw
*/
private function escrituraControlador(InputInterface $input, OutputInterface $output)
{
$this->controladorDirectorio = implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, ConfigAcceso::leer($this->parametro['app'], 'fuente', 'directorio'), 'Desarrollo', 'Fuente', 'Sistema', 'Modulos', $this->parametro['modulo'], 'Modelos'));
if (is_writable($this->controladorDirectorio) == true) {
$this->existenciaControlador($input, $output);
} else {
throw new \RuntimeException(sprintf('El directorio de Modelos del modulo: [ %s ] de la aplicación: [ %s ] no tiene permisos de lectura y escritura', $this->parametro['modulo'], $this->parametro['app']));
}
}
/**
* Desarrollo::inputExistenciaApp()
*
* Genera la validacion de la existencia de
* la aplicacion y retorna el directorio base
*
* @param string $app
* @return string
*/
private function inputExistenciaApp($app = false)
{
if (ConfigAcceso::appExistencia($app) == true) {
return implode(DIRECTORY_SEPARATOR, array(ROOT_APPS, ConfigAcceso::leer($app, 'fuente', 'directorio')));
} else {
throw new \RuntimeException(sprintf('La aplicación: %s no se encuentra registrada en el archivo de configuración de accesos', $app));
}
}
/**
* Cod::inputAppExistencia()
*
* Genera la validacion de la existencia de la aplicacion
* para el proceso de codificacion
*
* @param string $app
* @return string
*/
private function inputAppExistencia($app = false)
{
if (ConfigAcceso::appExistencia($app) == true) {
return $app;
} else {
throw new Excepcion(sprintf('La aplicación: %s no se encuentra registrada en el archivo de configuración para el procesd de Codificación', $app), 0);
}
}
/**
* Validacion::crearJsAppValidar()
*
* Genera la validacion de la existencia
* de la aplicacion configurada para la
* asignacion de las rutas de los archivos
* fuente
*
* @param string $app
* @param bool $validate
* @param bool $jQuery
* @param string $namespace
* @return string
*/
private function crearJsAppValidar($app = false, $validate = false, $jQuery = false, $namespace = false)
{
if (ConfigAcceso::appExistencia($app) == true) {
return $this->crearJsLibrerias($app, $validate, $jQuery, $namespace);
} else {
throw new Excepcion(sprintf('La aplicación: %s no existe para generar la construcción del script de validación', $app), 0);
}
}
