Tutorial hacer un crud con prado

TUTORIAL PRADO
COMO ELABORAR DE UN CRUD
Presentado a:
Ing. Libardo Pantoja
Presentado por:
Gustavo Salazar Escobar
UNIVERSIDAD DEL CAUCA
INGENIERIA DE SISTEMAS
POPAYAN-CAUCA

TUTORIAL PRADO
COMO ELABORAR DE UN CRUD
INTRODCION A PRADO
PRADO es una capa de programación (framework) basada en componentes y
programación dirigida por eventos, para desarrollo de aplicaciones Web en PHP 5. Las
siglas PRADO significan en español Desarrollo Rápido de Aplicaciones con Programación
Orientada a Objetos en PHP (PHP Rapid Application Development Object-oriented).
El principal objetivo de PRADO es utilizar al máximo la reutilización en la programación
Web. Por reusabilidad, queremos decir no solamente reutilizar el código propio, si no el de
otros programadores de una manera fácil. Lo último dicho es más importante, ya que evita
el esfuerzo de reinventar nuevamente la rueda y además posibilita disminuir notablemente
los tiempos de desarrollos. La introducción al concepto de componentes tiene este
propósito.
Para alcanzar el propósito mencionado, PRADO estipula un protocolo para escribir y usar
componentes para construir una aplicación Web. Un componente es una pieza de
programa que es auto contenido y puede ser reutilizado con una mínima personalización
del mismo. Nuevos componentes pueden ser creados por una simple composición de
componentes existentes.
Para facilitar la interacción con componentes, PRADO implementa el paradigma de la
programación dirigida por eventos (event-driven) que permite la delegación de
comportamientos extensibles a los componentes. Las actividades de los usuarios finales,
tales como hacer clic en un botón de un formulario, son capturados como eventos en el
lado del servidor (server events).
Métodos o funciones deben ser enlazadas a dichos eventos de tal manera que cuando los
eventos sucedan, estos son invocados automáticamente para responder a dicho evento.
Comparado con la programación Web tradicional en la cual los desarrolladores tienen que
tratar directamente con las variables de arreglo POST y GET, la programación dirigida por
eventos ayuda a los desarrolladores enfocarse mejor en las necesidades lógicas y reducir
significativamente el código de bajo nivel repetitivo (low-level repetitive coding).
En resumen, desarrollar aplicaciones Web con PRADO principalmente involucra
instantáneamente tipos de componentes pre desarrollados, configurarlos mediante sus
propiedades, responder a sus eventos escribiendo funciones manipuladoras de los
mismos, y agrupándolos dentro de páginas para la aplicación. Es muy similar al Kit de
herramientas RAD de Borland Delphi y Microsoft Visual Basic, que son utilizadas para
desarrollar aplicaciones (Interfaces Graficas de Usuarios, GUI) de escritorio.
Características
La siguiente lista es un pequeño resumen de las características principales de PRADO,
Reutilización - Los códigos que se rigen por el protocolo basado en componentes de
PRADO son altamente reutilizables. Esto beneficia a los equipos de desarrollo a largo
plazo, ya que pueden reutilizar sus trabajos anteriores e integrar otras partes de trabajo
con facilidad.
Programación dirigida por eventos - Las actividades del usuario final, tales como como
hacer clic en un botón de enviar, son capturadas como eventos del servidor permitiendo
que los desarrolladores tengan un mejor enfoque en interacciones del usuario.
Integración de equipo - La capa de presentación y la capa lógica son almacenados por

