links

hagamos un link a una vista de algun formulario:

dentro del bloque definido como html
puedes hacer referencia a otro formulario con un link el siguiente codigo da un ejemplo de como hacer un link:



Inicio

estas lineas crearan un link a tu form inicio.

suponiendo que tienes un form y desea pasarle una accion o parametros lo haces cono en cualquier boton:


Persona

generando Combos

para generar el combos has una consulta a tu base de datos a la tabla de la cual quieres optener los registros a listar en la lista despegable....

indicando el llamado a la funcion del form

agregando la funcion para el form

creo una funcion dentro de la clase, el form lo dibujo dentro de la funcion Form_guardar(), en html

trabajando con las clases

al comenzar crearemos una clase en php, para esto crea dentro de tu carpeta src un archivo de extencion php (ejemplo primer_form.php)

Paginando!!!! en php

las paginaciones de los registro que optenemos de la base de datos, y listamos en el form de ser paginado una manera facil de lograr esta paginacion es utilizando un archivo que se encarga de realizar el trabajo por nosotros:

descarga de la web paginator.inc.php y copialo en tu src de tu proyecto.. la descarga te proporciona un blog con las instrucciones de su uso.

estructura del project

creando el form

Creando mi aplicación para el formulario:
require_once("Conexion.php");//hacienmos referencia que usaremos este archivo

class My_form{
private $_conexion;// variable para conexion a la base de datos

public function My_form(){
$this->_conexion = new Conexion(); //Creamos una conexion


} // fin public function
private function myformulario(){
?>
//crea aqui tu formulario tipeando html

}
// Guardar en la base de datos.
function save(){
//recibimos los valores por el metodo post y lo almacenamos en variables
$dato = strtoupper($_POST["dato"]);

//hacemos uso de la sentencia sql y ejecutamos una accion en la base de datos
$_sql = "insert into tabla (dato) values
('$dato')";
$result = $this->_conexion->ejecutarConsulta($_sql);
// $result = $this->_conexion->ejecutarConsulta($_sql); ejecuta la conecion de la base de datos la sentencia sql y sierra la conexion en una sola linea gracias a Conexion.php
}

} //
$My_form = new My_form();// creando una nueva clase


?>

jugando con Php

Preparando el proyecto:
Una ves instalado tu gestor de servicios apache ( appserver, easyphp, wamp, vértigo ), las condiciones mínimas para tu servidor apache es que contenga php5, mysql 5.0 en adelante;
Dirígete hasta la carpeta www de tu servidor apache, dentro de esta crea una carpeta con el nombre del proyecto (miproject), dentro de esta cuatro sub carpetas ( js, css, crs, images), quedando de este modo:


