MyRad4PHP: UN GENERADOR DE APLICACIONES WEB DINAMICAS CON PHP Y MySQL v. 1.0

El objetivo de esta herramienta es crear aplicaciones al vuelo, generar interfaces tomando como origen una base de datos, haciendo que el desarrollador tenga una aplicación Web sin escribir una sola línea de código, esta inspirado en el Entity Framework y los sitios Web de datos dinámicos ambos de Microsoft y aun que su objetivo es no escribir código puede extenderse o escribirse código para personalizar todas o algunas de sus funcionalidades. Esta herramienta tiene como corazón clases que mapean la base de datos y la metadata útil para el manejo de la base de datos (cruds) y también los elementos que permitan generar la interfase.

Los sitios que se pueden desarrollar con esta herramienta tienen como centro la base de datos, desde ella parte todo con un analizador de estructuras de tablas y las relaciones entre ellas, la mayoría de generadores de aplicaciones Web con PHP parten de una estructura de datos establecida este generador no hace eso, lo que hace es partir de la estructura de la base de datos de tu aplicación y de allí genera todo lo necesario para poder trabajar los CRUD’s.

Indice

1. Descargando la aplicacion
2. Configurando la aplicacion
3. La estructura de directorios
4. Descripcion de las clases generadas ORM
5. Descripcon de la clase metadata
6. Campo enlazados
7. Campos calculados
8. Templates para insertar/modificar/detalles personalizados
9. Paginas personalizadas
10. Cambiando las etiquetas a mostrar
11. Cambiando el orden en que se presentan los campos
12. Cosas finales.

1. Descargando la aplicacion

La aplicacion puede ser descargada desde dos ubicaciones:
PHPClasses
SourceForge

2. Configurando la aplicacion

Cuando tenga el paquete del aplicativo, descomprimalo en una carpeta que este enlazada a un servidor web ej. si usa Apache en la carpeta htdocs, luego cargue la siguiente direccion en un web browser http://localhost/myrad4phpdemo/ donde el nombre de la carpeta en donde descomprimi mi archivo es myrad4phpdemo cuando la pagina cargue ver una pantalla que le permite seleccionar el idioma, solo he colocado dos idiomas ingles y español.

Despues de seleccionar el idoma y presionar en el boton para continuar, sera redireccionado a la pagina de configuracion del aplicativo en la que tendra que ingresar los valores siguientes:

Servidor: el nombre del servidor MySQL que alberga la aplicación en este caso: localhost
Base de datos: nombre de la base de datos en este caso: almacén
Usuario de MySQL: el usuario del servidor de MySQL
Clave: contraseña del servidor de MySQL
Nombre de la aplicacion: Nombre de la aplicación
Ruta en el servidor: que seria la ruta en el servidor Web de nuestra aplicación para este caso seria: /myrad4phpdemo/
Directorio de destino de los archivos ORM: indica la carpeta en donde se vana colocar los archivos que contengan el mapeo de las clases generados por el ORM Buillder, por defecto es la carpeta /DAL pero peude modificarse en caso de hacerlo asegurese de que dicha carpeta existe.
Idioma de la interface: Idioma en que se va a mostrar la interface.

Para el caso del ejemplo estos serian los valores:

Al pulsar procesar lo que va a realizar son dos cosas, crear un archivo llamado setings.php tanto en la carpeta congif como en la carpeta efm en la primera se crea un archivo con los includes para los datos y otras opciones que usa la aplicacion final y en la segunda solo lo basico para el funcionamiento del generador de aplicaciones, tambien va generar un archivo llamado rutabase.js en la carpeta scripts que sirve como indicador de ruta para los javascripts y solo contiene una linea
«var = ‘/myrad4phpdemo/'» para el caso del ejemplo actual.

Cuando se cargue la ventana siguiente le va a mostrar una tabla con cuatro columnas la primera contilos nombres de las tablas de su base de datos, la segunda le indica si quiere generar la clase ORM para esa tabla, la trecera columna indica si desea generar un archivo que contenga la metadata para esa tabla y la cuarta columna indica si esa tabla es la tabla donde se ubican las contraseñas (usuario, clave, nombre de usuario)