separado. Las aplicaciones en PRADO pueden ser armadas por temas.
Controles web Potentes - PRADO viene con un conjunto de poderosos componentes que
se ocupan de interfaces de usuario Web. Altamente interactivo, se puede crear páginas
web con unas pocas líneas de código. Por ejemplo, utilizando el componente DataGrid, se
puede crear rápidamente una página que presenta una tabla de datos que permite la
paginación, la clasificación, editar y eliminar filas de los datos.
Fuerte soporte de bases de datos - Desde la versión 3.1, PRADO ha sido equipada con
total soporte de bases de datos, escrita en forma nativa y, por tanto, encaja con el resto
del framework PRADO. De acuerdo a la complejidad de los objetos de negocio, se puede
optar por utilizar la PDO simple, basada en el acceso a los datos, o el ampliamente
conocido Active Record, o el mapa completo de los objetos del negocio SqlMap.
Soporte de AJAX sin fisuras - Uso de AJAX en PRADO nunca ha sido más fácil con su
innovador Controles Activos (Active Controls) introducidos desde la versión 3.1. Puede
escribir una aplicación AJAX sin escribir una sola línea de código javascript. De hecho,
que la utilización de los Controles Activos, no es muy diferente a la utilización de
componentes no-AJAX.
Soporte de I18N y L10N - PRADO incluye soporte completo para crear aplicaciones con
múltiples idiomas y la localización.
Compatibilidad XHTML - Las páginas Web generadas por PRADO son compatibles con
XHTML.
Albergar trabajos ya existentes - PRADO es un framework genérico, con especial atención
a la capa de presentación. No excluye a desarrolladores que hacen uso de la mayoría de
las actuales bibliotecas de clase o juegos (kits) de herramientas. Por ejemplo, uno puede
usar ADOdb o Creole para tratar con base de datos en su aplicación PRADO.
Otras características - Potente manipulación de errores /excepciones y registro de
mensajes (message logging); cache genérico y memoria caché de salida selectiva;
manejo de errores personalizable y localizable; extensible autentificación y autorización;
prevención de medidas de seguridad tales como cross-site script (XSS), protección de
cookies, etc.
Modelo Vista Controlador
La mayoría de frameworks de PHP principalmente se centra en separar la presentación y
la lógica y promueve el patrón de diseño MVC (modelo-vista-controlador). PRADO logra el
mismo objetivo, naturalmente, al exigir que la lógica se almacene en las clases y la
presentación en las plantillas.
PRADO hace mucho más en otros aspectos distintos de MVC. Se llena de mucho espacio
en blanco en la programación web en PHP, con su paradigma de programación basada
en componentes, la riqueza de su conjunto de controles Web, su potente soporte de
bases de datos, su flexible manejo de errores y registro de mensajes, y muchos otros.
Instalación
Previo a la instalación hay tener instalado xammp/wampp los cuales son servidores
independientes de plataforma, que contienen MySQL, el servidor Apache, intérpretes de
PHP, PERL.
Lo primero que debemos hacer es ir a la página principal de Prado
“http://www.pradosoft.com” y descargar la última versión disponible en la pestaña
Download, una vez bajada a tu computador, se mostrara como un archivo .zip, este se

descomprime en la carpeta “htdocs” de “xampp”, a la carpeta que resulta de la
descompresión del .zip, por razones de facilidad le cambiamos el nombre
a “prado”.
Ahora debemos agregar una nueva variable al path, para hacer esto damos click al menú
inicio, y le damos click derecho a equipo, y seleccionamos propiedades, nos saldrá la
siguiente ventana
Seleccionamos Configuración avanzada del sistema, aparecerá una ventana, donde damos
click a variables de entorno

En la lista de variables del sistema buscamos la variable path y le damos a editar y agregamos
lo que esta subrayado
Creación de un nuevo proyecto
Para crear una estructura de trabajo en prado, abrimos una consola de Windows y vamos
hasta el directorio donde queremos guardar el proyecto. Para poder correr nuestro proyecto en
nuestro servidor local en este caso xampp, debemos guardarlo en la carpeta htdocs.
Una vez estamos ubicados en el directorio ejecutamos la siguiente línea en la consola de
Windows

