Sigo en la misma linea de la nota anterior.

Ahora la idea es generar una aplicación web completa en VB.NET para Visual Studio 2005, trabajando con SQL Server 2005.

Esta vez subo un conjunto de archivos somo ejemplo para que quien quiera haga sus pruebas.

Los archivos pueden bajarse desde este link SyP.zip 

Pero para esto recomiendo tener funcionando el HelloWorld del ejemplo anterior, de esta forma ya tenemos garantizado el funcionamiento de AjGenesis con NAnt correctamente.

AjGenesis, el generador de código de Ángel “Java” López, permite, entre otras cosas, definir el lenguaje en el que se quiere trabajar, Ángel tiene ejemplos publicados en VB.NET, C#, PHP, Java, en cuanto a bases de datos hay para MySQL, SQL Server 2000, y SQL Server 2005, cualquiera que quiera extender este modelo sólo debe escribir el Template y agregarlo en la Tarea que corresponda.

Como si fuera poco Ángel publica ejemplos con Modelos en Domain Driven Design, usando NHibernate, por separado y combinados también.

En esta versión de AjGenesis, Ángel, agregó un archivo .xml de configuración, en nuestro caso de nombre VbNet2.xml, en el que se define el Dialecto de Programación, el Dialecto de Base de Datos y valores de la conexión a la misma.

Los Dialectos definen el juego de Templates que se van a utilizar, en nuestro ejemplo serán los correspondientes a VB.NET para Visual Studio 2005 y SQL Server 2005.

Los Templates o Plantillas son archivos con extensión .tpl y las Tareas o Tasks son archivos .ajg, ambos archivos de texto.

Los Templates son la base del código que se autogenerará a partir de AjGenesis, los Templates “leen” el Modelo, la estructura de datos, de un conjunto de archivos .xml.

En estos archivos .xml se definen los nombres de las Entidades y campos, los tipos, longitudes y las relaciones entre Entidades.

Existe un archivo .xml que define al conjunto de las Entidades que componen al Modelo, en nuestro ejemplo será Project.xml, luego por cada Entidad tendremos un archivo .xml.

Como escribí antes, los Templates “leen” el Modelo de estos archivos .xml, los Templates se aplican al ejecutar las Tareas.

Por último para ejecutar las Tareas necesitamos NAnt, en un archivo .build se orquestan las Tareas y por línea de comando se ejecuta el archivo NAnt.El ejemplo que voy a desarrollar, como escribí antes, se continúa con el HelloWorld de la nota anterior, es decir, voy a seguir usando la misma estructura de directorios, a quién le agrade podrá usar la misma, sino el modelo permite cualquier otra, pero hay que tener particular cuidado de corregir todas las referencias necesarias.

El ejemplo que voy a tomar es el la aplicación AjSaaS que Ángel “Java” López publica en AjGenesisExamples3.

Pueden bajarse el conjunto de archivos desde acá: SyP.zip, en mi ejemplo yo lo ubico en la carpeta SyP, debajo de la misma veremos el siguiente árbol:

Carpeta Raiz

En la carpeta SyP, nuestra raiz, encontramos el archivo NAnt, en este caso, AjSaaSVbNet2.build.

En Libraries encontraremos las dlls que necesitaremos, este ejemplo usa AjFramework para acceder a datos, entonces encontraremos una carpeta AjFramework y dentro de ella AjFramework.Core.dll y AjFramework.Data.dll. Para quien quiera conocer el AjFramework, otro desarrollo de Ángel “Java” López lo puede encontrar acá, AjFramework, con código fuente disponible.

En Projects se almacenan los Modelos, un Modelo por carpeta, nosotros vamos a ver una carpeta con nombre AjSaaS, que contiene Project.xml, en el que se definen las Entidades intervinientes, veamos: 

<?xml version=”1.0″ encoding=”ISO-8859-1″ standalone=”yes”?>

<Project>

            <Name>AjSaaS</Name>

            <Description>A sample Software as a Service application</Description>

            <Company>ajlopez.com</Company>

            <CompanyName>ajlopez</CompanyName>

            <SystemName>AjSaaS</SystemName>

            <Language>En</Language>

            <Prefix>AjSaaS</Prefix>

            <OpenSource>true</OpenSource>

            <Model>

                        <Entities>

                                    <Entity Source=”Entities/Tenant.xml”/>

                                    <Entity Source=”Entities/Provider.xml”/>

                                    <Entity Source=”Entities/User.xml”/>

                                    <Entity Source=”Entities/Application.xml”/>

                                    <Entity Source=”Entities/Role.xml”/>

                                    <Entity Source=”Entities/UserRole.xml”/>

                                    <Entity Source=”Entities/TenantApplication.xml”/>

                                    <Entity Source=”Entities/Entity.xml”/>

                                    <Entity Source=”Entities/EntityProperty.xml”/>

                                    <Entity Source=”Entities/EntityApplication.xml”/>

                                    <Entity Source=”Entities/Contact.xml”/>

                                    <Entity Source=”Entities/ToDoItem.xml”/>

                        </Entities>

             </Model>