Como pueden ver yo he marcado la tabla «usuarios» como seguridad y el objetivo de eso lo veremos en la pantalla siguiente, pero al pulsar sobre procesar hara que se generen todos los archivos de ORM y metadata para las tablas seleccionadas, y archivos include para las las clases de ORM y la maetadata, asi como la clase del contexto de datos.

La pagina siguiente contiene tres combobox de los cuales el primero permite seleccionar el campo donse se encuentren los login’s de los suarios, el segundo las contraseñas y el tercero el nombre del usuario todos refiriendose a la tabla marcada como seguridad en el paso anterior que fue «usuarios».

Si pulsa sobre «Generar» sera llevado a una pagina que le da dos caminos uno para ir al indice de la aplicacion y otra que le permite acceder al generador de menus, es recomendable que antes de generar el menu maneje la metada en especial las etiquetas a mostrar de las tablas ya bque en base a ellas es que se genera el menu, claro tambien se peude hacer manualmente pero no lo recomiendo.

3. La estructura de directorios

• config: Carpeta donde se encuentran los archivos de configuracion que son los siguientes:
  • secure.php: es el que mantiene la configuracion de la tabla usada para las contraseñas, asi como que campo corresponde a que valor.
  • setings.php: indica los valores de configuracion iniciales de la aplicacion como rutas, includes y definciones de variables globales.
  • setup.php: contiene la definicion de la clase Smarty_myrad4php que tiene como clase primaria smarty y en ella se definen las opciones globales del objeto smarty de la aplicacion como el menu.
  • idioma.php: clase basica para elmanejo de los idomas.
  • idoimascfg.php: clase que carga los archivos de idoma de forma parametrizada y es usada por el setings.php para la configuracion de los idiomas.
  • carpeta idiomas: esta carpeta contiene los archivos de idiomas, en caso de querer crear mas idiomas solo es necesario agregar un archvio llamado «nombreidioma.php» y en el colocar el contenido de uno de los dos archivos actuales y cambiar los valores de las variables que hacen referencia a las etiquetas.
  • erros.html: este archivo se muestra si al iniciar el generador de aplicaciones detecta que no tiene las librerias smarty o html2pdf indicandole de donde descargarlas.
  • menuxml.xml: este archivo contiene la definicion de los menus de la aplicacion y al instalar la aplicacion solo contiene una linea que es el menu que indica el home de la aplicacion y puede ser manipulado manualmente o generado desde el generador de menus que tiene la aplicacion.
• css: contiene los archivos de estilo de la aplicacion.
• dal: carpeta por defecto para albergar a los archivos de mapeo de tablas (ORM) y la metada, en el se estos archivos uno que es llamado nombretabla.php contiene el mapeo de la tabla y otro llmado nombretabal_meta.php contiene la definicion de la metadata de la tabla a la que pertenece (donde nombretabla es el nombre de una tabla en nuestra base d datos), tambien va a otros archivos:
  • dalall.php: contiene los includes para las clases orm.
  • metadata.php: contiene los includes de las clases de metadata
  • datacontext.php: es la clase para el contexto de datos
  • caller.php: es el archvio que maneja las respuestas en JSON para las transferencias de AJAX contra PHP.
