*buscar: Acción genérica de Igep que se lanza cuando le damos desde un panel de busqueda al botón buscar. Se encarga de recoger los datos incluidos en el panel de busqueda y realizar la Select a partir de los parametros $str_select, $str_where y $str_orderBy.
*nuevo: Acción genérica que se lanza al dar al botón de nuevo. Es importante tener en cuenta que esta acción puede llegar a phrame o no; esto dependerá de si el panel lo require o no. Siempre lo requerirá si tiene listas deplegables, ya que si se tienen que cargar debe pasar por esta acción.
*editar: Acción genérica que se lanza al pulsar el botón de editar en un panel de listado. Se encarga de recoger los datos del registro seleccionado y construir la select a partir de los atributos $str_selectEditar, $str_whereEditar y $str_orderByEditar.
*borrar: Acción genérica que se lanza en un panel de listado (que tenga asociado un panel de edición o Ficha) al pulsar el botón de guardar. Se encarga de recoger las tuplas que el usuario a marcado para borrar y lanza el Delete.
*recargar: Acción privada de Igep que se encarga de sincronizar el maestro-detalle.
*operarBD: Acción genérica que se lanza al pulsar el botón guardar en un panel de listado. Se encarga de realizar las tres operaciones básicas de mantenimiento y que se pueden realizar desde este panel: Inserción, Actualización y borrado.
*cancelarTodo: Acción genérica que se lanza al pulsar el botón cancelar de un panel de listado. Se encarga de borrar el contenido de la ultima consulta y volver al panel de busqueda.
*cancelarEdicion: Acción genérica que se lanza al pulsar el botón cancelar de un panel de edición o ficha. Se encarga de borrar el contenido de la ultima edición y volver al panel de listado.
*inicializarBusqueda: Acción genérica que se lanzará en el caso de que se quiera incluir una lista desplegable en el menu de busqueda. En este caso, antes de entrar en la ventana tendrá que realizarse una llamada a phrame con esta acción.
*camposDependientes: Acción privada de Igep que sirve para recalcular las listas dependientes con el nuevo valor seleccionado. Nunca tiene que ser utilizado por los programadores.
*abrirVentanaSeleccion: Acción privada de Igep que sirve para abrir una ventana de Selección. Nunca tiene que ser utilizado por los programadores.
*buscarVentanaSeleccion: Acción privada de Igep que sirve para buscar en una ventana de Selección. Nunca tiene que ser utilizado por los programadores.
*
*
* Se recomienda consultar la documentación acerca del método perform.
*
* @version $Id: IgepNegocio.php,v 1.299 2006-06-22 10:44:49 afelixf Exp $
*
* @author David:
* @author Keka:
* @author Vero:
* @author Raquel:
* @author Toni:
*
* @package igep
*/
class IgepNegocio extends Action{
/**
* objeto conexion
* @access private
* @var object obj_conexion
*/
var $obj_conexion;
/**
* vector de nombres de tablas
* @access private
* @var array v_nombreTablas
*/
var $v_nombreTablas;
/**
* vector de manejadores de tablas
* @access private
* @var array v_tablas
*/
var $v_tablas;
/**
* string que contiene la SELECT que define el contenido del panel en su pestaña principal (la que se mostrará tras lanzar el panel de busqueda). Esta select debe ser inicializada por el programador en la clase contenida en actions
*
* @var string str_select
*/
var $str_select;
/**
* string que contiene el ORDER BY de la SELECT
*
* @var string str_orderBy
*/
var $str_orderBy;
/**
* objeto de resultado de la última consulta
*
* @var object obj_ultimaConsulta
*/
var $obj_ultimaConsulta;
/**
* variable de error
*
* @var object obj_errorNegocio
*/
var $obj_errorNegocio;
/**
* Variable que controla el match-in entre las tpl y la bd
* @access private
* @var array $matching
*/
var $matching;
/**
* La instancia de IgepComunicación para comunicarnos con la presentación
* @access public
* @var object $comunica
*/
var $comunica;
/**
* Esta variable tiene el nombre de la clase Hija que la ha llamado. Esto lo hacemos para guardarla con ese nombre en la sesión.
* Este parámetro debe ser rellenado por el usuario, ya que hasta la versión 5 de PHP la función get_class devuelve el nombre de la clase en minusculas.
*
* @var string str_claseActual
*/
var $str_claseActual;
/**
* Esta variable contiene la WHERE que se aplicará a la Select de búsqueda
* @var string $str_where
*/
var $str_where;
/**
* Guardamos el valor de la variable global g_aplicación. Como lo gastamos para Sesion.
* @access private
* @var string $str_aplicacion
*/
var $str_aplicacion;
/**
* Esta variable contiene la SELECT que se aplicará al segundo panel de edición.
* @var string $str_selectEditar
*/
var $str_selectEditar;
/**
* Esta variable contiene la WHERE que se aplicará al segundo panel de edición.
* @var string $str_whereEditar
*/
var $str_whereEditar;
/**
* Esta variable contiene el ORDER BY que se aplicará al segundo panel de edición.
* @var string $str_orderByEditar
*/
var $str_orderByEditar;
/**
* Esta variable contiene el resultado de la última Select de Edición. Contiene el DBResult
* @access private
* @var object $obj_ultimaEdicion
*/
var $obj_ultimaEdicion;
/**
* Variable que contendrá el posible mensaje a enviar al panel. Tiene que ser de la clase IgepMensaje
*
* @var object $obj_mensaje
*/
var $obj_mensaje;
/**
* Para guardar la fila actual
* @access private
* @var integer $int_filaActual
*/
var $int_filaActual;
/**
* Variable interna donde tenemos la descripción de las lista desplegables
* @access private
* @var array $v_lista
*/
var $v_listas;
/**
* Este array tiene la referencia de los paneles hijos(su clase manejadora) y la relación de dependencia existente,
* es decir los campos de la TPL que correspondan.
* @var array $v_hijos
*/
var $v_hijos;
/**
* Esta variable contiene el nombre de la clase padre. Si el panel tiene un panel maestro del que depende, debe inicializar esta variable con el nombre de la clase padre.
* @var string $str_nombrePadre
*/
var $str_nombrePadre;
/**
* Esta variable contiene el array de definición de todas las ventanas de selección del panel.
* @access private
* @var array $v_ventanasSeleccion
*/
var $v_ventanasSeleccion;
/**
* String donde se almacena el filtro de la Where de Busqueda. Es importante porque este filtro se mantiene hasta que se vuelva a realizar otra busqueda
* @access private
* @var string $str_whereFiltro
*/
var $str_whereFiltro;
/**
* String donde se almacena el filtro de la Where de la selección (3 pestañas en el panel lis). Es importante porque este filtro se mantiene hasta que se vuelva a realizar otra edicion
* @access private
* @var string $str_whereFiltroEdicion
*/
var $str_whereFiltroEdicion;
/**
* Variable donde marcamos el límite de los registros a mostrar
* @access private
* @var integer int_limiteConsulta
*/
var $int_limiteConsulta = 100;
/**
* Array que se utiliza para preInsertar los datos cuando se pulsa al botón de nuevo.
* @access private
* @var array $v_preInsercionDatos
*/
var $v_preInsercionDatos;
/**
* Array que se gasta para almacenar datos necesarios para la presentacion.
* Permite interactuar con el panel de presentación. Es decir, ponerlo en
* modo inserción o en modo modificacion.
* @access private
* @var array $v_datosPresentacion
*/
var $v_datosPresentacion;
/**
* Array que describe las características de los campos del panel.
* @access private
* @var array $v_descCamposPanel
*/
var $v_descCamposPanel;
/**
* Variable privada que se gasta de forma interna para contener todos los campos con definición decimal. Facilita su tratamiento.
* @access private
* @var array $v_camposDecimales
*/
var $v_camposDecimales = array();
/**
* Variable que almacena las constantes que se van a incluir en la consulta.
* @access private
* @var string str_SelectConstantes
*/
var $str_SelectConstantes;
/**
* Array que almacena los campos claves del panel.
* @access private
* @var array v_camposClave
*/
var $v_camposClave = array();
/**
* String en el que se almacenarán condiciones de busqueda especiales. Por ejemplo para añadir un EXISTS a la SELECT si cierto campo del panel de busqueda está a true.
* @access private
* @var string str_whereAdicional
*/
var $str_whereAdicional;
/**
* Array que contiene la estructura necesaria para controlar las validaciones que los usuarios pueden programar a partir de funciones particulares de la clase.
* @access private
* @var array v_validacionesUsuario
*/
var $v_validacionesUsuario;
/**
* Objeto que contiene la descripción del arbol igep
* @access private
* @var object igepArbol
*/
var $obj_arbol;
/**
* Objeto que permite manejar/registrar el javascript de esta clase
* @access private
* @var object obj_IgSmarty
*/
var $obj_IgSmarty;
/**
* Variable interna que permite modificar el tipoConsulta general de un panel. Los valores posibles son:
* (0) Se construye la Where igualando los campos a los valores.
* (1) Se construye con like y comodines para cada campo.
* (2) Por defecto, se contruye con like sólo si el usuario ha especificado comodines.
* @access private
* @var integer $int_tipoConsulta
*/
var $int_tipoConsulta;
/**
* Vector que contiene los checks que en un tres modos se han seleccionado al realizar una accion editar.
* @access private
* @var array $v_checksMarcados
*/
var $v_checksMarcados;
/**
* Cadena que contiene el nombre de la clase manejadora del panel detalle activo (visible)
* @access private
* @var string panelDetalleActivo
*/
var $panelDetalleActivo;
/**
* constructor. Generará a partir de los parámetros que se le pasen una conexión a al base de datos y un
* array de manejadores de tablas (una por cada una de las que mantenga el panel hijo).
*/
function IgepNegocio($dsn='',$nombreTablas=''){
//Cogemos la referencia de la variable del nombre de la aplicación.
global $g_aplicacion;
$this->str_aplicacion = $g_aplicacion;
//Contiene la coleccion de tablas que mantiene
$this->v_nombreTablas= $nombreTablas;
//Guardamos la referencia del dsn principal
$this->_dsnInterno = $dsn;
//Guardamos la referencia al tipo de consulta
global $gint_tipoConsulta;
$this->int_tipoConsulta = $gint_tipoConsulta;
//Creamos la instancia de IgepSmarty que controla el Js
$this->obj_IgSmarty = new IgepSmarty();
//Generamos la instancia completa
$this->regenerarInstancia($dsn);
}//Fin de constructor
function regenerarInstancia($dsn=''){
//Recuperamos la instancia de la clase Error. Si no existe (caso en el que venimos de Views), lo creamos
global $g_error;
//#NVI#VIEWS#: Cuando quietemos del views las llamadas a Negocio quitamos este if
if(!isset($g_error))
$g_error = new IgepError();
$this->obj_errorNegocio = & $g_error;
if($dsn=='')
$dsn=$this->getDSN();
//Como es una instancia de una clase hija creamos la conexión.
$this->obj_conexion = new IgepConexion($dsn);
//Comprobación de errores de la conexion.
if($this->obj_errorNegocio->hayError()){
$v_descError = $this->obj_errorNegocio->getDescErrorDB();
die('Error: No se ha podido establecer la conexión con la Base de Datos. El error detectado por la BD es:'."\n".'"'.$v_descError[0].'"');
}
$i=0;
foreach($this->v_nombreTablas as $tabla) {
$this->v_tablas[$i] = new IgepPersistencia($this->obj_conexion->getConexion(),$tabla);
$i++;
}
}
function getDSN(){
if(!empty($this->_dsnInterno))
return $this->_dsnInterno;
else
return '';
}
/**
* Utilizado por Negocio. Devuelve una colección campo/valor, campo/valores que contine
* la información para preasignar valores por defecto en campos de inserción y detalles
* (los campos que lo relaciona con el maestro)
* @acces private
* @param string nombreCampo Nombre del campo sobre el que se dan valores por defecto
* @return array Vector indexado por el nombre del campo que contiene los valores de los
* mismos en función del tipo
*/
function getDatosPorDefecto($nombreCampo=''){
if($nombreCampo=='')
return ($this->v_preInsercionDatos);
else
return ($this->v_preInsercionDatos[$nombreCampo]);
}
/**
* Utilizado por Negocio. Fija valores por defecto para distintos campos de la TPL,
* por ejemplo, los valores de las listas cuando pulsamos la opción de insertar, o
* los campos que relacionan una panel detalle con su maestro
* @access private
* @param string nombreCampo Nombre del campo sobre el que se dan valores por defecto
* @param mixed $valor Valor (string) /valores (arraysLista) que asignar
*/
function addDatosPorDefecto($nombreCampo, $valor){
$this->v_preInsercionDatos[$nombreCampo] = $valor;
}
/**
* Método que SIEMPRE se lanza cuando venimos desde phrame y que es el encargado de realizar la unión entre Igep y el controlador (phrame).
* Este método comprueba cual es la acción a ejecutar y lanza las operaciones pertinentes.
* Estas acciones pueden ser acciones genéricas en cuyo caso aparecerán en el codigo de este método como entradas del switch principal; o pueden ser acciones
* particulares del panel hijo, en cuyo caso deberán incorporarse al sobreescribiendo el método comportamientosParticulares en la clase hija.
* La forma que proporciona phrame para que le indiquemos la dirección de destino son los objetos de la clase actionForward.
* Por esta razón este método recogerá estos objetos y los devolverá a phrame; quien se encargará de
* redirigir al navegador hasta la URL adecuada. Estos objetos actionForward se obtienen a partir del
* parámetro $actionMapping (que se encarga de leer el valor del mappings.php de la aplicación).
*
IMPORTANTE: Este método SIEMPRE almacena en la SESSION el objeto panel actual, por ello no es
* necesario que nosotros lo almacenemos previamente si venimos de phrame.
* @access private
*/
function perform($actionMapping, $actionForm) {
//Recogemos la accion y le quitamos el prefijo que nos viene de la ventana
$str_accion = $actionForm->get('action');
if(strpos($str_accion,'__')>0) {
$auxiliar = explode('__',$str_accion);
$str_accion = $auxiliar[1];
}
//Debug:Indicamos que la accion a ejecutar
IgepDebug::setDebug(DEBUG_IGEP,'IgepNegocio: ejecutamos acción '.$str_accion.' de la clase Manejadora '.$this->getClaseActual());
//creamos la instancia de IgepComunicacion
$this->comunica = new IgepComunicacion($this->matching,$this->getDSN(),$this->v_descCamposPanel);
switch ($str_accion) {
//Acción genérica de Igep que se lanzará cuando se quiera incluir en un panel de búsqueda una lista desplegable cargada desde BD
case 'iniciarVentana':
$actionForward = $this->iniciarVentana($actionMapping);
break;
//Acción que normalmente se dispara desde los paneles de filtro. Comprueba si la busqueda tiene parámetros y lanza la SELECT q se encuentra en el parámetro str_select
case 'buscar':
//Como volvemos a buscar, borramos el filtro anterior.
$resultado = $this->construirConsulta();
if($resultado==0)
$resultado = $this->buscar();
if($resultado==0){
//Si se trata de un maestro (tiene paneles dependientes los recargamos)
if(isset($this->v_hijos)){
//De momento esto no funciona
$this->int_filaActual = 0;
$this->recargar($this->obj_ultimaConsulta);
}
//Hay que lanzar el focusChanged si es una ficha
$this->obj_IgSmarty->addScriptLoad(IgepSmarty::getJsLanzarFocusChanged(),'IGEP');
$actionForward = $actionMapping->get('correcto');
}
else {
//Si no tiene datos comprobamos si el usuario tiene una acción por defecto
$actionForward = $actionMapping->get('sinDatos');
if(($resultado!=-2) or count($actionForward)==0){
$actionForward = new ActionForward('IgepErrorValidacion');
$actionForward->put('IGEPclaseManejadora',$this->getClaseActual());
}
}
break;
//Acción que se lanza al pulsar al botón de nuevo registro en un panel. Se utiliza para cargar listas u otros componentes antes de que el usuario empiece la inserción de datos.
case 'nuevo':
$resultado = $this->nuevo();
if($resultado==0){
$actionForward = $actionMapping->get('correcto');
}
else {
$actionForward = new ActionForward('IgepErrorValidacion');
$actionForward->put('IGEPclaseManejadora',$this->getClaseActual());
}
break;
//Acción que se lanza al pulsar el botón modificar de un panel con dos consultas. En este caso se lanzaría la segunda consulta que se encuentra en el parámetro str_selectEditar
case 'editar':
$this->comunica->construirArraySeleccionar();
//Fijamos la operación a seleccionar
$this->comunica->setOperacion('seleccionar');
$resultado = $this->construirConsultaEditar();
if($resultado==0)
$resultado = $this->editar();
if($resultado==0){
$this->obj_IgSmarty->addScriptLoad(IgepSmarty::getJsLanzarFocusChanged(),'IGEP');
$actionForward = $actionMapping->get('correcto');
}
else {
$actionForward = new ActionForward('IgepErrorValidacion');
$actionForward->put('IGEPclaseManejadora',$this->getClaseActual());
}
break;
//Acción que se lanza al pulsar el botón borrar de un panel. Borra los registros seleccionados.
case 'borrar':
//En las tablas de la ventanas de 3 paneles
$this->comunica->construirArrayBorrar();
$resultado = $this->borrar();
if($resultado==0){
$actionForward = $actionMapping->get('correcto');
if(isset($this->str_nombrePadre))
$this->recargarDesdeHijo();
else{
$this->buscar();
if(count($this->obj_ultimaConsulta)>0) {
$actionForward = $actionMapping->get('correcto');
}
else{
$this->obj_ultimaConsulta = null;
$this->obj_mensaje = new IgepMensaje('IGEP-20');
$actionForward = $actionMapping->get('sinDatos');
}
}
}
else {
$actionForward = new ActionForward('IgepErrorValidacion');
$actionForward->put('IGEPclaseManejadora',$this->getClaseActual());
}
break;
//Acción que se lanza al paginar en un maestro para recargar los detalles
case 'recargar':
//Capturamos los datos de la fila Seleccionada
$this->comunica->construirArraySeleccionar();
/*Recogida de los datos de phrame para montar el where de la consulta con los datos del padre*/
$this->comunica->setOperacion('seleccionar');
$this->int_filaActual = $this->comunica->dameFilaActual();
$m_datosPadreTpl = $this->comunica->getAllTuplas();
$resultado = $this->recargar($m_datosPadreTpl);
if($resultado==0)
$actionForward = $actionMapping->get('correcto');
else
$actionForward = $actionMapping->get('error');
break;
//Acción que realiza las tres operaciones básicas de un mantenimiento: Insertar, Borrar y Modificar.
case 'operarBD':
$hayDatos = 0;
$this->comunica->construirArrays();
$resultado = $this->borrar();
if ($resultado==0) {
$resultado = $this->modificar();
if ($resultado==0) {
$resultado = $this->insertar();
}
}
//Si el resultado es correcto
if($resultado==0){
//Hay que volver a realizar la consulta del panel
//Si es un detalle
if(isset($this->str_nombrePadre)) {
$this->recargarDesdeHijo();
$actionForward = $actionMapping->get('correcto');
}
else {
//Si no es un detalle
$this->buscar();
$hayDatos = count($this->obj_ultimaConsulta);
//Si se trata de un maestro (tiene paneles dependientes)
if(isset($this->v_hijos)){
$this->int_filaActual = $this->comunica->dameFilaActual();
$filaActiva[0] = $this->obj_ultimaConsulta[$this->int_filaActual];
$this->recargar($filaActiva);
}
if($hayDatos>0) {
$actionForward = $actionMapping->get('correcto');
}
else{
unset($this->obj_ultimaConsulta);
if(empty($this->obj_mensaje))
$this->obj_mensaje = new IgepMensaje('IGEP-20');
$actionForward = $actionMapping->get('sinDatos');
}
}
}//Fin de resultado == 0
else {
$actionForward = new ActionForward('IgepErrorValidacion');
$actionForward->put('IGEPclaseManejadora',$this->getClaseActual());
}
break;
//Acción que elimina el contenido de la última consulta y de la última edición
case 'cancelarTodo':
unset($this->str_whereFiltro);
unset($this->str_whereFiltroEdicion);
unset($this->obj_ultimaConsulta);
unset($this->obj_ultimaEdicion);
//Si se trata de un maestro (tiene paneles dependientes unset a todos los hijos)
if(isset($this->v_hijos)){
foreach ($this->v_hijos as $claseHija => $val)
IgepSession::borraPanel($claseHija);
}
$actionForward = $actionMapping->get('correcto');
break;
//Acción que elimina el contenido de la última edición
case 'cancelarEdicion':
unset($this->str_whereFiltroEdicion);
unset($this->obj_ultimaEdicion);
$actionForward = $actionMapping->get('correcto');
break;
/*SOLO PARA LA UN PANEL TRES PESTAÑAS*/
case 'modificar':
$this->comunica->construirArrays();
$resultado = $this->modificar();
if($resultado==0){
if(isset($this->str_nombrePadre))
$this->recargarDesdeHijo();
else
$this->buscar();
$this->editar();
$actionForward = $actionMapping->get('correcto');
}
else {
$actionForward = new ActionForward('IgepErrorValidacion');
$actionForward->put('IGEPclaseManejadora',$this->getClaseActual());
}
break;
/*SOLO PARA LA UN PANEL TRES PESTAÑAS*/
case 'insertar':
$this->comunica->construirArrays();
$resultado = $this->insertar();
if($resultado==0){
//Las líneas siguientes modifican el filtro de busqueda para que incluya las nuevas tuplas
if(!isset($this->str_nombrePadre)) {
$tuplas = $this->comunica->dameDatos('insertar',$this->v_tablas[0]->getTabla());
foreach($tuplas as $tupla){
$nuevaTupla = $this->obj_conexion->construirWhere($tupla,'');
}
if(!empty($this->str_whereFiltro))
$this->str_whereFiltro.= ' OR ';
else
$this->str_whereFiltro.= ' WHERE ';
$this->str_whereFiltro.= '('.$nuevaTupla.')';
$this->buscar();
}
else{
$this->recargarDesdeHijo();
}
$actionForward = $actionMapping->get('correcto');
}
else {
$actionForward = new ActionForward('IgepErrorValidacion');
$actionForward->put('IGEPclaseManejadora',$this->getClaseActual());
}
break;
case 'abrirRamaArbol':
$actionForward = $this->obj_arbol->abrirRamaArbol($actionMapping);
break;
case 'cancelarArbol':
$actionForward =$this->obj_arbol->cancelarArbol($actionMapping);
unset($this->obj_arbol);
break;
default:
$this->comunica->construirArraysAccionParticular();
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
$actionForward = $this->accionesParticulares($str_accion, $actionMapping, $comunicaUsuario);
break;
}//Fin switch
$this->limpiarInstancia();
//Guardamos el panel en la SESSION
IgepSession::guardaPanel($this->getClaseActual(),$this);
//Marcamos el nombre del PANEL como panel visitado
IgepSession::_marcarPanelVisitado($this->getClaseActual());
return $actionForward;
}// Fin de perform
/**
* Método que debemos sobreescribir en el caso de que se quieran incorporar acciones particulares para un panel.
* @abstract
*/
function accionesParticulares($str_accion, $actionMapping, $objDatos) {
IgepDebug::setDebug(PANIC,'Se ha intentado ejecutar la acción '.$str_accion.' y no está programada.');
die('Error: La acción '.$str_accion.' no se reconoce.');
}
/*------------------------------METODOS DE LAS ACCIONES------------------------------*/
/**
* Método abstracto que se debe de sobre escribir si se quiere realizar un salto de ventana
* @abstract
*/
function saltoDeVentana($idSalto, $objDatos){
return -1;
}
/**
* Método abstracto que se debe de sobre escribir si se quiere volver deun salto de una ventana
* @abstract
*/
function regresoAVentana($idSalto, $objDatos){
return 0;
}
/**
* Método abstracto que se debe de sobre escribir si se quiere parametrizar la acción nuevo antes de que se lance.
* @abstract
*/
function preNuevo($objDatos){
return 0;
}
/**
* Método abstracto que se ejecuta tras lanzar la acción de nuevo
* @abstract
*/
function postNuevo($objDatos){
return 0;
}
/**
* Método encargado de realizar las operaciones relativas a la acción nuevo
* @access private
*/
function nuevo(){
$this->comunica->setOperacion('postConsultar');
$this->comunica->setArrayOperacion(array($this->v_preInsercionDatos));
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
$valido = $this->preNuevo($comunicaUsuario);
if($valido!= '0') {
return -1;
}
$datosPorDefecto = $comunicaUsuario->getAllTuplas();
foreach ($datosPorDefecto[0] as $campo => $valor)
$this->addDatosPorDefecto($campo,$valor);
//Para vaciar la última edicion -> no permitimos modificar e insertar en la misma ficha
unset($this->obj_ultimaEdicion);
//ATENCION: EN EL CASO DE 3 MODOS TENEMOS QUE INDICAR LA ACCION A REALIZAR Y LOS DATOS PREINSERTADOS.
//Debemos indicar a la ficha que va a insertar
$this->v_datosPresentacion['accionFicha'] = 'insertar';
//Si es un detalle cargamos los pre-insertados del maestro en el panel detalle.
if(isset($this->str_nombrePadre)) {
$vectorHijos = IgepSession::dameVariable($this->str_nombrePadre,'v_hijos');
$filaActualPadre = IgepSession::dameVariable($this->str_nombrePadre,'int_filaActual');
$resultadoConsultaPadre = IgepSession::dameUltimaConsulta($this->str_nombrePadre);
$resFilaPadre = & $resultadoConsultaPadre[$filaActualPadre];
foreach ($vectorHijos[$this->str_claseActual] as $padre => $hijo)
$this->addDatosPorDefecto($hijo,$resFilaPadre[$padre]);
}
$this->postNuevo();
return 0;
}//Fin de nuevo
function preIniciarVentana(){
return 0;
}
/**
* Este método se utiliza en la acción genérica del mismo nombre y básicamente realiza dos acciones:
*
*- Genera todas las listas definidas para el panel y las carga en el objeto v_datosPreinsertar. De modo que si en el panel de búsqueda se quiere incluir una lista,
* en el atributo datos de la misma, debe hacer referéncia a esta estructura.
*- Almacena el valor del módulo actual por si es la primera vez que se entra en una pantalla de dicho módulo.
*
*/
function iniciarVentana($actionMapping){
$valido = $this->preIniciarVentana();
if($valido!= '0') {
$actionForward = $actionMapping->get('incorrecto');
return $actionForward;
}
if(isset($_REQUEST['menuActivo']))
IgepSession::guardaVariable('global','menuActivo',$_REQUEST['menuActivo']);
$actionForward = $actionMapping->get('correcto');
return $actionForward;
}//Fin de IniciarVentana
/*-------------------------- MÉTODOS DE CONSULTA --------------------------*/
/**
* Este método almacenará una cadena que luego se anexará a la WHERE de la consulta a ejecutar. En esa cadena se pueden incluir condiciones especiales como añadir un EXISTS si cierto campo del panel de busqueda está a true.
* @param string str_where contiene la cadena que se quiere concatenar a la WHERE de la consulta
* @return integer
* @abstract
*/
function setParametrosBusqueda($str_where){
if(trim($str_where)!='')
$this->str_whereAdicional = $str_where;
}
/**
* Este método es el método abstracto que ofrece Igep para parametrizar el comportamiento antes lanzar la consulta de busqueda. Su utilización pude ser:
*
*- Añadir condiciones de busqueda especiales a la consulta antes de ejecutarse utilizando el método setParametrosBusqueda
*- Añadir constantes a la consulta antes de que se ejecute con el método addConstante
*- Impedir la ejecución de la consulta si se dan ciertas condiciones. Para ello debe retornar -1. Si se desea se puede crear un IgepMensaje para indicar al usuario el problema.
*- Fijar el límite de la consulta dependiendo de ciertos parámetros. Esto se puede hacer con el método setLimiteConsulta.
*
* IMPORTANTE:: El método debe devolver 0 si todo ha ido bien. En caso contrario -1 (es valido cualquier valor distinto de 0, pero recomendamos -1).
* @param array Vector que contiene los valores de los campos que ha introducido el usuario en el panel de busqueda.
* @return integer
* @abstract
*/
function preBuscar(& $objDatos){
return 0;
}
/**
* Este método es el método abstracto que ofrece Igep para parametrizar el comportamiento de la busqueda una vez se ha realizado la consulta. Su utilización pude ser:
*
*- Añadir columnas al DB:Result obtenido en la consulta
*- Modificar los valores obtenidos en la consulta antes de visualizarse.
*
* IMPORTANTE:: Si se quiere interrumpir la ejecución de la Busqueda, el programador debe utilizar el método setError para indicar que se ha producido un error.
* @param array Matriz de datos que contiene el resultado de la consulta realizada.
* @return integer
* @abstract
*/
function postBuscar(& $objDatos){
return 0;
}
/**
* Método encargado de realizar las preOperaciones de busqueda cuando el panel no tiene select
* @access private
*/
function construirConsultaSinSelect(){
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
$valido = $this->preBuscar($comunicaUsuario);
if($valido!= '0') {
return -1;
}
return 0;
}
/**
* Método encargado de realizar las operaciones de busqueda cuando el panel no tiene select
* @access private
*/
function buscarSinSelect(){
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
$this->comunica->setOperacion('postConsultar');
$this->comunica->setArrayOperacion($this->obj_ultimaConsulta);
$this->postBuscar($comunicaUsuario);
$this->obj_ultimaConsulta = $comunicaUsuario->getAllTuplas();
if($this->obj_errorNegocio->hayError()){
//La consulta es erronea.
$this->obj_errorNegocio->setMsjError($this->obj_mensaje =new IgepMensaje());
return -1;
}
else {
//Para que adapte los datos que vienen de la Base de datos a los requerimientos de la presentación.
//Tratamiento de listas
if (isset($this->v_listas))
$this->obj_ultimaConsulta =$this->generarListas($this->obj_ultimaConsulta);
return 0;
}
}//Fin de buscarSinSelect
/**
* Método que inicializa las variables para realizar la consulta correspondiente al panel de filtro.
* Genera la Where a partir de los parámetros introducidos y modifica el filtro activo.
*
* @access private
*/
function construirConsulta(){
if(isset($_REQUEST['menuActivo']))
IgepSession::guardaVariable('global','menuActivo',$_REQUEST['menuActivo']);
if(empty($this->comunica))
$this->comunica = new IgepComunicacion($this->matching,$this->getDSN(),$this->v_descCamposPanel);
$this->comunica->setOperacion('buscar');
$this->comunica->construirArrayBuscar();
//Comprobamos si tiene el parámetro str_select. Si no lo tiene ejecutamos buscarSinSelect
if($this->str_select=='')
return $this->construirConsultaSinSelect();
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
//Ejecutamos la función preBuscar donde el usuario puede cargar ciertas cosas.
$valido = $this->preBuscar($comunicaUsuario);
if($valido!= '0') {
return -1;
}
$m_datos = $this->comunica->dameDatos('buscar');
//Componemos la WHERE de la consulta.
if (isset($m_datos)) {
$str_where = '';
foreach($m_datos as $v_datos) {
$str_where = $this->obj_conexion->construirWhereConLike($v_datos,$str_where,$this->getTipoConsulta());
}//Fin de foreach
}
//Mezclamos las dos partes de la where
$str_where = $this->obj_conexion->combinarWhere(array($str_where,$this->str_where,$this->str_whereAdicional));
$this->str_whereAdicional = '';
//Almacenamos la última where realizada
$this->str_whereFiltro = $str_where;
//Si tenemos constantes se las concatenamos a la SELECT
if($this->str_SelectConstantes!=''){
$posFrom = strpos(strtolower($this->str_select),' from');
$this->str_select = substr_replace($this->str_select,$this->str_SelectConstantes,$posFrom,0);
}
return 0;
}
/**
* Método encargado de realizar las consultas que se almacenan en el obj_ultimaConsulta
* @access private
*/
function buscar(){
//Comprobamos si tiene el parámetro str_select. Si no lo tiene ejecutamos buscarSinSelect
if($this->str_select=='')
return $this->buscarSinSelect();
//Añadimos el Order By
if (isset($this->str_orderBy))
$orden = ' ORDER BY '.$this->str_orderBy;
$str_where = $this->str_whereFiltro;
//Añadimos el límite de la consulta
$limite = $this->obj_conexion->construirLimite($str_where,$this->int_limiteConsulta);
//Realizamos la Consulta
$consultaActual = $this->str_select.$str_where.$orden.$limite;
$this->obj_ultimaConsulta = $this->obj_conexion->consultar($consultaActual);
//Mostramos un mensaje que dice que se ha pasado del límite
if(count($this->obj_ultimaConsulta)==$this->int_limiteConsulta){
$this->obj_mensaje = new IgepMensaje('IGEP-14',array($this->int_limiteConsulta));
}
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
//Pasamos a guardamos los datos q hemos obtenido de la consulta
//Si no hay ningun error ejecutamos el postBuscar
if(!DB::isError($this->obj_ultimaConsulta)){
$this->comunica->setOperacion('postConsultar');
$this->comunica->setArrayOperacion($this->obj_ultimaConsulta);
$this->postBuscar($comunicaUsuario);
$this->obj_ultimaConsulta = $comunicaUsuario->getAllTuplas();
}
if(DB::isError($this->obj_ultimaConsulta) or $this->obj_errorNegocio->hayError()){
//La consulta es erronea.
$consultaActual = str_replace("\n",' ',$consultaActual);
$consultaActual = str_replace("'","\'",$consultaActual);
$consultaActual = str_replace("\"","\\\"",$consultaActual);
$mensajeError[0] = 'La consulta es:
'.$consultaActual;
$this->showMensaje('IGEP-15',$mensajeError);
return -1;
}
else {
if (count($this->obj_ultimaConsulta)>0) {
//La consulta es correcta ha devuelto datos
//Para que adapte los datos que vienen de la Base de datos a los requerimientos de la presentación.
$this->obj_conexion->presentaDatos($this->obj_ultimaConsulta, $this->v_camposDecimales);
//Tratamiento de listas
if (isset($this->v_listas))
$this->obj_ultimaConsulta =$this->generarListas($this->obj_ultimaConsulta);
return 0;
}
else {
//La consulta es correcta pero no ha devuelto datos
if($this->obj_mensaje==null)
$this->showMensaje('IGEP-10');
return -2;
}
}//Fin del else
}// Fin de buscar
function preRecargar($objDatos){ //selección del Padre
return 0;
}
function postRecargar(& $objDatos){ //obj_ultimaConsulta
return 0;
}
/**
* Método encargado de realizar las operaciones de busqueda cuando el panel no tiene select
* @access private
*/
function recargarSinSelect($comunicaUsuario){
$valido = $this->preRecargar($comunicaUsuario);
if($valido!= '0') {
return -1;
}
$this->comunica->setOperacion('postConsultar');
$this->comunica->setArrayOperacion($this->obj_ultimaConsulta);
$this->postRecargar($comunicaUsuario);
$this->obj_ultimaConsulta = $comunicaUsuario->getAllTuplas();
if($this->obj_errorNegocio->hayError()){
//La consulta es erronea.
$this->obj_errorNegocio->setMsjError($this->obj_mensaje =new IgepMensaje());
return -1;
}
else {
//Tratamiento de listas
if (isset($this->v_listas))
$this->obj_ultimaConsulta =$this->generarListas($this->obj_ultimaConsulta);
return 0;
}
}
/**
* Este método realiza la recarga desde el padre de todos sus hijos
* @access private
*/
function recargar($m_datosPadreTpl){
//buscamos los datos
if (!empty($m_datosPadreTpl)){
//Para cada uno de los detalles
foreach($this->v_hijos as $nombreClaseHija => $correspondenciaClaseHija){
//Solo recargamos si es el panel activo
if($nombreClaseHija == $this->panelDetalleActivo){
//Creamos las instancias de la clase hija
if(IgepSession::existePanel($nombreClaseHija)){
$obj_claseHija = IgepSession::damePanel($nombreClaseHija);
$obj_claseHija->regenerarInstancia();
}
else{
IgepDebug::setDebug(DEBUG_IGEP,'Creamos una instancia de la clase '.$nombreClaseHija);
$obj_claseHija = new $nombreClaseHija;
}
//Para la clase hija vamos a insertar el array de seleccionados del padre
$obj_claseHija->comunica = new IgepComunicacion($obj_claseHija->matching,$obj_claseHija->obj_conexion->getDsn(),$obj_claseHija->v_descCamposPanel);
$obj_claseHija->comunica->setOperacion('seleccionarPadre');
$obj_claseHija->comunica->setArrayOperacion($m_datosPadreTpl);
$comunicaUsuario = new IgepComunicaUsuario($obj_claseHija->comunica,$obj_claseHija->v_preInsercionDatos,$obj_claseHija->v_listas);
//Si no tiene Select ejecutamos buscarSinSelect
if($obj_claseHija->str_select==''){
$resultado = $obj_claseHija->recargarSinSelect($comunicaUsuario);
IgepSession::guardaPanel($nombreClaseHija,$obj_claseHija);
}
else{
//Ejecutamos el evento de preRecargar
$valido = $obj_claseHija->preRecargar($comunicaUsuario);
if($valido!= '0') {
//Si el programador ha insertado un mensaje lo guardamos en el panel maestro.
$this->obj_mensaje =$obj_claseHija->obj_mensaje;
return -1;
}
$v_datos = array();
foreach ($correspondenciaClaseHija as $padre => $hijo){
$filapadre = array_keys($m_datosPadreTpl);
$tablahijo = $obj_claseHija->matching[$hijo]['tabla'];
$campohijo = $obj_claseHija->matching[$hijo]['campo'];
$campoConsultaHijo= $tablahijo.".".$campohijo;
$v_datos[$campoConsultaHijo] = $m_datosPadreTpl[$filapadre[0]][$padre];
}
//Componemos la WHERE de la consulta.
$str_where = $this->obj_conexion->construirWhere($v_datos,'');
//Cuando no hay datos para el where dara error
$str_where = $this->obj_conexion->combinarWhere(array($str_where,$obj_claseHija->str_where));
//dejo el ordeby de momento
if (isset($obj_claseHija->str_orderBy))
$orden = ' ORDER BY '.$obj_claseHija->str_orderBy;
$obj_claseHija->obj_ultimaConsulta = $this->obj_conexion->consultar($obj_claseHija->str_select.$str_where.$orden);
//Lanzamos el postBuscar si no hay errores
if(!$this->obj_errorNegocio->hayError()){
$obj_claseHija->comunica->setOperacion('postConsultar');
$obj_claseHija->comunica->setArrayOperacion($obj_claseHija->obj_ultimaConsulta);
$obj_claseHija->postRecargar($comunicaUsuario);
$obj_claseHija->obj_ultimaConsulta = $comunicaUsuario->getAllTuplas();
}
//Comprobación de Errores
$errores = $this->obj_errorNegocio->hayError();
if($errores) {
$this->showMensaje('IGEP-13', $this->obj_errorNegocio->getDescErrorDB());
$this->obj_errorNegocio->limpiarError();
//Si hay error paramos la recargar devolviendo el Forward de error.
return -1;
}
else {
//Guardamos los datos
//Para que adapte los datos que vienen de la Base de datos a los requerimientos de la presentación.
$this->obj_conexion->presentaDatos($obj_claseHija->obj_ultimaConsulta,$obj_claseHija->v_camposDecimales);
//Tratamiento para las listas
if (isset($obj_claseHija->v_listas))
$obj_claseHija->obj_ultimaConsulta =$obj_claseHija->generarListas($obj_claseHija->obj_ultimaConsulta);
$obj_claseHija->limpiarInstancia();
IgepSession::guardaPanel($nombreClaseHija,$obj_claseHija);
$resultado = 0;
}
}//Fin del else indica que tiene select
IgepSession::_marcarPanelVisitado($nombreClaseHija);
} //Fin del if (si es el panel activo)
}//Fin del Foreach de para cada hijo
}//Fin del If
return $resultado;
}
/**
* Método encargado de realizar la recarga desde un hijo. Como su nombre indica se ejecuta cuando se ha realizado una operación sobre un detalle.
* Entonces este lanza para realizar la busqueda con los valores del padre. Lógicamente este método se suele llamar desde views.
* @access private
*/
function recargarDesdeHijo(){
//Cogemos la referencia del padre de la Session
$obj_padre = IgepSession::damePanel($this->str_nombrePadre);
if (isset($obj_padre)){
$m_datosPadre = $obj_padre->obj_ultimaConsulta;
$this->int_filaActual = IgepSession::dameVariable($this->str_claseActual,'int_filaActual');
foreach ($obj_padre->v_hijos[$this->str_claseActual] as $padre => $hijo){
//creamos el array de datos que pasamos a la Where de la consulta.
$filapadre = $obj_padre->int_filaActual;
$tablahijo = $this->matching[$hijo]['tabla'];
$campohijo = $this->matching[$hijo]['campo'];
$campoConsultaHijo= $tablahijo.'.'.$campohijo;
//Este será el array que construimos para la construcción de la Where
$v_datos[$campoConsultaHijo] = $m_datosPadre[$filapadre][$padre];
//Este array lo construimos para pasarlo al preRecargar
$m_datosTplPadre[$filapadre][$hijo] = & $v_datos[$campoConsultaHijo];
}
$this->comunica = new IgepComunicacion($this->matching,$this->obj_conexion->getDsn(),$this->v_descCamposPanel);
$this->comunica->setOperacion('selecionarPadre');
$this->comunica->setArrayOperacion($m_datosTplPadre);
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
//Si no tiene Select ejecutamos buscarSinSelect
if($this->str_select==''){
return $this->recargarSinSelect($comunicaUsuario);
}
//Ejecutamos la función preRecargar donde el usuario puede cargar ciertas cosas.
$valido = $this->preRecargar($comunicaUsuario);
if($valido!= '0'){
return -1;
}
//Componemos la WHERE de la consulta.
$str_where = $this->obj_conexion->construirWhere($v_datos,$str_where);
//Cuando no hay datos para el where dara error
$str_where = $this->obj_conexion->combinarWhere(array($str_where,$this->str_where));
//dejo el ordeby de momento
if (isset($this->str_orderBy))
$orden = ' ORDER BY '.$this->str_orderBy;
$this->obj_ultimaConsulta = $this->obj_conexion->consultar($this->str_select.$str_where.$orden);
if(!DB::isError($this->obj_ultimaConsulta)){
$this->comunica->setOperacion('postConsultar');
$this->comunica->setArrayOperacion($this->obj_ultimaConsulta);
$this->postRecargar($comunicaUsuario);
$this->obj_ultimaConsulta = $this->comunica->getAllTuplas();
}
//Guardamos los datos
//Para que adapte los datos que vienen de la Base de datos a los requerimientos de la presentación.
$this->obj_conexion->presentaDatos($this->obj_ultimaConsulta, $this->v_camposDecimales);
//Tratamiento para las listas
if (isset($this->v_listas))
$this->obj_ultimaConsulta =$this->generarListas($this->obj_ultimaConsulta);
if (count($this->obj_ultimaConsulta)>0)
return 0;
else
return -1;
} //Fin del if
return -1;
} //Fin de recargarDesdeHijo
/*----------------------- FUNCIONES DE OPERACIONES ----------------------*/
/**
* Este método es el método abstracto que ofrece Igep para realizar las validaciones previas antes de la Inserción. Su utilización pude ser:
*
*- Impedir la ejecución de la inserción. Para ello debe retornar -1. Si se desea se puede crear un IgepMensaje para indicar al usuario el problema.
*- Calcular un número de secuencia de un campo de la clave primaria. Ver métodos calcularSecuencia y calcularSecuenciaBD
*
* IMPORTANTE:: El método debe devolver 0 si todo ha ido bien. En caso contrario -1 (es valido cualquier valor distinto de 0, pero recomendamos -1).
* @return integer
* @abstract
*/
function preInsertar($objDatos) {
return 0;
}
/**
* Este método es el método abstracto que ofrece Igep para realizar operaciones una vez realiza la acción de insertar. Todo lo que se realice en este evento está
* incluido en la TRANSACTION por lo que podrá cancelarse la operación. Su utilización pude ser:
*
*- Si se quiere insertar N tuplas en una tabla con relación 1:N con la tabla sobre la que ya hemos insertado. Si no se puede realizar la operación, podemos cancelar toda la transacción.
*
*
* IMPORTANTE:: Si se quiere interrumpir la ejecución de la Insercion, el programador debe utilizar el método setError para indicar que se ha producido un error.
* @return integer
* @abstract
*/
function postInsertar($objDatos){
return 0;
}
/**
* Método encargado de realizar los INSERTs
* @access private
*/
function insertar(){
//Fijamos la operación a insertar
$this->comunica->setOperacion('insertar');
//Comprobamos si hay datos para operar
if(!$this->comunica->hayDatos())
return 0;
/*Validaciones de los datos*/
//Validaciones Igep
$datos = $this->comunica->getAllTuplas();
$validacionIgep = $this->comunica->validaDatos();
if($validacionIgep!= '0') {
$this->showMensaje('IGEP-17',array($validacionIgep));
return -1;
}
//Validaciones del Usuario
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
$valido = $this->preInsertar($comunicaUsuario);
if($valido!= '0') {
return -1;
}
/*Empezamos la transacción*/
$this->obj_conexion->empezarTransaccion();
foreach($this->v_tablas as $tabla) {
$m_datos = $this->comunica->dameDatos('insertar',$tabla->getTabla());
$tabla->insertar($m_datos);
}
//Realizamos la operación de Post-Inserción si no hay errores.
$errores = $this->obj_errorNegocio->hayError();
if(!$errores){
$this->comunica->reset();
$this->postInsertar($comunicaUsuario);
}
/*Comprobación de errores*/
$errores = $this->obj_errorNegocio->hayError();
$this->obj_conexion->acabarTransaccion($errores);
if($errores) {
$this->obj_errorNegocio->setMsjError($this->obj_mensaje =new IgepMensaje());
return -1;
}
else
return 0;
}// Fin de insertar
/**
* Este método es el método abstracto que ofrece Igep para realizar las validaciones previas antes de la Modificación. Su utilización pude ser:
*
*- Impedir la ejecución de la modificación por que no se cumple cierta regla de validación. Para ello debe retornar -1. Si se desea se puede crear un IgepMensaje para indicar al usuario el problema.
*- Modificar los datos antes de que se vayan a actualizar.
*
IMPORTANTE:: El método debe devolver 0 si todo ha ido bien. En caso contrario -1 (es valido cualquier valor distinto de 0, pero recomendamos -1).
* @return interger
* @abstract
*/
function preModificar($datos) {
return 0;
}
/**
* Este método es el método abstracto que ofrece Igep para realizar operaciones una vez realiza la acción de modificar. Todo lo que se realice en este evento está
* incluido en la TRANSACTION por lo que podrá cancelarse la operación. Su utilización pude ser:
*
*- Si se quiere modificar N tuplas en una tabla con relación 1:N con la tabla sobre la que ya hemos modificado. Si no se puede realizar la operación, podemos cancelar toda la transacción.
*
*
* IMPORTANTE:: Si se quiere interrumpir la ejecución de la modificación, el programador debe utilizar el método setError para indicar que se ha producido un error.
* @return integer
* @abstract
*/
function postModificar($m_datos) {
return 0;
}
/**
* Método encargado de realizar las UPDATEs
* @access private
*/
function modificar(){
//Fijamos la operación a actualizar
$this->comunica->setOperacion('actualizar');
/*Comprobamos si hay datos para operar*/
if(!$this->comunica->hayDatos())
return 0;
/*Validaciones de los datos*/
$datos = $this->comunica->getAllTuplas();
$validacionIgep = $this->comunica->validaDatos();
if($validacionIgep!= '0') {
$this->showMensaje('IGEP-17',array($validacionIgep));
return -1;
}
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
$valido = $this->preModificar($comunicaUsuario);
if($valido!= '0') {
return -1;
}
/*Empezamos transacción*/
$this->obj_conexion->empezarTransaccion();
foreach($this->v_tablas as $tabla) {
$m_datos = $this->comunica->dameDatos('modificar',$tabla->getTabla());
$m_datosant = $this->comunica->dameDatosAntiguos($tabla->getTabla());
foreach($m_datos as $indice => $v_datos) {
$tabla->actualizar($v_datos, $m_datosant[$indice]);
}
}
//Lanzamos el postModificar si no ha habido errores
$errores = $this->obj_errorNegocio->hayError();
if(!$errores){
$this->comunica->reset();
$this->postModificar($comunicaUsuario);
}
/*Comprobación de errores*/
$errores = $this->obj_errorNegocio->hayError();
$this->obj_conexion->acabarTransaccion($errores);
if($errores){
$this->obj_errorNegocio->setMsjError($this->obj_mensaje =new IgepMensaje());
return -1;
}
else{
$this->obj_IgSmarty->addScriptLoad(IgepSmarty::getJsFijarFichaActiva($this->comunica->damePanelActivo(),$this->str_claseActual,$this->comunica->dameFilaActual()),'IGEP');
return 0;
}
}//Fin de modificar
/**
* Este método es el método abstracto que ofrece Igep para parametrizar el comportamiento antes lanzar la consulta del panel de Edición. Su utilización pude ser:
*
*- Añadir condiciones de busqueda especiales a la consulta de Edición antes de ejecutarse.
*- Añadir constantes a la consulta antes de que se ejecute
*- Impedir la ejecución de la consulta si se dan ciertas condiciones. Para ello debe retornar -1. Si se desea se puede crear un IgepMensaje para indicar al usuario el problema.
*
* IMPORTANTE:: El método debe devolver 0 si todo ha ido bien. En caso contrario -1 (es valido cualquier valor distinto de 0, pero recomendamos -1).
*/
function preEditar($m_datos){
return 0;
}
/**
* Este método es el método abstracto que ofrece Igep para parametrizar el comportamiento de la edicion una vez se ha realizado la consulta. Su utilización pude ser:
*
*- Añadir columnas al DB:Result obtenido en la consulta de Edición
*- Modificar los valores obtenidos en la consulta antes de visualizarse.
*
* IMPORTANTE:: Si se quiere interrumpir la ejecución de la Edición, el programador debe utilizar el método setError para indicar que se ha producido un error.
* @return integer
* @abstract
*/
function postEditar(& $m_datos){
return 0;
}
/**
* Método que inicializa las variables para realizar la consulta correspondiente al panel de edicion.
* Calcula la Where que se debe aplicar a la consulta de edición y cambia el filtro de edicion.
*
* @access private
*/
function construirConsultaEditar(){
//Si no hay datos finalizamos
if(!$this->comunica->hayDatos()){
$this->showMensaje('IGEP-16');
return -1;
}
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
$valido = $this->preEditar($comunicaUsuario);
if($valido!= '0') {
return -1;
}
$m_datos = $this->comunica->dameDatos('editar');
//Inicializamos las filas Seleccionadas
$this->v_checksMarcados = array();
$m_datosTpl = $comunicaUsuario->getAlltuplas();
$this->nombreCheckTabla = $this->comunica->nombreCheckTabla;
$hayCamposClave = count($this->v_camposClave);
foreach($m_datos as $indice=>$v_datos) {
if($hayCamposClave>0) {
foreach($this->v_camposClave as $campoTpl){
$campoBD = $this->matching[$campoTpl]['tabla'].'.'.$this->matching[$campoTpl]['campo'];
$v_datosCP[$campoBD] = $v_datos[$campoBD];
$v_filaSeleccionada[$campoTpl] = $v_datos[$campoBD];
}
$str_where = $this->obj_conexion->construirWhere($v_datosCP,$str_where);
//Añadimos al vector de filas seleccionadas
array_push($this->v_checksMarcados,$v_filaSeleccionada);
}
else
$str_where = $this->obj_conexion->construirWhere($v_datos,$str_where);
}
$str_where = $this->obj_conexion->combinarWhere(array("($str_where)",$this->str_whereEditar));
if($this->str_orderByEditar!='')
$orderBy = ' ORDER BY '.$this->str_orderByEditar;
$this->str_whereFiltroEdicion = $str_where.$orderBy;
return 0;
}
/**
* Método encargado de realizar las consultas de Edición que se almacena en el obj_ultimaEdicion.
* @access private
*/
function editar(){
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
$consultaActual = $this->str_selectEditar.$this->str_whereFiltroEdicion;
$this->obj_ultimaEdicion = $this->obj_conexion->consultar($consultaActual);
//Si no hay errores entonces ejecutamos la postEdición
if(!$this->obj_errorNegocio->hayError()){
$this->comunica->setOperacion('postConsultar');
$this->comunica->setArrayOperacion($this->obj_ultimaEdicion);
$this->postEditar($comunicaUsuario);
}
if(!$this->obj_errorNegocio->hayError()){
//Guardamos los resultados.
$this->obj_ultimaEdicion = $this->comunica->getAllTuplas();
//Para que adapte los datos que vienen de la Base de datos a los requerimientos de la presentación.
$this->obj_conexion->presentaDatos($this->obj_ultimaEdicion, $this->v_camposDecimales);
//Tratamiento para las listas. Hay que modificar el DB:Result si tiene listas desplegables.
if (isset($this->v_listas))
$this->obj_ultimaEdicion = $this->generarListas($this->obj_ultimaEdicion);
//Interacción con Pantalla
$this->v_datosPresentacion['accionFicha'] = 'modificar';
//PARCHE: Hacemos referencia a $this->nombreCheckTabla. Pendiente de cambios en Plugin
//Tenemos que cargar el JS de los checks marcados
$filasSeleccionadas = $this->_getFilasSeleccionadas($this->nombreCheckTabla);
$this->obj_IgSmarty->addScriptLoad(IgepSmarty::getJsChecksMarcados($filasSeleccionadas),'IGEP');
return 0;
}
else{
//Si hay algún error lo indicamos con el mensaje
$this->obj_errorNegocio->setMsjError($this->obj_mensaje =new IgepMensaje());
return -1;
}
}//Fin de editar
function _getFilasSeleccionadas($nombreCheck){
$arrayFilasSeleccionadasTpl = array();
$filasMarcadasNegocio = $this->v_checksMarcados;
foreach($this->obj_ultimaConsulta as $indiceFila => $fila){
foreach($filasMarcadasNegocio as $indiceSeleccionda => $filaSeleccionada){
$distinta = false;
foreach($filaSeleccionada as $nomCampo => $valorCampo){
if($fila[$nomCampo]!= $valorCampo){
$distinta = true;
break;
}
}
//Esta tupla es marcable
if($distinta==false){
array_push($arrayFilasSeleccionadasTpl,$nombreCheck.$indiceFila);
unset($filasMarcadasNegocio[$indiceSeleccionda]);
break;
}
}
}
return $arrayFilasSeleccionadasTpl;
}
/**
* Este método es el método abstracto que ofrece Igep para realizar las validaciones previas antes del borrado. Su utilización pude ser:
*
*- Impedir la ejecución del DELETE porque no se cumple cierta regla de validación. Para ello debe retornar -1. Si se desea se puede crear un IgepMensaje para indicar al usuario el problema.
*
* IMPORTANTE:: El método debe devolver 0 si todo ha ido bien. En caso contrario -1 (es valido cualquier valor distinto de 0, pero recomendamos -1).
* @return integer
* @abstract
*/
function preBorrar($m_datos) {
return 0;
}
/**
* Este método es el método abstracto que ofrece Igep para realizar operaciones una vez realiza la acción de borrar. Todo lo que se realice en este evento está
* incluido en la TRANSACTION por lo que podrá cancelarse la operación. Su utilización pude ser:
*
*- Si se quiere borrar N tuplas en una tabla con relación 1:N con la tabla sobre la que ya hemos borrado. Si no se puede realizar la operación, podemos cancelar toda la transacción.
*
*
* IMPORTANTE:: Si se quiere interrumpir la ejecución del borrado, el programador debe utilizar el método setError para indicar que se ha producido un error.
* @return integer
* @abstract
*/
function postBorrar(){
return 0;
}
/**
* Método encargado de realizar los DELETEs
* @access private
*/
function borrar(){
//Fijamos la operación a borrar
$this->comunica->setOperacion('borrar');
//Comprobamos si hay datos para operar
if(!$this->comunica->hayDatos())
return 0;
/*Validaciones de los datos*/
//Recogemos los datos en formato tpl
$comunicaUsuario = new IgepComunicaUsuario($this->comunica,$this->v_preInsercionDatos,$this->v_listas);
$valido = $this->preBorrar($comunicaUsuario);
if($valido!= '0') {
return -1;
}
$this->obj_conexion->empezarTransaccion();
foreach($this->v_tablas as $tabla) {
$m_datos = $this->comunica->dameDatos('borrar',$tabla->getTabla());
foreach ($m_datos as $v_datos)
$tabla->borrar($v_datos);
}
//Lanzamos el postBorrar si no ha habido errores
$errores = $this->obj_errorNegocio->hayError();
if(!$errores){
$this->comunica->reset();
$this->postBorrar($comunicaUsuario);
}
//Comprobación de errores
$errores = $this->obj_errorNegocio->hayError();
$this->obj_conexion->acabarTransaccion($errores);
if($errores) {
$this->obj_errorNegocio->setMsjError($this->obj_mensaje =new IgepMensaje());
return -1;
}
else
return 0;
}//Fin de borrar
function _recalcularListasDependientes($destinos,$destinosAdaptados){
$opciones = '';
foreach($destinos as $indice => $campoRellenar) {
if(isset($this->v_listas[$campoRellenar])) {
$listas = $this->v_listas;
$objLista = & $listas[$campoRellenar];
if($objLista->hayDependencia()){
$resultado = $objLista->construyeLista($this->comunica->currentTupla());
$opciones.= IgepSmarty::getJsLista($destinosAdaptados[$indice], $resultado);
}
} //Fin de listas
}//Fin del foreach de todas las listas
return $opciones;
}
function _accionesInterfaz($campoDisparador, $campoOrigenHtml) {
$jsActualizaCampo = '';
if(isset($this->v_validacionesUsuario[$campoDisparador])) {
//Buscamos la función a ejecutar
$funcionValidacion = $this->v_validacionesUsuario[$campoDisparador]['funcion'];
//Ejecutamos la función de validacion
$comunicaUsuario = new IgepComunicaIU($this->comunica,$this->v_preInsercionDatos,$this->v_listas,$campoOrigenHtml);
$comunicaUsuario->_setCampoDisparador($campoDisparador);
$validacion = $this->$funcionValidacion($comunicaUsuario);
if(isset($this->obj_mensaje))
$jsActualizaCampo.=IgepSmarty::getJsMensaje($this->obj_mensaje);
else {
//En caso de error
if($validacion != 0){
//Si el programador no introduce un mensaje, mostramos el de por defecto
$jsActualizaCampo.=IgepSmarty::getJsMensaje(new IgepMensaje('IGEP-18'));
}
}
$jsActualizaCampo.= $comunicaUsuario->getScript();
}
return $jsActualizaCampo;
}
function preFocusChanged(&$objDatos){
return 0;
}
function postFocusChanged(&$objDatos){
return 0;
}
function _focusChanged($composicionCampos,$filaActual, $filaProxima) {
$jsActualizaCampo='';
$comunicaUsuario = new IgepComunicaIU($this->comunica,$this->v_preInsercionDatos,$this->v_listas,$composicionCampos);
if($filaActual!=-1){
$comunicaUsuario->posicionarEnFicha($filaActual);
$this->preFocusChanged($comunicaUsuario);
}
if($filaProxima!=-1){
$comunicaUsuario->posicionarEnFicha($filaProxima);
$this->postFocusChanged($comunicaUsuario);
}
if(isset($this->obj_mensaje))
$jsActualizaCampo.=IgepSmarty::getJsMensaje($this->obj_mensaje);
$jsActualizaCampo.= $comunicaUsuario->getScript();
return $jsActualizaCampo;
}
/*-------------------------- FUNCIONES AUXILIARES -------------------------*/
/**
* Método encargado de realizar la carga de las listas definidas por el programador
* @access private
*/
function generarListas($res){
if (count($res)>0){
foreach ($this->v_listas as $campo => $lista ){
//Si tenemos la lista calculada previamente... no la volvemos a calcular
if(!$lista->hayDependencia()){
if (is_array($this->v_preInsercionDatos[$campo]))
$res2 = $this->v_preInsercionDatos[$campo];
else
$res2 = $lista->construyeLista();
}
//Comprobamos que el campo esté en el DB:Result que vamos a modificar
if(array_key_exists($campo,$res[0])){
//Si no tiene estructura de lista ya
if(!is_array($res[0][$campo])){
//Realizamos la actualización del DB:Result para cada una sus filas
foreach(array_keys($res) as $indice){
//Si hay dependencia hay que ejecutar la SELECT para cada fila.
if ($lista->hayDependencia()){
$res2 = $lista->construyeLista($res[$indice]);
}//Fin de if de dependencia
//Tratamiento: cogemos el valor y lo marcamos.
$res2['seleccionado'] = $res[$indice][$campo];
unset($res[$indice][$campo]);
$res[$indice][$campo] = $res2;
}//fin del foreach
}
}//fin del if
}//fin de foreach
}//fin del if de count($res)>0
return $res;
} //Fin de generarListas
/**
* Método que limpia de variables inncesarias el objeto actual antes de guardarlo en la SESSION
* @access private
*/
function limpiarInstancia(){
//Esta función se encargará de liberar de carga la instancia de la clase antes de ponerla en la SESSION
unset($this->obj_conexion->obj_conexion);
unset($this->obj_conexion->obj_errorConexion);
unset($this->obj_errorNegocio);
unset($this->v_tablas);
unset($this->comunica);
unset($this->str_SelectConstantes);
}
/**
* Este método devuelve el valor de una secuencia programada en la base de datos
* para la conexión del panel
*
* @param nombreSecuencia string nombre de la secuencia en la BD
* @return integer
*/
function calcularSecuenciaBD($nombreSecuencia){
$res = $this->obj_conexion->calcularSecuenciaBD($nombreSecuencia);
if($this->obj_errorNegocio->hayError()) {
$this->showMensaje('IGEP-12',$this->obj_errorNegocio->getDescErrorDB());
$this->obj_errorNegocio->limpiarError();
return -1;
}
else
return $res;
}
/**
* Este método calcula una secuencia compuesta por varios campos de la misma tabla.
*
* @param tabla string nombre de la tabla de la BD
* @param campoSecuencia string campo del que se quiere obtener la secuencia
* @param camposDependientes array contiene el nombre de los campos de los cuales va a depender la secuencia y sus valores. Estructura [nombreBD] = valor
* @param valorInicial integer Fija el valor inicial que devuelve calcularSecuencia en el caso de que no exístan tuplas en la tabla el valor por defecto es 1
* @return integer
*/
function calcularSecuencia($tabla,$campoSecuencia,$camposDependientes, $valorInicial=1){
$res = $this->obj_conexion->calcularSecuencia($tabla,$campoSecuencia,$camposDependientes, $valorInicial);
if($this->obj_errorNegocio->hayError()) {
$this->showMensaje('IGEP-12',$this->obj_errorNegocio->getDescErrorDB());
$this->obj_errorNegocio->limpiarError();
return -1;
}
else {
if (($res=='')||($res==null)||(!isset($res)))
return $valorInicial;
else
return ($res);
}
}//Fin de funcion calcularSecuencia
/*------------------- FUNCIONES DE AYUDA AL PROGRAMADOR -------------------*/
/**
* Función encargada de indicar a Negocio las características de un campo de una TPL. A partir de esta información, el Negocio y los Plugins
* realizan validaciones de los datos.
*
*@access public
*@param campoTpl corresponde con el nombre del campo en la Tpl
*@param obligatorio indica si el campo es oblicatorio (valor 1) o no (valor 0).
*@param tipo indica el tipo de los datos. Los tipos definidos son: TIPO_CARACTER, TIPO_ENTERO, TIPO_DECIMAL, TIPO_FECHA
*@param longitud indica la capacidad del campo.
*@param parteDecimal en el caso de los tipos decimales, indica la longitud de la parte decimal.
*@return none
*/
function addCampoPanel($campoTpl,$obligatorio,$tipo,$longitud,$parteDecimal=''){
//Comprobamos que no esté duplicado el campo en el Array de descripción de campos
if(isset($this->v_descCamposPanel[$campoTpl])){
IgepDebug::setDebug(PANIC,'Error de Programación: Ha redefinido el campo del Panel '.$campoTpl.'. Revise el fichero '.$this->claseActual.'.php.');
die('Error de Programación: Ha redefinido el campo del Panel '.$campoTpl.'. Revise el fichero '.$this->claseActual.'.php.');
}
if($obligatorio<>1 and $obligatorio<>0){
IgepDebug::setDebug(PANIC,'Error de Programación: Ha definido el campo del Panel '.$campoTpl.' con un valor para de obligatorio fuera de rango. Los valores posibles son [0,1].Revise el fichero '.$this->claseActual.'.php.');
die('Error de Programación: Ha definido el campo del Panel '.$campoTpl.' con un valor para de obligatorio fuera de rango. Los valores posibles son [0,1].Revise el fichero '.$this->claseActual.'.php.');
}
if($tipo!=TIPO_CARACTER and $tipo!=TIPO_ENTERO and $tipo!=TIPO_DECIMAL and $tipo!=TIPO_FECHA){
IgepDebug::setDebug(PANIC,'Error de Programación: Ha definido el campo del Panel '.$campoTpl.' con un valor para de tipo fuera de rango. Consulte en la documentación los tipos posibles.Revise el fichero '.$this->claseActual.'.php.');
die('Error de Programación: Ha definido el campo del Panel '.$campoTpl.' con un valor para de tipo fuera de rango. Consulte en la documentación los tipos posibles.Revise el fichero '.$this->claseActual.'.php.');
}
$this->v_descCamposPanel[$campoTpl] = array("obligatorio" => $obligatorio, "tipo" => $tipo, "longitud"=>$longitud);
if($tipo==TIPO_DECIMAL){
$this->v_descCamposPanel[$campoTpl]['parteDecimal'] = $parteDecimal;
array_push($this->v_camposDecimales,$campoTpl);
}
}//Fin de addCampoPanel
/**
* Función encargada de indicar a Negocio la correspondencia de los campos de la TPL con los campos de la BD.
* En principio sólo deben de indicarse los campos que se almacenarán en la BD.
* @internal Rellena el array de matchin. Tenemos que quitar la referencia al mismo en el caso de editar.
*
* @param campoTpl corresponde con el nombre del campo en la Tpl
* @param campoBD indica el nombre del campo en la tabla de la BD
* @param tablaBD indica el nombre de la tabla a la que corresponde.
* @return none
*/
function addMatching($campoTpl,$campoBD,$tablaBD){
/*Función que enmascara la creación del array de matching*/
//Comprobamos que la tabla está en nuestra lista de tablas
if(!in_array($tablaBD,$this->v_nombreTablas)){
IgepDebug::setDebug(PANIC,'Error de Programación: Se ha definido un Matchig que contiene la tabla '.$tablaBD.' de la BD. Esta tabla no está en la lista de tablas de la clase. Compruebe que la definición de las SELECT está antes que el matching');
die('Error de Programación: Se ha definido un Matchig que contiene la tabla '.$tablaBD.' de la BD. Esta tabla no está en la lista de tablas de la clase. Compruebe que la definición de las SELECT está antes que el matching');
}
//Comprobamos que exista una referencia a ese campo en una SELECT
/*
$cond1 = strpos($this->str_select,$campoTpl);
$cond2 = strpos($this->str_selectEditar,$campoTpl);
if (($cond1===false) and ($cond2===false))
die("Error de Programación: Ha incluido el campo $campoTpl que no tiene ninguna referencia en las SELECT de la clase. Compruebe que la definición de tablas está antes que el matching");
*/
$this->matching[$campoTpl] = array('campo'=>$campoBD,'tabla'=>$tablaBD);
}//Fin de addMatching
/**
* Función encargada de indicar a Negocio que existe una definición de una nueva Ventana Seleccion
* @param obj_ventanaSeleccion objetivo de tipo IgepVentanaSeleccion.
* @return none
*/
function addVentanaSeleccion($obj_ventanaSeleccion){
if(!is_object($obj_ventanaSeleccion)){
IgepDebug::setDebug(PANIC,'Error: Problema al adjuntar la ventana de Selección del campo de la Tpl '.$obj_ventanaSeleccion->getNombreVentana());
die('Error: Problema al adjuntar la ventana de Selección del campo de la Tpl '.$obj_ventanaSeleccion->getNombreVentana());
}
$this->v_ventanasSeleccion[$obj_ventanaSeleccion->getNombreVentana()] = & $obj_ventanaSeleccion;
}//Fin de addVentanaSeleccion
/**
* Función encargada de indicar a Negocio que existe una definición de una nueva Lista
*
* @param obj_lista objetivo de tipo IgepLista.
* @return none
*/
function addLista(& $objLista){
if(!is_object($objLista)){
IgepDebug::setDebug(PANIC,'Error: Problema al adjuntar la lista '.$objLista->getNombre());
die('Error: Problema al adjuntar la lista '.$objLista->getNombre());
}
if($this->str_claseActual==''){
IgepDebug::setDebug(PANIC,'Error: Problema al adjuntar la lista '.$objLista->getNombre().'. Antes de definir las listas debe tener definida la variable de clase str_claseActual en el constructor de la clase.');
die('Error: Problema al adjuntar la lista '.$objLista->getNombre().'. Antes de definir las listas debe tener definida la variable de clase str_claseActual en el constructor de la clase.');
}
if(!$objLista->hayDSN())
$objLista->setDSN($this->getDSN());
$this->v_listas[$objLista->getNombre()] = $objLista;
$resultadoLista = $objLista->construyeLista($this->getDatosPorDefecto());
$this->addDatosPorDefecto($objLista->getNombre(), $resultadoLista);
//En el caso de los datalles puede darse el caso de que no pasemos por phrame (recargarDesdeHijo), y que no ejecutemos el perform. Por eso lo metemos en la SESSION.
$datosPreInsertados = IgepSession::dameVariable($this->str_claseActual,'v_preInsercionDatos');
$datosPreInsertados[$objLista->getNombre()]=$resultadoLista;
IgepSession::guardaVariable($this->str_claseActual,'v_preInsercionDatos',$datosPreInsertados);
}//Fin de addLista
/**
* Función encargada de almacenar de la creación del array de información de la relación de un panel padre y un panel hijo
*
* @param nombreClaseManejadora string nombre de la clase manejadora del Hijo
* @param listaCamposPadre array array con la lista de todos los campos que necesitará el detalle para identificarse
* @param listaCamposHijo array array con la lista de todos los campos que en el hijo hacen referencia a los campos del padre (en el mismo orden que el parámetro anterior).
* @return none
*/
function addHijo($nombreClaseManejadora,$listasCamposPadre,$listasCamposHijo) {
if(!class_exists($nombreClaseManejadora)){
IgepDebug::setDebug(PANIC,'Se ha intentado crear un IgepHijo que no corresponde a una clase de Igep. La clase '.$nombreClaseManejadora.' no es una clase válida');
die('Se ha intentado crear un IgepHijo que no corresponde a una clase de Igep. La clase '.$nombreClaseManejadora.' no es una clase válida');
}
$dependencia = array();
if((!is_array($listasCamposPadre)) or (!is_array($listasCamposHijo)) or (count($listasCamposPadre)!=count($listasCamposHijo))){
IgepDebug::setDebug(PANIC,'Error en la introducción de la dependencia con el panel hijo '.$nombreClaseManejadora.' . Recuerde que debe introducir dos arrays.');
die('Error en la introducción de la dependencia con el panel hijo '.$nombreClaseManejadora.' . Recuerde que debe introducir dos arrays.');
}
$i=0;
for($i=0;$iv_hijos[$nombreClaseManejadora] = $dependencia;
//Fijamos el panel como panel activo
if(empty($this->panelDetalleActivo))
$this->panelDetalleActivo = $nombreClaseManejadora;
}//Fin de addHijo
/**
* Función encargada de almacenar en un panel hijo el nombre del padre (maestro)
*
* @param nombreClaseManejadora string nombre de la clase manejadora del Padre
* @return none
*/
function addPadre($nombreClaseManejadoraPadre) {
if(!class_exists($nombreClaseManejadoraPadre)){
IgepDebug::setDebug(PANIC,'Se ha intentado crear un IgepHijo que no corresponde a una clase de Igep. La clase '.$nombreClaseManejadoraPadre.' no es una clase válida');
die('Se ha intentado crear un IgepHijo que no corresponde a una clase de Igep. La clase '.$nombreClaseManejadoraPadre.' no es una clase válida');
}
$this->str_nombrePadre = $nombreClaseManejadoraPadre;
}
/**
* Función encargada de almacenar constantes que se añaden al DBResult que se muestra en un panel.
* Es importante tener en cuenta que no se pueden añadir constantes en consultas con el operador SQL DISTINCT afectando a todo la tupla.
*
* @param nombre nombre que se le da a la constante
* @param valor valor que va a tomar la constante
* @return none
*/
function addConstante($nombre, $valor){
//La cadena que tiene que guardar es del tipo '$valor' as "$nombre"
if(isset($nombre)&&isset($valor))
$this->str_SelectConstantes.= ", "." '$valor' as \"$nombre\"";
}//Fin de addConstante
/**
* Función encargada de indicar los campos Clave de un panel.
* Es importante tener en cuenta que la definición de los campos clave se utilizará posteriormente en la función de edición.
*
* @param camposClave array que contiene los campos clave del panel.
* @return none
*/
function addCamposClave($camposClave){
foreach($camposClave as $campoTpl){
if(!isset($this->matching[$campoTpl])){
IgepDebug::setDebug(PANIC,'Todos los campos claves tienen que tener matching');
die('Todos los campos claves tienen que tener matching');
}
array_push($this->v_camposClave,$campoTpl);
}
}
/**
* Está funcion se utiliza para asociar funciones PHP desarrolladas por
* el programador a elementos de la interfaz. Dadas las limitaciones
* de la interfaz Web, estás acciones siempre se disparan al perder el
* foco el lelemento de la tpl (interfaz de usuario) elegido como primer
*
* @param campoTpl string indica el nombre del campo de la tpl (interfaz) sobre el que se va a lanzar la validación. Cuando pierda el foco se lanzará la validación.
* @param funcion string Nombre de una función de clase que se ejecutará cuando el elemento de la interfaz pierda el foco.
* @param dependencia array contiene un array de los campos de TPl que son necesarios, a parte del ya indicado en el primer parámetro, para realizar la validación.
* @access public
* @return none
*/
function addAccionInterfaz($campoTpl, $funcion){
$this->v_validacionesUsuario[$campoTpl]['funcion'] = $funcion;
}
/**
* Método encargado de incorporar un componente IgepArbol a una ventana Igep
* @param IgepArbol $arbol Instancia de la clase IgepArbol que se quiere insertar en la ventana
* @access public
* @return none
*/
function addArbol($arbol){
if(!IgepSession::dameVariable($this->str_claseActual,'obj_arbol')){
$arbol->generaXML($this->str_claseActual);
$this->obj_arbol = $arbol;
}
else
$this->obj_arbol = IgepSession::dameVariable($this->str_claseActual,'obj_arbol');
}
/**
* Función que realiza una consulta a la Base de datos con la conexión actual
* Es la función que el programador debe gastar para realizar una consulta SQL
*
* @param string que contiene la consulta.
* @return array devuelve un array si todo ha ido bien o -1 en caso de error.
*/
function consultar($str_consulta){
if(!isset($this->obj_errorNegocio)){
global $g_error;
$g_error =& new IgepError();
$this->obj_errorNegocio = & $g_error;
}
$res = $this->obj_conexion->consultar($str_consulta);
if($this->obj_errorNegocio->hayError()){
//La consulta es erronea.
$this->obj_errorNegocio->setMsjError($this->obj_mensaje =new IgepMensaje());
return -1;
}
return $res;
}
/**
* Función que realiza una operación SQL en la Base de datos con la conexión actual
* Es la función que el programador debe gastar para realizar una operación SQL
*
* @param string que contiene la operación a realizar.
* @return integer devuelve 0 si todo ha ido bien o -1 en caso de error
*/
function operar($str_operacion){
if(!isset($this->obj_errorNegocio)){
global $g_error;
$g_error =& new IgepError();
$this->obj_errorNegocio = & $g_error;
}
$this->obj_conexion->operar($str_operacion);
if($this->obj_errorNegocio->hayError()){
//La consulta es erronea.
$this->obj_errorNegocio->setMsjError($this->obj_mensaje =new IgepMensaje());
return -1;
}
return 0;
}
/**
* Función que debe utilizar el programador para indicar el límite de registros que se pueden recuperar de la base de datos con una consulta.
* Por defecto IGEP tiene un límite de 100.
*
* @param integer número que indica el límite.
* @return none
*/
function setLimiteConsulta($int_limite){
$this->int_limiteConsulta = $int_limite;
}
/**
* Función que fija el nombre de la clase actual
*
* @param $nombre String Nombre de la clase
* @return none
*/
function setClaseActual($nombre){
$this->str_claseActual = $nombre;
}
/**
* Función que fija el nombre de la clase actual
*
* @param $nombre String Nombre de la clase
* @return none
*/
function getClaseActual(){
return $this->str_claseActual;
}
/**
* Función que fija (cambia) el conjunto de datos manejados por IGEP internamente
* Se destina a uso en comportamientos muy particulares no cubiertos
* por la funcionalidad generica, el parámetro es una matiz de datos (dbresult),
* que pasará a sustirtuir a la matriz que se hubiese obtenido tras realizar una consulta
*
* @param $mDatos Array Matriz (cursor/dbResult) de datos (registros)
* @return none
*/
function setResultadoBusqueda($mDatos){
$this->obj_ultimaConsulta = & $mDatos;
if(isset($this->v_hijos)){
$this->int_filaActual= 0;
$this->recargar($mDatos);
}
return 0;
} //Fin de setResultadoBusqueda
/**
* Función que devuelve el conjunto de datos manejados por IGEP internamente
* Se destina a uso en comportamientos muy particulares no cubiertos
* por la funcionalidad generica. El valor devuelto es una matiz de datos (dbresult)
* que corresponde con el resultado obtenido tras la busqueda.
*
* @return Array Matriz (cursor/dbResult) de datos (registros)
*/
function getResultadoBusqueda(){
return $this->obj_ultimaConsulta;
} //Fin de getResultadoBusqueda
/**
* Función que fija (cambia) el conjunto de datos manejados por IGEP internamente
* Se destina a uso en comportamientos muy particulares no cubiertos
* por la funcionalidad generica, el parámetro es una matiz de datos (dbresult),
* que pasará a sustirtuir a la matriz que se hubiese obtenido tras realizar una
* preseleccion de datos en una panel
* @param $mDatos Array Matriz (cursor/dbResult) de datos (registros)
* @return none
*/
function setResultadoEdicion($mDatos){
$this->obj_ultimaEdicion = & $mDatos;
return 0;
} //Fin de setClaseActual
/**
* Función que devuelve el conjunto de datos manejados por IGEP internamente
* Se destina a uso en comportamientos muy particulares no cubiertos
* por la funcionalidad generica. El valor devuelto es una matiz de datos (dbresult)
* que corresponde con el resultado obtenido tras la edicion.
*
* @return Array Matriz (cursor/dbResult) de datos (registros)
*/
function getResultadoEdicion(){
return $this->obj_ultimaEdicion;
} //Fin de getResultadoEdicion
/**
* Este método crea un IgepMensaje y se lo asigna al panel. El primer parámetro corresponde
* con el id del mensaje (ver mensaje.php) y el segundo, que es opcional, permite parametrizar
* el mensaje pasando en un array los campos que se sustituirán en la cadena del mensaje.
* @param $idMensaje string Cadena que contiene el id del mensaje. Ver mensaje.php
* @param $mDatos Array Array que contiene parámetros del mensaje.
* @return none
*/
function showMensaje($idMensaje,$params=null) {
$this->obj_mensaje = new IgepMensaje($idMensaje,$params);
}
/**
* Método que sirve para fijar el tipo de consulta del panel. Las posibilidades son:
* (0) Se contruye la Where igualando los campos a los valores.
* (1) Se construye con like y comodines para cada campo.
* (2) Por defecto, se contruye con like sólo si el usuario ha especificado comodines.
* @param integer $valorTipoConsulta Entero entre 0 y 2 que indica el tipo deseado.
* @return none
*/
function setTipoConsulta($valorTipoConsulta){
if(($valorTipoConsulta>-1) and ($valorTipoConsulta<3))
$this->int_tipoConsulta = $valorTipoConsulta;
else
die('Error en el constructor de la clase '.$this->getClaseActual().'. El valor del tipo de consulta debe encontrarse entre [0-2]');
}
/**
* Método que sirve para obtener el tipo de consulta del panel. Las posibilidades son:
* (0) Se contruye la Where igualando los campos a los valores.
* (1) Se construye con like y comodines para cada campo.
* (2) Por defecto, se contruye con like sólo si el usuario ha especificado comodines.
* @return integer
*/
function getTipoConsulta(){
return $this->int_tipoConsulta;
}
}//Fin clase IgepNegocio
?>