</Project>

 

 

En la carpeta Projects también encontramos otras dos carpetas más, Entities y Technologies. En Entities tenemos un archivo .xml por cada Entidad que compone al Modelo, por ejemplo Role.xml: 

 

<?xml version=”1.0″ encoding=”ISO-8859-1″ standalone=”yes”?>

<Entity>

            <Name>Role</Name>

            <Description>Role</Description>

            <SetName>Roles</SetName>

            <Descriptor>Role</Descriptor>

            <SetDescriptor>Roles</SetDescriptor>

            <SqlTable>roles</SqlTable>

            <Properties>

                        <Property>

                                    <Name>Id</Name>

                                    <Description>Id</Description>

                                    <Type>Id</Type>

                                    <SqlType>int</SqlType>

                        </Property>

                        <Property>

                                    <Name>RoleName</Name>

                                    <Description>Role Name</Description>

                                    <Type>Text</Type>

                                    <SqlType>varchar(40)</SqlType>

                                    <Required>true</Required>

                        </Property>

                        <Property>

                                    <Name>Description</Name>

                                    <Description>Description</Description>

                                    <Type>Text</Type>

                                    <SqlType>varchar(200)</SqlType>

                                    <Required>true</Required>

                        </Property>

                        <Property>

                                    <Name>IdApplication</Name>

                                    <Description>Application</Description>

                                    <Type>IdRef</Type>

                                    <SqlType>int</SqlType>

                                    <Reference>Application</Reference>

                        </Property>

            </Properties>

</Entity>

 

 

 

Los primeros nodos son respectivamente para definir Nombre, Descripción, Nombre de Conjunto, Descriptor, Descriptor de Conjunto, y nombre de tabla de base de datos, esto es definir para una determinada Entidad cómo se la conocerá y describirá en el código que se autogenere acerca de ella.

Después está Properties, una colección de nodos Property, que definen los campos de la tabla de base de datos y las propiedades de la Entidad relacionada, todas las Property tienen nodos Name, Description, Type y SqlType.

Type puede valer:

Id: Clave Primaria de la tabla de base de datos.

Int: Cualquier entero.

Date: para fechas.

Decimal: para decimales.

Text: Cualquier tipo de cadena.

IdRef: para definir relaciones con otras Entidades y Foreign Keys en las relaciones de tablas de bases de datos.

 

Si Type vale IdRef, entonces hay que agregar el nodo Reference, para referenciar a la tabla con que se quiere vincular.

El nodo SqlType define el tipo SQL Server.

Con esto tenemos bien entendido el Modelo, ahora vamos a la carpeta Technologies, en ella encontraremos el archivo VbNet2.xml: 

<Technology>

            <Programming>

                        <Dialect>VbNet2</Dialect>

            </Programming>

            <Database>

                        <Dialect>MsSql2005</Dialect>

                        <Name>AjSaaS</Name>

                        <Username>sa</Username>

                        <Prefix>AjSaaS_</Prefix>

                        <Trusted_Connection>yes</Trusted_Connection>

                        <Host>SPICA\SQLEXPRESS</Host>

            </Database>

</Technology> 

 

 

Podemos leer claramente cómo se definen los Dialectos y los valores de conexión a base de datos, como escribí más arriba.

Ya estamos en condiciones de ver el archivo NAnt, AjSaaSVbNet2.build, acá su contenido: 

 