• efm: contiene el corazon del framework y los archivos para generador de aplicaciones.
• libs: contiene la librerias a usarse, al momento de descarga de la aplicacion esta se encuentra sin las librerias snarty y html2pdf y estas deben ser descargadas y colocadas en las carpetas llamadas: smarty y html2pdf respectuivamente, tambien incluye tres clases mas menubuillder.php para generar los menus, xmlfile.php para leer ye scribir archivos XML (desarrollada por Chris Monson) y datamanager.php para el manejo de servidores de datos.
• scripts: carpeta en la que se encuentran los archivos de javascript como jquery y similares.
• swdd: esta es la carpeta donde se encuentran los archivos que hacen la aplicacion web mejor dicho la interface de la misma y esta formado por los siguientes directorios:
  • controls_php: donde se albergan los controles en php. (al momento de escribir esto solo existe el archivo cuadricula.php que contiene la clase del mismo nombre y genera la cuadricula o grilla)
  • template_pages: alberga a cuatro archivos php que genera la interface para cada operacion del crud y el listado insert.php, edit.php, list.php y details.php, estos archivos son genericos y funcionan con todas las entidades del proyecto a menos que se definan paginas personalizadas (custom_pages).
  • custom_pages: albergaria las paginas personalizadas de cualquier entidad de la base de datos, si se crea una carperta con el nombre de la entidad y dentro de ella se incluye archivo o archivos con los nombres insert.php, edit.php, list.php o details.php la aplicacion obiara los templates estandadres y usara el contenido de esos archivos.
  • scripts: este directorio esta planeado para albergar funciones genericas de javascript que solo funcionarian en los crud’s o si se desea colocar una funcion solo para una entidad se crea un archivo con el nombre de la entidad ejemplo categorias.js
  • templates: este directorio contiene los subdirectorios de configuracion de la libreria smarty y son:
    • cache: mantiene el cache de los templates.
    • configs: configuraciones de los templates, esta vacia por que uso configuraciones basicas.
    • Template: aqui residen los templates de las paginas y tiene dos carpetas controls_Edit que contiene la defincion del template para cada control de las edicoines/inserciones de registros y custom_pages que contiene la definicion de los templates para las paginas personalizadas.

4. Descripcion de las clases generadas ORM

Las clases que genera el ORM Buillder estan formadas por:

Los campos son definidos como propiedades privadas y si un campo es una llave externa FK se crea una propiedad publica con el nombre del campo antecedida de un subguion «_», tambien existen dos propiedades una llamada «esnuevo» y otra editado que sirven para indicar si el registro es nuevo o esta editado en buffering de datos. Como ejemplo tendriamos esto:

public $editado;
public $esnuevo;
private $idcategoria;
private $descripcion;
private $idcatemain;
public $_categorias;

Como pueden ver existe una propiedad llamada $_categorias, eso es por que la tabla categorias contiene un FK hacia si misma.

Luego existe un cosntructor que coloca los valores vacios a las propiedades.

function __construct()
{
$this->editado = false;
$this->esnuevo = false;
$this->idcategoria=»»;
$this->descripcion=»»;
$this->idcatemain=»»;
}

Esa es la definicion del cosntructor.

Las propiedades SET y GET que usan las funcioanes magicas de PHP __set y __get

Esta seria la definicion del constructor.

function __get($propiedad)
{
return $this->$propiedad;
}
function __set($propiedad,$valor)
{
switch($propiedad)
{
case «idcategoria»:
$this->idcategoria=$valor;
break;
case «descripcion»:
$this->descripcion=$valor;
break;
case «idcatemain»:
$this->idcatemain=$valor;
break;
default:
$this->$propiedad=$valor;
}
}

Una funcion llamada «manual» a la que se le pasa un array con nombres con los valores de los campos.

La funcion manual recibiria un array definido por:

$row[‘idcategoria’]=valor;
$row[«descripcion»]=valor;
$row[«_categorias»]=null; //esto indicaria que esta categoria no tiene subcategorias

public function manual($row)
{
$this->__set(«idcategoria»,$row[«idcategoria»]);
$this->__set(«descripcion»,$row[«descripcion»]);
if(isset($row[«_categorias»]))
$this->_categorias=$row[«_categorias»];
$this->__set(«idcatemain»,$row[«idcatemain»]);
}

Una funcion toarray() que convierte en un array con nombres los valores del objeto.

Una funcion «tostring» que retorna un valor que puede ser un campo o la conjuncion de los campos por defecto esta funcion tiene el valor del segundo campo ya que siempre el primero se supone que es el PK de la tabla, esto es muy usado para los combos de los filtros y para las grillas o cuadriculas.

Veremos un ejemplo de clase:

<?php
class tipdocsper
{

//estas son las propiedades

function __construct()
{
$this->editado = false;
$this->esnuevo = false;
$this->idtipdocsper=»»;
$this->descripcion=»»;
$this->abrevia=»»;
}
function __get($propiedad)
{
return $this->$propiedad;
}
function __set($propiedad,$valor)
{
switch($propiedad)
{
case «idtipdocsper»:
$this->idtipdocsper=$valor;
break;
case «descripcion»:
$this->descripcion=$valor;
break;
case «abrevia»:
$this->abrevia=$valor;
break;
default:
$this->$propiedad=$valor;
}
}
public function manual($row)
{
$this->__set(«idtipdocsper»,$row[«idtipdocsper»]);
$this->__set(«descripcion»,$row[«descripcion»]);
$this->__set(«abrevia»,$row[«abrevia»]);

}
public function tostring()
{
return $this->descripcion;
}
public function toarray()
{
$arr=array();
$arr[«idtipdocsper»]=$this->idtipdocsper;
$arr[«descripcion»]=$this->descripcion;
$arr[«abrevia»]=$this->abrevia;
return $arr;
}
}
?>

5. Descripcon de la clase metadata

Las clases que se generan y que tiene como agregado al nombre _meta extienden la clase baseentity que esta conformada por el listado de las clases de las propiedades manejadas como metadata para las tablas por el core del framework y por un array llamado aCampos que esta formado por un array con nombres donde cada elemento del array es un objeto de la clase basecolumn que define toda la metadata manejada para los campos:

Elementos de la clase baseentity:

• nombre: nombre de la tabla este elemento nunca debe de modificarse.
• displayname: es la etiqueta de la tabla, en este caso la tabla se llama categorias (siguiendo el ejemplo) pero podriamos ponerle en la etiqueta «Categorias de productos», esta etiqueta es usada para mostrar en los formularios y ene l generador de menus.
• mostrar: indica si la tabla se va o no a mostarr en el menu.
• aCampos = array(): este es una rray que contiene objetos de tipo basecolumn.
• campomostrar: esta propiedad la manetngo por compatibilidad con versiones anteriores y tenia como objetivo indicar que campo se devuelbe por defecto pero ha sido reemplazada por la funcion tostring de la clase de mapeo (ORM).
• readonly: indica si la tabla e de solo lectura, si se coloca true en este campo no se permite editar ni agregar registros.

Los elementos de la clase basecolumn son los siguientes:

• mostrar: indica si el campo es visible o no lo es, un ejemplo de uso seria los PK que normalmente no se muestran.
• readonly: si el campo es de solo lectura, como campos autogenerados.
• espk: indica si es la llave principal de la tabla
• esfk: indica si es una clave externa.
• tipo: el tipo de datos que contiene la tabla los tipos soportados son los siguientes:
• int=>integer
  varchar=>string
  decimal=>decimal
  datetime=>datetime
  float=>float
  tinyint(1)=bool
  text=>text
  ancho: es el ancho del campo.
• displayname: Nombre que se mostrara ej. idproducto = Codigo.
• tipocontrol: Es el nombre del control que reproducira cuando se muestre una pagina de edicion/insercion y son los mismos que los tipos de datos soportados.
• requerido: Indica si el campo es requerido es de tipo booleam.
• nombre: Nombre del campo, este elemetno no debe de ser modificado.
• posicion: Indica la posicion en que el campo se mostrara en las ventanas de crud, si quiero que un campo salga antes que otro pues le coloco una poscion menos al que quiero que salga despues es de tipo integer.
• filtrar: indica si el campo va a ser tomado como filtro en la pantalla de listado es de tipo booleam.
• filtroobject: indica el tipo de objeto que se usara para el filtrado.
• subtipo: indica si el tipo de datos tiene algun subtipo ej. el tipo del campo es DateTime pero lo que en realidad quiero usar es solo la fecha o el tiempo asi los subtipos son: “date” y “time”, solo se aplica a tipo datetime.
• campoRelacion: si un campo es un FK entonces se coloca el campo al que hace relacion en la tabla destino, este elemetno no debe de ser modificado.
• tablaRelacion: indica el nombre de la tabla con la que se esta relacionando. Se presume que todas las relaciones son de tipo uno a varios, no se controla relaciones de uno a uno o de muchos a muchos, este elemetno no debe de ser modificado.
• totalizar: indica si un campo es totalizable, si un campo es marcado como true en este valor en las cuadriculas del listado se va a mostar la suma de sus valores, no usar con campos tipo string o fecha.
  defaultvalue: es el valor por defecto digamos si quiero que un campo muestre un valor al inicar el formulario de insertar el valor debe de ser colocado aqui.