Remplazamos “nombre_proyecto” por el nombre que le queremos dar al proyecto para este
ejemplo será empresa Si la línea está bien escrita aparecerán los siguientes mensajes
Ya tenemos el esqueleto de nuestro proyecto, este es la estructura que tiene
Ahora tenemos un esqueleto de la aplicación PRADO accesible a través de la URL
http://localhost/demo/index.php que nos lleva a una página Web que muestra en ingles
"Bienvenido a PRADO".
Revisemos el esqueleto del proyecto
Definimos como la carpeta principal a "nombre_proyecto" con el nombre del proyecto que
estamos realizando, de esta se desprenden carpetas hijas: "assets", "protected".
"assets", guarda todos los archivos privados que deseas hacer públicos por instrucción en
el código fuente de tu aplicación, de manera que serán visibles por todos desde el navegador.

"protected", es el directorio principal de tu aplicación, principalmente se utiliza para guardar
scripts privados e información que no será visible para los usuarios finales.
"runtime", no te preocupes por este directorio nunca, pues jamás le pondrás una mano
encima pero no por ello debes dejar de saber en qué consiste, "runtime" conserva toda la
información generada a la hora de correr la aplicación, data cacheada, estado, etc. Es
fundamental que este directorio pueda ser escrito por Apache.
"pages", como su nombre lo indica mantiene todas los .pages y .php que generaras una vez
vayas escribiendo tu aplicación.
Además de la estructura creara los archivos cuyas funciones se explican a continuación:
"index.php", este es el script inicial de Prado y es requerido por todas las aplicaciones
escritas usando el Framework de la misma manera es el único script que es visible por los
usuarios finales y a través de él se accedan las otras páginas.
"Home.page", es la plantilla que por defecto es devuelta al navegador cuando no hacemos
una petición especifica, en los archivos .page colocaremos el código HTML en conjunto con
los controles con los que necesitamos interactuar.
"Home.php", es la página con las instrucciones que ejecutaremos dependiendo a las
llamadas de los eventos de los controles que coloquemos en los .page, contiene la clase para
dicha pagina así mismo contiene el método que dará respuesta a cualquier evento llamado por
los objetos antes mencionados.
“application.xml”, contiene la configuración de la aplicación. Su principal objetivo es
personalizar de una forma configurable la instancia de aplicación creado en el script de
entrada.

CREACION DEL CRUD
Ya creado el proyecto, procederemos a crear el CRUD para 2 tablas: empleado,
departamento.
Base de datos
Para los CRUDS vamos a utilizar una base de datos que tendrá el siguiente esquema
Xampp ya nos provee de un motor de base de datos llamado MySql, podemos acceder a el
escribiendo en el navegador http://localhost/phpmyadmin/, aquí podremos crear nuestra base
de
datos, para nuestro ejemplo la llamamos “empresa” y ejecutamos el siguiente script.
/*==============================================================*/
/* DBMS name: MySQL 5.0 */
/* Created on: 24/09/2014 09:29:23 a.m. */
/*==============================================================*/
drop table if exists DEPARTAMENTO;
drop table if exists EMPLEADO;
create table DEPARTAMENTO
(
COD_DEP int not null auto_increment,
NOM_DEP varchar(50),
primary key (COD_DEP)
);
create table EMPLEADO
(
COD_EMP int not null auto_increment,
COD_DEP int,
NOM_EMP varchar(50),
FECHANAC_EMP date,
SALARIO_EMP float,
primary key (COD_EMP)
);
alter table EMPLEADO add constraint FK_RELATIONSHIP_1 foreign key (COD_DEP)