Conectando la base de datos:
Esta es una función encargada de conectar la base de datos, ejecutar consultas, y una serie de sub-funciones muy útiles y practicas para programar en php.
Crea un archivo Conexión.php con el siguiente código: este archivo estará dentro de tu carpeta src.
class Conexion {

//variables de conexion
private $_baseDatos;
private $_ipServidor;
private $_usuario;
private $_password;
// identificador de conexión y consulta
private $_conexion;
private $_resultadoID; //id (puntero) de la consulta
private $_resultado; //arreglo bidimensional
private $_lastID; //representa el valor de un campo autonumérico
// número de error y texto error
private $_errno;
private $_error;

public function Conexion() {

$this->_baseDatos = "nombredb";
$this->_ipServidor = "localhost";
$this->_usuario = "user";
$this->_password = "password"; //de no tener dejar vacio

$this->_conexion = 0;
$this->_lastID = -1;
$this->_resultadoID = 0;
$this->_resultado = array(); //valores vooleanos 1= TRUE 0= FALSE
$this->_errno = 0;
$this->_error = "";
}
/**
* Metodo encargado de ejecutar una consulta establecida por el usuario.
*
* @param string $sql Consulta sql a ejecutar.
* @return object - Si tenemos éxito en la consulta devuelve un arreglo bidimensional con los resultados, sino devuelve 0.
* El cero representa un error. No representa la falta de resultado.
* Para saber la cantidad de tuplas en el resultado utilice el método getCantRegistros().
* @see getCantRegistros
*/
public function ejecutarConsulta($sql){

if (empty($sql)) {
echo "No QUERY...:!";//ocurrio un error
}
//Conecto a la base de datos
$this->conectarDB();
if (!$this->_conexion) {
echo "conection closed...!!";//conexion cerrada
}
//ejecutamos la consulta
$this->_resultadoID = mysql_query($sql, $this->_conexion);
//Verifico que la consulta se haya llevado a cabo
if (!$this->_resultadoID) {
echo "ocurrio un error al ejecutar la consulta...!!!, no se pudo obtener el resultado...!!";//error en consulta
return;
}
//Proceso la consulta. Saco las tuplas y las pongo en un arreglo
$i = 0;
//limpio el array
$this->_resultado = array();
while($_tupla= mysql_fetch_array($this->_resultadoID)) {
$this->_resultado[$i++] = $_tupla;
}
if (!$this->_resultadoID) {
$this->_resultado = 0; //cumple con el API
}
//Cierro la conexion
$this->desconectarDB();
return $this->_resultado;
}

public function ejecutarConsultaID($sql,$nombreSeq){

if (empty($sql)) { echo "No se ha especificado una consulta SQL!"; }

if (empty($nombreSeq)) {echo "No se ha especificado el nombre de la secuencia!"; }

//Establezco conexion con la base de datos
$this->conectarDB();

if (!$this->_conexion) { echo "La conexion se halla cerrada!"; }

//Escribo el log
$_logger = new Logger();
$_logger->escribirSQLLog($sql);

//ejecutamos la consulta
$this->_resultadoID = mysql_query($sql,$this->_conexion);

//Verifico que la consulta se haya llevado a cabo
if (!$this->_resultadoID) {

if($this->_config->getEstadoDepuracion() == "true") {
ERROR::show(mysql_error($this->_conexion),__FILE__,__LINE__);
} elseif ($this->_config->getEstadoDepuracion() == "false") {
echo "Se ha producido un error al ejecutar la consulta!";
} else {
echo"El estado de depuracion contiene un valor invalido";
}
}
//Proceso la consulta. Saco las tuplas y las pongo en un arreglo
$i = 0;
//limpio el array
$this->_resultado = array();
while($tupla= mysql_fetch_array($this->_resultadoID, null, MYSQL_ASSOC)) {
$this->_resultado[$i++] = $tupla;
}
if (!$this->_resultadoID) {
$this->_errno = mysql_stat($this->_resultadoID);
$this->_error = mysql_error();
$this->_resultado = 0; //cumple con el API
}
$_sqlSeq = "SELECT currval('$nombreSeq')";
//ejecutamos la consulta
$this->_resultadoID = mysql_query($_sqlSeq,$this->_conexion);
//Verifico que la consulta se haya llevado a cabo
if (!$this->_resultadoID) {

if($this->_config->getEstadoDepuracion() == "true") {
ERROR::show(mysql_error($this->_conexion),__FILE__,__LINE__);
} elseif ($this->_config->getEstadoDepuracion() == "false") {
echo "Se ha producido un error al ejecutar la consulta!";
} else {
echo"El estado de depuracion contiene un valor invalido";
}
}
//Obtenemos la tupla con el id
$tuplaSeq = pg_fetch_array($this->_resultadoID, null, MYSQL_ASSOC);
//programación defensiva
if($tuplaSeq['currval'] == "") { echo"Error al obtener el último ID de la secuencia...!"; }
$this->_lastID = -1;
$this->_lastID = $tuplaSeq['currval'];
//Cierro la conexion con la base de datos
$this->desconectarDB();
return $this->_resultado;
}


/**
* Método encargado de devolver el ultimo Id generado al llamar al método ejecutarConsultaID.
*
* @return integer Devuelve el número de Id del campo autonumérico de la última consulta.
* En caso de que no se haya generado el valor, devuelve -1.
*/
public function getUltimoId(){ return $this->_lastID;}


/**
* Método encargado de devolver el número de columnas de una consulta.
*
* @return integer Devuelve el número de columnas de una consulta.
*/
public function getCantColumnas() { return mysql_num_fields($this->_resultadoID); }


/**
* Método encargado de devolver el número de registros de una consulta.
*
* @return integer Devuelve el número de registros de una consulta.
*/
public function getCantRegistros(){ return mysql_num_rows($this->_resultadoID); }
/**
* Método encargado de devolver el nombre de una columna en una consulta.
*
* @param integer $numcampo Numero positivo que indique su posicion en la tabla de resultados. Parte de cero.
* @return string Devuelve el nombre de una columna de una consulta.
*/
public function getNombreColumna($numcampo) {
if($numcampo < 0 || $numcampo > $this->getCantColumnas()){
//ERROR::show("El numero posicional de la columna es invalido!",__FILE__,__LINE__);
echo "posicion de columna invalida..!!";
}
return mysql_field_name($this->_resultadoID, $numcampo);
}

/**
* Método encargado de devolver el codigo de error de la consulta.
*
* @return integer Devuelve el número del codigo de error de la consulta.
*/
public function getNroError(){ return $this->_errno; }
/**
* Método encargado de devolver el mensaje de error de la consulta.
*
* @return string Devuelve el mensaje de error de la consulta.
*/
public function getInfoError(){ return $this->_error; }
/**
* Muestra los datos de la última consulta en formato tabular.
* Este método tiene como objetivo servir para depuración.
*
*/
public function toString() {

echo "\n";
echo "\n";
// mostramos los nombres de los campos
for ($i = 0; $i < $this->getCantColumnas(); $i++){
echo "\n";
}
echo "\n";

//mostramos los registros
foreach ($this->_resultado as $tupla) {
echo "\n";
for ($i = 0; $i < $this->getCantColumnas(); $i++){
echo "\n";
}
echo "\n";
}
echo "

".$this->getNombreColumna($i)."
".$tupla[$this->getNombreColumna($i)]."

";
}
/*
* Metodo encargado de establecer la conexión con la base de datos.
*
* @return object - Si tenemos éxito conectando devuelve la conexión, sino devuelve 0.
*
* @access private
*/
private function conectarDB(){

//Programación defensiva
if(empty($this->_baseDatos) || empty($this->_ipServidor) || empty($this->_usuario) ){
//ERROR::show("Alguno de los valores de configuracion de la base de datos no esta seteado!",__FILE__,__LINE__);
echo "error en la configuracion de la conexion...!!";
}
try{
// Conectamos al servidor
$this->_conexion = mysql_connect($this->_ipServidor, $this->_usuario, $this->_password);
if (!$this->_conexion) {
$this->Error = "Ha fallado la conexión.";
throw new Exception('');
}
$db_selected = mysql_select_db($this->_baseDatos, $this->_conexion);
return $this->_conexion;
} catch (Exception $e) {
//ERROR::show("Se ha producido una excepción en el método conectarDB!",__FILE__,__LINE__);
echo "Se ha producido una excepción en el método conectarDB!";
}
}
/*
* Método encargado de cerrar la conexión con la base de datos.
*
* @access private
*/
private function desconectarDB() { mysql_close($this->_conexion); }
} //fin de la clase Conexion

// # NOTA: LA MAYORIA DE LAS FUNCIONES SON BASADAS PARA UN POSGRET AQUI ADAPTADOS PARA MYSQL....
?>