• esunico: indica si el valor del campo no puede ser repetido.
• gotop: esta hecho para los formularios de uno a muchos indica que campo va en la parte superior (antes de la grilla del detalle) y cuales van despues, true = arriba.
• linkfields: este campo indica los campos enlazados osea si al modificar un campo este afecta los valores de otros se debe de colocar aqui una lista de cmapos afectado, separados por comas, ej. digamos que se tiene un campo subtotal y este va a fectar a los campos: valorimpuesto y total, pero usa tambien el valor del campo impuestoentonces este campo de la metadata debe de quedar de esta manera $linkfields=»valorimpuesto,total, igv»;

6. Campo enlazados

En teoria solo bastaria con inidcar que campo esta enlazado con otro y esto debe de funcionar pero me he encontrado con casos especiales en los que se tiene que hacer algunos ajustes como el orden en que se maneja la funcion manual de cda objeto, me explico, si se tienen los campos subtotal, impuesto, valorimpuesto y total y se quiere que al ingresar se calcule los valores de los campos valorimpuesto y total basados en el monto del subtotal y el impuesto pues la funcion manual debe de quedar de esta manera:

Esta la funcion original (solo salida del generador)

public function manual($row)
{
$this->__set(«idventascab»,$row[«idventascab»]);
$this->__set(«fecha»,$row[«fecha»]);
if(isset($row[«_series»]))
$this->_series=$row[«_series»];
$this->__set(«idserie»,$row[«idserie»]);
$this->__set(«numdoc»,$row[«numdoc»]);
if(isset($row[«_padron»]))
$this->_padron=$row[«_padron»];
$this->__set(«idpadron»,$row[«idpadron»]);
$this->__set(«credito»,$row[«credito»]);
$this->__set(«cancelada»,$row[«cancelada»]);
$this->__set(«anulada»,$row[«anulada»]);
$this->__set(«enviada»,$row[«enviada»]);
$this->__set(«subtotal»,$row[«subtotal»]);
$this->__set(«valimpuesto»,$row[«valimpuesto»]);
$this->__set(«impuesto»,$row[«impuesto»]);
$this->__set(«total»,$row[«total»]);

}

Esta es la funcion modificada:

public function manual($row)
{
$this->__set(«idventascab»,$row[«idventascab»]);
$this->__set(«fecha»,$row[«fecha»]);
if(isset($row[«_series»]))
if($row[«_series»]!=null)
$this->_series=$row[«_series»];
$this->__set(«idserie»,$row[«idserie»]);
if($row[«numdoc»]==»»)
{
if(isset($row[«_series»]))
$this->__set(«numdoc»,$this->_series->numact);
else
$this->__set(«numdoc»,»»);
}
else
$this->__set(«numdoc»,$row[«numdoc»]);
if(isset($row[«_padron»]))
$this->_padron=$row[«_padron»];
$this->__set(«idpadron»,$row[«idpadron»]);
$this->__set(«credito»,$row[«credito»]);
$this->__set(«cancelada»,$row[«cancelada»]);
$this->__set(«anulada»,$row[«anulada»]);
$this->__set(«enviada»,$row[«enviada»]);
$this->__set(«valimpuesto»,$row[«valimpuesto»]);
$this->__set(«subtotal»,$row[«subtotal»]);
$this->__set(«impuesto»,$row[«impuesto»]);
$this->__set(«total»,$row[«total»]);
}

Como pueden ver lel campo calimpuesto ha sido colocado antes que los otros por que si ese valor esta vacio pues nada se va a calcular.