references DEPARTAMENTO (COD_DEP) on delete restrict on update restrict;
Estableciendo conexión con la Base de Datos
Para utilizar la base de datos que acabamos de crear, primero tenemos que establecer una
conexión con ella.
Vamos a utilizar Data Access Objects (DAO) para abstraer los mecanismos de acceso a
datos. Si en
el futuro se decide utilizar un DBMS diferente (por ejemplo, PostgreSQL, Oracle, etc.) para
almacenar nuestros datos, sólo tenemos que cambiar el nombre de la fuente de base de datos
y
podemos mantener nuestro código PHP intacto.
Modificamos nuestro archivo de configuración de la aplicación protected/ application.xml
mediante la inserción de las siguientes líneas, que le dice a Active Record cómo conectarse a
la
base de datos recién creada:
<modules>
<module id="db" class="System.Data.TDataSourceConfig">
<database ConnectionString= "mysql:host=localhost;dbname=libreria" username="root"
passw ord="" />
</module>
<module class="System.Data.ActiveRecord.TActiveRecordConfig" ConnectionID="db" />
</modules>
La configuración anterior muestra que estamos añadiendo dos módulos a nuestra aplicación.
El
TDataSourceConfig módulo está configurado con la cadena de conexión
"mysql:host=localhost;dbname=libreria" username="root" password="" que apunta a
nuestra
base de datos. Esta conexión es utilizada por el TActiveRecordConfig módulo que es
requerido por
Active Record.
Creación de clases de Active Record
Tenemos que crear dos Active Record clases, LibroRecord y EditorialRecord , para
representar los
registros de datos de los Libro y la Editoriales respectivamente. Clases de Active Record que
se
extienden desde la base de la clase ActiveRecord , y debe definir los nombres de propiedades
que
coinciden con los nombres de los campos de la tabla correspondiente.
Para organizar mejor nuestros directorios, creamos una nueva carpeta Clases en el directorio
protected de nuestro proyecto, para almacenar los archivos de clase. También modificar
nuestra
configuración de la aplicación mediante la inserción de las siguientes líneas. Es equivalente a
agregar el directorio protected/Clases al include_path de PHP, lo que nos permite uti lizar las
clases.

<paths>
<using namespace="Application.Clases.*" />
</paths>
En lugar de escribir las clases de forma manual, vamos a utilizar la herramienta de línea de
comandos PRADO, para generar las clases.
También modificamos la configuración en protected/ application.xml con la siguiente línea de
código y así poder utilizar el servicio de prado wsat (Web Site Administration Tool) que es
una herramienta de desarrollo que permite realizar tareas tediosas de un proyecto de PRADO
a través de una GUI.
<service id="wsat" class="System.Wsat.TWsatService" Password="123" />
Para hacer uso de él Active record abrimos el Web Site Administration Tool ingresando la
siguiente url en nuestro navegador http://localhost/empresa/index.php?wsat=TWsatHome.
Luego de haber ingresado a la página escogemos la opción AR Clases que se encuentra
en un menú en la parte izquierda de la página y aparecerá el siguiente formulario:

En el campo otput Folder solo dejamos Application.Clases y en el campo Table Name
dejamos el * ya que este creara los Records de todas las tablas de lavase de datos.
Le damos click en generar y aparecerá un mensaje de verificación de la creación de la los
Records.
Ahora vamos a nuestro proyecto y vemos que están creadas nuestras clases
En el archivo EmpleadoRecord.php vemos las siguientes líneas de código

Añadimos las siguientes líneas de código
Una vez establecida la conexión y creadas las clases records, el objetivo es gestionar los
datos de la
base de datos, para ello se debe crear una estructura similar a esta

Donde se deberán crear tanto las paginas “.page” como las “.php” de cada uno de los métodos
del
crud.
Esto es lo que llevara cada página para departamento y sería similar para empleado:
listarDpto.page
l
<div align="center">
<h1>Departamentos</h1>
<table>
<com:TForm>
<tr >
<com:TDataGrid ID="lista_dptos"
DataKeyField="COD_DEP"
AutoGenerateColumns="false"
OnEditCommand="editButtonClicked"
OnDeleteCommand="deleteButtonClicked"
ItemStyle.BackColor="#BFCFFF"
AlternatingItemStyle.BackColor="#E6ECFF"
HeaderStyle.BackColor="5a5389"
HeaderStyle.ForeColor="white">
<com:TBoundColumn
HeaderText="Codigo"
DataField="COD_DEP"
/>
<com:TBoundColumn
HeaderText="Nombre"
DataField="NOM_DEP"
/>
<com:TButtonColumn
HeaderText="Accion"
Text="Editar"
ButtonType="PushButton"
CommandName="edit" />
<com:TButtonColumn
HeaderText="Accion"
Text="Borrar"
ButtonType="PushButton"
CommandName="delete" />
</com:TDataGrid>
</tr>

