Crear Objetos GeneXus
Objeto Folder
Referenciar las siguientes librerias:
Artech.Architecture.Common.Objects
Artech.Architecture.UI.Framework.Services
Antes de crear cualquier objeto se necesita comprobar si la base de conocimientos está disponible, con el siguiente código:
if(UIServices.KB != null && UIServices.KB.CurrentModel != null){}
Así se comprueba que la KB y el Modelo están disponibles, entonces puede recién crearse objetos.
Para crear un folder en el árbol del Folder View de GeneXus:
Se comprueba si el nombre “iQueries” para el Folder existe:
Folder folder = folder = Folder.Get(UIServices.KB.CurrentModel, “iQueries”);
if (folder == null){}
Entonces se pregunta si el folder (en éste caso “iQueries”) no existe, se procede a crear el folder:
folder = new Folder(UIServices.KB.CurrentModel);
folder.Parent = Folder.GetRoot(UIServices.KB.CurrentModel);
folder.Name = “iQueries”;
folder.Save();
Objeto Procedure
Referenciar las siguientes librerias:
Artech.Architecture.Common.Objects
Artech.Architecture.UI.Framework.Services
Artech.Genexus.Common.Objects
Artech.Genexus.Common
En el paso anterior se creó el objeto folder, el siguiente procedure que será creado se colocará ahí:
Recuperar el folder “iQueries”:
Folder folder = Folder.Get(UIServices.KB.CurrentModel, “iQueries”);
Comprobar que el procedure no existe:
Procedure procedure = Procedure.Get(UIServices.KB.CurrentModel, “MiProcedimiento”);
if(procedure == null){}
Se crea y coloca el procedure en el Folder:
procedure = new Procedure(UIServices.KB.CurrentModel);
procedure.Name = “MiProcedimiento”;
procedure.Parent = folder;
procedure.Save();
NOTA: Para que el objeto procedure aparezca directamente en el árbol de folder view de GeneXus Ev2, se establece la propiedad parent del procedure del siguiente modo:
procedure.Parent = Folder.GetRoot(UIServices.KB.CurrentModel);
Variables
Para agregar variables al objeto procedure anterior el siguiente código ayuda a hacerlo:
Variable variable = new Variable(procedure.Variables);
variable.Name = “query”;
variable.Type = eDBType.VARCHAR; //definimos el tipo
variable.Length = 9999; //definimos el tamaño procedure.Variables.Add(var);
procedure.Save();
Source
Para escribir directamente en el source del procedure, el siguiente código ayuda a hacerlo:
Utilizando la variable anteriormente creada:
string source = “&query = ‘Hola mundo con procedure’”;
procedure.ProcedurePart.Source = source;
procedure.Save();
Rules
Para agregar las rules de in u out en un objeto procedure el siguiente código ejemplifica como hacerlo:
procedure.Rules.Source = “parm(out:&variable);”;
procedure.Save();
En la regla se establece a la variable anteriormente creada que será un parámetro out, en caso de querer que sea una rule de in solo se debe sustituir el out por el in.
Structured Data Type
Referenciar las siguientes librerías:
Artech.Architecture.Common.Objects
Artech.Architecture.UI.Framework.Services
Artech.Genexus.Common.Objects
Artech.Genexus.Common.Parts.SDT
Recuperar el folder:
Folder folder = Folder.Get(UIServices.KB.CurrentModel, “iQueries”);
Comprobar si el objeto no existe:
SDT miSdt = SDT.Get(UIServices.KB.CurrentModel, “miSdt”);
if(miSdt == null){}
Crear y colocar el objeto en el folder:
miSdt = new SDT(UIServices.KB.CurrentModel);
miSdt.Parent = folder;
miSdt.Name = “miSdt”;
Agregar un nivel al objeto Structured Data Type y establecer la propiedad IsCollection a True:
SDTLevel sdtLevel = miSdt.SDTStructure.Root;
sdtLevel.Name = “Item”;
sdtLevel.Items.Clear();
sdtLevel.IsCollection = true;
sdtLevel.CollectionItemName = “Item”;
Crear y agregar items al level recién creado:
SDTItem item = new SDTItem(sdtLevel.SDTStructure);
item.Name = “item1”;
item.Type = eDBType.VARCHAR; //definimos el tipo
item.Length = 9999; //definimos el tamaño
item.IsCollection = false;
sdtLevel.AddItem(item);
miSdt.Save();
DataProvider
Referenciar las siguientes librerias:
Artech.Architecture.Common.Objects
Artech.Architecture.UI.Framework.Services
Artech.Genexus.Common.Objects
Recupera el folder:
Folder folder = Folder.Get(UIServices.KB.CurrentModel, “iQueries”);
Comprobar si existe el DataProvider:
DataProvider dataProvider = DataProvider.Get(UIServices.KB.CurrentModel, “MiDataProvider”);
if(dataProvider == null){}
Crear y colocar el DataProvider en el folder:
dataProvider = new DataProvider(UIServices.KB.CurrentModel);
dataProvider.Name = “MiDataProvider”;
dataProvider.Parent = folder;
dataProvider.Save();
Source
En éste ejemplo se debe suponer que se tiene el siguiente objeto structured data type como muestra la figura 7:
Figura 7. SDTEjemplo. Fuente. Elaboración propia.
En la propiedad source del objeto dataprovider establecer la estructura del structured data type, de la siguiente forma:
dataProvider.DataProviderSource.Source = “jqSelectData\r\n{ Item\r\n { \r\n Id = ‘1’\r\n Descr = ‘Opción 1’ \r\n Selected = False \r\n } \r\n }”;
dataProvider.Save();
Propiedades
El objeto dataprovider cuenta con el método setpropertyvalue para establecer sus propiedades mediante código fuente, de la siguiente forma:
Propiedad: Expose as Web Service: dataProvider.SetPropertyValue(Properties.DPRV.ExposeAsWebService, true);
Propiedad: CollectioName: dataProvider.SetPropertyValue(Properties.DPRV.CollectionName, “jqSelectData”);
Propiedad: Output:
dataProvider.SetPropertyValue(Properties.DPRV.Output, new KBObjectReference(jqSelectData.Key));
Dominio
El siguiente código ayuda a crear dominios:
Recuperar el folder:
Folder folder = Folder.Get(UIServices.KB.CurrentModel, “iQueries”);
Comprobar si existe el Dominio:
Domain miDominio = Domain.Get(UIServices.KB.CurrentModel, “MiDominio”);
if(miDominio == null){}
Crear y colocar el Dominio en el folder:
Domain miDominio = new Domain(UIServices.KB.CurrentModel);
miDominio.Name = “miDominio”;
miDominio.Parent = folder;
miDominio.Type = eDBType.VARCHAR;
miDominio.Length = 256;
miDominio.Save();
External Object
El objeto External Object (EO) permite al desarrollador agregar funcionalidad a su aplicación. El EO debe tener asociado alguna librería que respalde su comportamiento, la librería debe ser realizada en el mismo lenguaje que la aplicación principal está siendo compilada por GeneXus Ev2.
Por ejemplo para el caso que la aplicación esté siendo compilada en Java, entonces la librería debería ser un .jar. Del mismo modo para el caso que la aplicación esté siendo compilada en C#, la librería debe ser .dll. De éste modo no se producirá ningún conflicto al momento de compilar la aplicación completa.
Para crear un external object se debe tener un proyecto que nos genere .dll o .jar según sea el caso.
El siguiente ejemplo mostrará una clase llamada CLauncher, el cual está hecha en C#, y el nombre del ensamblado es iLauncher.
namespace iLauncher
{
public class CLauncher
{
public string server;
public string dbname;
public string dbmsport;
public string user;
public string password;
public string trusted;
public string parent;
public string child;
public string ns;
private DataSet dataSet;
private SqlDataAdapter dataAdapter;
public CLauncher(){}
public String ExecuteQueryToXml(string query){
//Lógica del método
}
}
}
En la lógica del método se puede definir el comportamiento del EO.
Agregar la librería a GeneXus Ev2, ir al menú Tools, menú contextual Application Integration, el cual muestra las siguientes opciones:
.Net Assembly Import
Java Class Import
WSDL Import
XML Schema Import
Para el ejemplo se elegirá la opción .Net Assembly Import, mostrará el siguiente cuadro de diálogo y buscar la ruta donde se encuentra la librería, como muestra la figura 8:
Figura 8. Importación de external object paso 1. Fuente: Elaboración propia.
Presionar Next y mostrará el siguiente cuadro de diálogo como se muestra en la figura 9:
Figura 9. Importación de external object paso 2. Fuente: Elaboración propia.
No es necesario que se establezcan valores a los campos Prefix y Folder, presionar Next y se muestra el siguiente cuadro de diálogo como se ve en la figura 10:
Figura 10. Importación de external object paso 3. Fuente: Elaboración propia.
En éste cuadro de diálogo muestra el contenido de la librería, se indica que la librería tiene tres clases definidas: CCondition, CLauncher y CMain. Puede elegirse cuál de ellos se importe en el external object, por cada clase se creará un external object, una vez elegido la clase puede elegirse los atributos y métodos a importar. Luego presionar Import.
NOTA: Para que los atributos o métodos se muestren tienen que ser declarados como public en la librería, caso contrario se le declaran como private.
La siguiente figura 11 muestra el external object creado de la clase CLauncher:
Figura 11. External object importado. Fuente: Elaboración propia.
Note que por cada atributo en la clase se creó una propiedad en el external object y por cada método se creó uno. Observe que los siguientes atributos no se importaron en el external object:
private DataSet dataSet;
private SqlDataAdapter dataAdapter;
Fíjese en la figura 12 las propiedades del external object, el Name, el Namespace y el AssemblyName son las mismas que la librería.
Figura 12: Propiedades del external object importado. Fuente: Elaboración propia.
NOTA: Una vez agregado el external object es necesario que la librería (en éste caso iLauncher.dll) se copie a la carpeta bin del proyecto:
Ejemplo: D:\Tesis\Proyecto\Rostros\CSharpModel\web\bin
Donde:
D:\Tesis\Proyecto: Es el directorio donde está ubicado el proyecto.
Rostros: Nombre del proyecto.
Luego de importar el external object es necesario que se haga un Rebuild All en el proyecto principal.
¿Cómo utilizamos el External Object?
Se crea una variable del tipo de external object que se ah importado, en el objeto web panel, como se muestra en la figura 13:
Figura 13: Variable del external object en un web panel. Fuente: Elaboración propia.
En la parte Events del Web Panel:
Establecer valores para las propiedades de la nueva variable.
&clauncher.parent = ‘SdtQueryRos’
&clauncher.child = ‘SdtQueryRos.Item’
&clauncher.ns = ‘Rostros’
&sqlQuery = ‘select * from ros’
Invocar al método de la variable.
&sqlResult = &clauncher.ExecuteQueryToXml(&sqlQuery)