Bueno ahora la pregunta y como se hace para asignar una funcion a un campo para que ste realize los calculos en otros campos, para ello se deb de modficar la asignacion de las propiedades en la funcion __set el ejemplo seria este (para mejor informacion vea «campos calculados» en este manual):

case «subtotal»:
$this->subtotal=$valor;
$this->impuesto = $this->subtotal*($this->valimpuesto/100);
$this->total=$this->subtotal+$this->impuesto;
break;
case «valimpuesto»:
$this->valimpuesto=$valor;
break;
case «impuesto»:
//$this->impuesto=$valor;
break;
case «total»:
//$this->total=$valor;
break;

En lo referente a como trabaja esto con la aplicacion pues lo hace mediante una llamada asincrona usando jquery hacia el archivo caller.php que se encuentra ubicado en la carpeta «dal» que recibe los nombres de los campos a modificar y los valores con los que procesar y retorna un objeto JSON con el objeto con los valores procesados, mediante ajax se maneja la asiganacion de los valores y es generalmente cuando pierde el foco en el caso de los textbox y en el changevalue para los combobox.

7. Campos calculados

En algunas ocasiones antes de guardar un registro se necesita realizar cálculos con algunos campos que el usuario no debe de modificar manualmente como los totales de una factura, creo que con un ejemplo me explico mejor, se va a guardar el total de una factura o sea se tiene el importe y se sabe cual es el impuesto (digamos 18%) y se tienen que guardar en los campos igv y total en el primero el 18% del importe y en el segundo el importe sumado el 18% del importe y no queremos que el usuario lo haga sino la aplicación para ello vamos primero a la metadata de la tabla y cambiamos el valor readonly a true en los campos igv y total, segundo vamos al mapeador de tabla y ubicamos el método __set($priedad, $valor) allí ubicaremos el campo “importe” dentro del switch

case “importe”:
$this->importe=$valor;
break;
case “igv”:
$this->igv=$valor;
break;
case “total”:
$this->total=$valor;
break;

Así es como encontraríamos el código de la clase y como queremos cambiar eso para que sea auto calculado colocamos las operaciones pertinentes dejándolo así:

case “importe”:
$this->importe=$valor;
$this->igv = $valor*0.18;
$this->total=$this->igv +$this->importe;
break;
case “igv”:
break;
case “total”:
break;

8. Templates para insertar/modificar/detalles personalizados

Ahora que sucede si no quiero que una tabla especifica se muestre como yo he diseñado los templates me refiero a que si no quisiera que al modificar sea siempre vertical sino que quiero un campo a la isquierda y otro a la derecha digamos la cabecera de ventas se muestra en forma vertical pero si quisiera que tomara el formato de una factura algo como:

Cliente: _________________________________________
Fecha: ____________ Fecha de pago: ______________
Factura Nro: ______________
Cancelada: ___
Importe: ____
IGV:___
Total:__

Para hacer esto se tiene que crear una carpeta en <applicationroot>/templates/template/custom_pages/ alli crearia una carpeta con el nmbre de la entidad en este caso “ventascab” y dentro de ella crear un archivo al cual quiero afectar, asi si es para la edicion creara en <applicationroot>/templates/template/custom_pages/ventascab/edit.tpl y en caso que fuera para el insertar insert.tpl o el detalle el archivo seria details.tpl.

Pero que modificar y que no, primero entendamos algo de como trabaja Smarty con los templates smarty es alimentado desde PHP mediate asignaciones de variables si vemos un codigo en php que asigne un valor a una variable seria este:

En la sentencia siguiente le estoy diciendo a Smarty que cree una variable llamada “tabla” y que va a tener el valor de $_GET[«tabla»]
$smarty->assign(‘tabla’,$_GET[«tabla»]);

En el segundo caso le estoy diciendo a Smarty que le asigne a la variable “acampos” el resultado de la funcion getfields:
$smarty->assign(‘acampos’,getfields($objentity,$objentity->registros[0]->toarray()));

ya dentro de la platilla de Smarty se invocan a las variables de la forma siguiente:
<tr>
{$value = $acampos.id_categoria}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>