</table>
</com:TForm>
</div>
<div align="center">
<table>
<tr align="right">
<td>
<a href="?page=departamento.dptoNuevo"
onclick="return true" ><img src="assets/img/insertar1.gif" width="138" height="26" border="0"
name="img5"></a>
</td>
</tr>
</table>
</div>
listarDpto.php
<?php
class listarDpto extends Tpage {
//Esta funcion inicia para cargar la pagina
public function onInit($param) {
parent::onInit($param);
// buscamos todas los dptos
$this->lista_dptos->DataSource=DepartamentoRecord::finder()->findAll();
// formateamos los datos
$this->lista_dptos->DataBind();
}
//Esta funcion inicia al dar click al boton editar
public function editButtonClicked($sender,$param){
//Obtenemos el item del DataGrid
$item=$param->Item;
// Obtenemos la llave primaria corresspondiente al item
$id=$this->lista_dptos->DataKeys[$item->ItemIndex];
//construimos el url
$url=$this->Service-
>constructUrl('departamento.dptoModificar',array('id'=>$id));
//enviamos
$this->Response->redirect($url);
}
//Esta funcion inicia al dar click al boton borrar
public function deleteButtonClicked($sender,$param)
{
//Obtenemos el item del DataGrid
$item=$param->Item;
// Obtenemos la llave primaria corresspondiente al item

$id=$this->lista_dptos->DataKeys[$item->ItemIndex];
//construimos el url
$url=$this->Service->constructUrl('departamento.dptoEliminar',array('id'=>$id));
//enviamos
}
}
?>
dptoNevo.page
<div align="center" >
<table>
<com:TForm>
<tr>
<h1>Agregar Departamento</h1>
</tr>
<tr>
<td><com:TLabel Text="Codigo"/>
</td>
<td>
<com:TTextBox ID="idtxt" Text=""/>
<com:TRequiredFieldValidator ID="val1"
ControlToValidate="idtxt"
ErrorMessage="digite el codigo del
departamento"
Display="Dynamic"/>
</td>
</tr>
<tr>
<td><com:TLabel Text="Nombre"/>
</td>
<td>
<com:TTextBox ID="nombretxt" Text=""/>
ControlToValidate="nombretxt"
ErrorMessage="digite el nombre "
Display="Dynamic"/>
</td>
</tr>
<tr>
<td>
<com:TButton ID="button"
Text="Agregar"
OnClick="btn_agregar_click"/>
</td>
<td>

<com:TLabel ID="mensaje" Enabled="false"
Text=""/>
</td>
</tr>
</table>
</com:TForm>
</div>
dptoNuevo.php
dptoModificar.php
<?php
class dptoModificar extends Tpage {
private $dpto;
//esta funcion inicia al cargar la pagina
//obtenemos el id de la URL
$id_dpto=(int)$this->Request['id'];
//buscamos un departamneto por el id
$this->departamento=DepartamentoRecord::finder()->findByPk($id_dpto);

//Si no se encuentra la editorial lanzamos una excepcion
if($this->dpto==null){
throw new THttpException(500,'No existe el departamento');
}else{
//si se encuentra la editorial cargamos los datos en los objetos de la pagina
$this->idtxt->Text=$this->departamento->COD_DEP;
$this->nombretxt->Text=$this->departamento->NOM_DEP;
}
}
//Esta funcion inicia al dar click al boton modificar
function btn_modificar_clicked ($sender, $param){
// si pasamos las validaciones de los objetos de la pagina
if($this->isValid){
//buscamos la editorial por id y los guardamos en un objeto
$dpto = DepartamentoRecord::finder()->findByPk($this-
>departamento->COD_DEP);
//modificamos los datos del objeto
$dpto->COD_DEP=$this->idtxt->Text;
$dpto->NOM_DEP=$this->nombretxt->Text;
//guardamos el objeto llamando la funcion del Active Record
$dpto->save();
//redireccionamos
$url=$this->Service->constructUrl('departamento.listarDpto');
}
}
}
?>
dptoModificar.page
<table>
<com:TForm>
<tr><h1>Modificar Departamento</h1>
</tr>
<tr>
<td>
<com:TLabel Text="Codigo"/>
</td>
<td>
<com:TTextBox ID="idtxt"/d>
ControlToValidate="idtxt"
ErrorMessage="digite el codigo del
departamento"
Display="Dynamic"/>
</td>
</tr>
<tr>
<td>
<com:TLabel Text="Nombre"/>
</td>