<?xml version=”1.0″?>

 <project name=”AjSaaS VB.NET 2.0 Web Site” default=”04-Build”>

     <property name=”project.name” value=”AjSaaS”/>

     <property name=”technology” value=”VbNet2″/>

     <property name=”src.dir” value=”.”/>

     <property name=”templates.dir” value=”${src.dir}/Templates”/>

     <property name=”tasks.dir” value=”${src.dir}/Tasks”/>

     <property name=”ajgenesis.dir” value=”C:.5″/>

     <property name=”nanttasks.dir” value=”${ajgenesis.dir}/bin”/>

     <property name=”website.dir” value=”${src.dir}/Build/${project.name}/${technology}/${project.name}/src/${project.name}.WebClient”/>

     <property name=”project.dir” value=”${src.dir}/Projects/${project.name}”/>

     <property name=”lib.dir” value=”${src.dir}/Libraries”/>

     <property name=”build.dir” value=”${src.dir}/Build/${project.name}/${technology}”/>

 

     <target name=”00-Clean” description=”Cleans Build Directory”>

         <delete dir=”${build.dir}” if=”${directory::exists(build.dir)}” />

     </target>

     <target name=”01-LoadTasks” description=”Loads AjGenesis Tasks” >

         <loadtasks assembly=”${nanttasks.dir}/AjGenesis.NAnt.dll” />

     </target>

     <target name=”02-Init” depends=”01-LoadTasks” description=”Init the AjGenesis model, Create build directory”>

         <mkdir dir=”${build.dir}”/>

         <loadmodel model=”${project.dir}/Project.xml”/>

         <loadmodel model=”${project.dir}/Technologies/${technology}.xml”/>

        <executetask task=”${tasks.dir}/BuildProject2.ajg”/>

        <executetask task=”${tasks.dir}/BuildTechnology.ajg”/>

    </target>

    <target name=”03-BuildSQL” depends=”02-Init”>

        <executetask task=”${tasks.dir}/BuildSql.ajg”/>

    </target>

    <target name=”04-Build” depends=”02-Init”>

        <executetask task=”${tasks.dir}/BuildProg.ajg”/>

        <copy todir=”${build.dir}/Src/Libraries”>

            <fileset basedir=”${lib.dir}/AjFramework”>

                <include name=”**/*”/>

            </fileset>

        </copy>

    </target>

    <target name=”05-DeploySQL” depends=”03-BuildSQL”>

        <exec program=”${build.dir}/Sql/CreateDatabase.bat”/>

    </target>

</project

 

 

 

Las primeras líneas del archivo ya están explicadas en la nota anterior, veremos algunas pequeñas diferencias como la definición de la carpeta de Technologies.

En la Target 02-Init podemos ver cómo se carga el Modelo y las Technologies a utilizar, luego se ejecutan las Tasks BuildProject2.ajg y BuildTechnologies.ajg.

Las Targets que más nos interesan son:

 

 

03-BuildSql, crea un script que creará todas las tablas, stored procedures, claves primarias y foráneas y se establecen las relaciones

04-Build, genera la solución con sus proyectos.

05-DeploySql, ejecuta 03-BuildSql y a continuación crea un archivo de lotes de nombre CreateDatabase.bat que ejecuta el script creado en la Targer 03-BuildSql y lo ejecuta. De esta forma se crea la base de datos automáticamente.

Las Tareas se ejecutan de la siguiente forma, abrimos una ventana de línea de comando y nos ubicamos en la carpeta que contiene al archivo NAnt AjSaaSVbNet2.build.

Si tipeamos NAnt y <Enter> se ejecutará la Target por default que es 04-Build, como se define en la segunda linea del archivo: 

 

 

<project name=”AjSaaS VB.NET 2.0 Web Site” default=”04-Build”> 

 

 

Si quisiéramos ejecutar una Target que no sea la definida como default, por ejemplo, 03-BuildSql, tipeamos lo siguiente: 

 

 

NAnt 03-BuildSql 

En nuestro caso ejecutando las Targets 04-Build y 05-DeploySql estaría todo hecho.

Para ejecutar dos Tareas con NAnt tipeamos lo siguiente: 

 

 

NAnt 04-Build 05-DeploySql 

La salida de esto es una larga lista de mensajes que al final incluye el feliz BUILD SUCCEEDED, sino algo falló. Hay que revisar las definiciones y reintentarlo. NAnt tiene que haber creado unas carpetas debajo de SyP con la siguiente estructura: 

Carpeta Build

 

En SyP\Build\AjSaaS\VbNet2\Sql están CreateDatabase.bat y Database.sql, que son respectivamente el encargado de ejecutar el script contra la base de datos y el script en si mismo.

En SyP\Build\AjSaaS\VbNet2\src está el archivo de la solución con todo lo que lo compone.

La solución se genera de tal modo que haciendo un doble click sobre el archivo .sln, para abrirlo con Visual Studio 2005 y con un simple F5 en ese ambiente, ya ejecuta sin ningún error ni ajuste adicional.

Como dice Ángel “Java” Lópezesto es ver la luz

Ahora sólo tienen que defiir un Modelo propio, crear su propio Project.xml y los archivos .xml de las Entidades y ya están en condiciones de generar una nueva aplicación.

Bienvenidos. )

About these ads