{$value = $acampos.descripcion}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>
</tr>

Como pueden ver siempre entre llaves y como si fuesen variables de PHP antecedidos del caracter $ en el caso del ejemplo que muestro es que en lugar que me use dos filas para hacer la edicion de la tabla categoria solo aparesca una, pero si se fijan en {$value = $acampos.descripcion} lo que hago aqui es que creo una variable Smarty llamada $valor a la que le asigno un elemento con el nombre del campo y esto es por que el array que devuelbe la funcion getfields es un array con indices y esta formada de esta manera:

array(“nomcamp”=> array(“etiqueta”=><etiqueta>, “tipocontrol”=><tipocontrol>, “valor”=><valoractual>, “tamanio”=><tamanio>, “indices”=>array(), “etiquetas”=>array())

donde:

<nomcamp>: Nombre del campo extraido de la metadata.
<etiqueta>: etiqueta del campo extraido de la metadata (displayname).
<tipocontrol>: tipo de control extraido de la metadata.
<tamanio>: Ancho del campo extraido de la metadata.
<valor actual>: si es edicion se cargara el valor del campo que tiene en el registro actual.
indices: si el control es de tipo combobox osea es un fk este un array con los ids de la tabla dependiente.
etiquetas: un array con los valores (textos) par ael combo del fk.

Asi que cuando quiera hacer un template personalizado para ventascab como en el formato anterior tendria que hacer lo siguiente:
<table>
<tr>
{$value = $acampos.idcliente}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>
</tr>
<tr>
{$value = $acampos.fecha}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>

{$value = $acampos.fechapago}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>

</tr>
<tr>
{$value = $acampos.id_tipdoc}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>

{$value = $acampos.numdoc}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>
</tr>
<tr>
{$value = $acampos.cancelada}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>
</tr>
<tr>
{$value = $acampos.importe}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>
</tr>
<tr>
{$value = $acampos.igv}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>
</tr>
<tr>
{$value = $acampos.total}
<td>{$value.etiqueta}</td>
<td>{include file=$value.tipocontrol}</td>
</tr>
<tr>
<td><input type=”submit” value=”Aceptar” name =”aceptar”/></td>
<td><input type=”submit” value=”Cancelar” name=”cancelar”/></td>
</tr>
</table>

Esto muestra que lo que varia es la posicion en la tabla de los campos y para hacer referencia a los indices del array que se pasa a Smarty se hace de la siguiente manera <arrayensmarty>.<indice> como cuando asigno a la variable $valor el contenido del indice total: {$value = $acampos.total}.

9. Paginas personalizadas

Las paginas personalizadas tienen la misma filosofia que la personalizacion de templates con la diferencia que aqui se maneja el PHP y no el template para ello se debe de crear una carpeta con el nombre de la tabla en <applicationroot>/swdd/custom_pages/ alli se colocaran los archivos que se quieran personalizar por ejemplo si quiera personalizar la insercion en la tabla ventascab pues creo una carpeta con el nombre ventas cab en la ruta indicada y un archivo llamado edit.php y seria algo asi: <applicationroot>/swdd/custom_pages/ventascab/edit.php con eso le estoy dicendo al motor del aplicativo que no usae el archivo estandar sino el que acabo de generar. COn esto se peude programar un nuevo archivo y nuevas formas de procesarlo dejando las demas entidades con el template estadar, digamos que quiero hacer un formulario de uno a muchos pues aun que el template no lo implementa se podria programar uno desde aqui apoyandonos en lo que ya tenemos programado manejado desde el core del framework.

10. Cambiando las etiquetas a mostrar

Es muy normal que los nombres de nuestros campos sean nemonicos y no queremos que en la aplicación final se muestren sino lo que en verdad representan y cuando la aplicación es generada solo se muestran los nemonicos o los nombres que están en la base de datos de nuestra tabla, pero como hacer que salga la cadena que deseamos veamos si en nuestra tabla “ventascab” tenemos un campo que indica “numdoc” y queremos que se muestre “Numero de documento” y también queremos que en lugar de que diga “ventascab” diga cabecera de ventas pues para ello vamos a la metadata y modificaríamos la etiqueta que dice “DisplayName” de la entidad y del campo veamos eso:

class ventascab_meta extends baseentity
{
function __construct()
{
$this->nombre=”ventascab”;
$this->displayname=”Cabecera de Ventas”;
$this->mostrar=true;
$this->readonly=false;
$this->grupo=”Menu”;
$this->campomostrar=idcliente;
$this->aCampos[id_ventacab]=new basecolumn();
$this->aCampos[id_ventacab]->nombre=”id_ventacab”;
.
.
.
.
$this->aCampos[numdoc]=new basecolumn();
$this->aCampos[numdoc]->nombre=”numdoc”;
$this->aCampos[numdoc]->displayname=”Numero de Documento”;
$this->aCampos[numdoc]->mostrar=true;
.
.
.

$this->aCampos[fechapago]->filtroobject=”datetime”;
}
}

11. Cambiando el orden en que se presentan los campos

Para cambiar el orden en que se muestran los campos tanto en la cuadricula (listados) para ello tenemos elemento posición en la metadata, solo se tiene que poner el orden siendo cero el primer campo a mostrar y así sucesivamente hasta completar con todos los campos aumentando en uno cada campo, tenga mucho cuidado de no repetir un numero ya que sobrescribiría en la ejecución al campo anterior con la misma posición, en otras palabras dos campos no pueden ocupar la misma posición.
Haciendo que se devuelva un campo diferente

Por defecto el generador toma como campo a devolver el campo siguiente a la llave primaria que en muchos casos viene a ser una llave externa como ejemplo se tiene una tabla productos en el que el campo que le sigue al PK es un FK hacia la tabla categorías por lo que al hacer consultas digamos en detalle de ventas me muestra los id’s de la categoría relacionada con ese producto y no la descripción del producto para ello tenemos que modificar el método tostring de el mapeador de la tabla, así que editaremos para este ejemplo seria el archivo productos.php y vamos a cambiar la línea que dice: return $this->idcategoria; por return $this->descripcion; con eso ya tenemos lo que deseamos que nos muestre la descripcion del producto, pero si yo quiero que me muestre no solo la descripcion sino también la categoría ósea en lugar que salga “Tarro de leche gloria x 400ml” y quiero que salga “Lácteos – Tarro de leche gloria x 400ml” pues tendría que modificar la misma función para que trabaje de esta manera:
return $this->_categorias->descripcion.” – “.$this->descripcion;
Como pueden ver he hecho una referencia a la entidad categorias e invocado a la propiedad descripcion y esto es posible por que el generado al encontrar un FK crea dos campos en la metadata:tablarelacion y camporelacion y al generar el mapedor de tabla crea un campo que tiene el nombre de la tabla relacionada pero antecedido por un sub guión “_” y que el core se encarga de completar con el registro relacionado y por eso se puede acceder a los valores de la tabla relacionada, es mas si una tabla tiene una tabla relación y esta tabla relación tiene otra tabla relación se pueden acceder a los valores de la tercera tabla relación de esta manera, pongamos que estamos viendo los detalles de una venta de productos y quiero saber la categoría:
$this->_productos->_categorias->descripcion;

12. Cosas finales

Aplicacion desarrollada por Jorge Luis Prado Anci, en cuanto al licenciamiento pues esta aplicacion se entrega tal cual y tienen permiso de modifcarla y distribuirla de la manera que deseen, solo se les solicita que respeten el nombre del desarrolador indicando quien lo ha desarrollado o manteniendo los comentarios en los archivos del script, como esta aplicacion se entrega tal cual el creador no se hace responsable de uso o mal uso de la misma, en lo referido al soporte el creador intentara dar el soporte necesario pero dejando en claro que es meramente voluntario.

URL de descarga: https://myrad4php.wordpress.com/descarga/
Email del desarrollador: xmeele@hotmail.com
Pagina del desarrollador: http://xmeele.wordpress.com
Pagina del Proyecto: https://myrad4php.wordpress.com