<td>
<com:TTextBox ID="nombretxt"/>
ControlToValidate="nombretxt"
ErrorMessage="digite el nombre"
Display="Dynamic"/>
</td>
</tr>
<tr>
<td>
<com:TButton
Text="modificar"
Enabled="true"
OnClick="btn_modificar_clicked"/>
</td>
</tr>
</table>
</com:TForm>
</div>
dptoEliminar.page
<table>
<com:TForm>
<tr><h1>Eliminar Departamento</h1>
</tr>
<tr>
<td>
<com:TLabel Text="Codigo"/>
</td>
<td>
<com:TLAbel ID="idtxt"/>
</td>
</tr>
<tr>
<td>
<com:TLabel Text="Nombre"/>
</td>
<td>
<com:TLabel ID="nombretxt"/>
</td>
</tr>
<tr>
<td>
<com:TButton

Text="eliminar"
Enabled="true"
OnClick="btn_eliminar_click"/>
</td>
</tr>
</table>
</com:TForm>
</div>
dptoEliminar.php
<?php
class dptoEliminar extends Tpage {
private $dpto;
//Esta funcion inicia para cargar la pagina
//extraemos el campo id de la url
$id_dpto=(int)$this->Request['id'];
//buscamos la editoria identificada con la id
$this->departamento=DepartamentoRecord::finder()->findByPk($id_dpto);
//si no encuentra el departamento lanzamos una excepcion
if($this->departamento==null){
throw new THttpException(500,'No existe el departamento');
}else{
//si se encuntra el departamento se extraen los valores de los atributos y se ingresan
en los label
$this->idtxt->Text=$this->departamento->COD_DEP;
$this->nombretxt->Text=$this->departamento->NOM_DEP;
}
}
//Esta funcion inicia al dar click al boton eliminar
function btn_eliminar_click ($sender, $param){
//buscamos la editoria identificada con la id
$dpto = DepartamentoRecord::finder()->findByPk($this-
>departamento->COD_DEP);
//llamamos la funcion heredada del Active record que borra el
objeto de la base de datos
$edit->delete();
//redireccionamos a la página de consulta
$url=$this->Service->constructUrl('departamento.listarDpto');
}
}
?>

Esta es la vista final de la pagina
Esta es la vista de agregar empleado
Esta es la vista de modificar al haber seleccionado un empleado de la lista de empleados

Esta es la vista de eliminar cuando se ha escogido un empleado de la lista de empleados

Referencias
· http://www.pradosoft.com/demos/quickstart/index.php?page=GettingStarted.AboutPrad
o&notheme=true&lang=es
· http://www.pradosoft.com/demos/quickstart/
· http://www.pradosoft.com/demos/blog-tutorial/
· http://www.pradosoft.com/documentation/
· http://www.xisc.com/
· http://pradolabs.blogspot.com/
· Edwar Alejandro Giraldo,PRADO

Tutorial hacer un crud con prado

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Tutorial hacer un crud con prado

Tutorial hacer un crud con prado