DEV Community: Alonzo Vera

Integración Jenkins con MSBuild e IIS

Alonzo Vera — Fri, 21 Jun 2024 20:41:31 +0000

Estos dias me he planteado realizar la implementacion de CI (Integración Continua) en mis proyectos. Para ello he acudido a Jenkins.

Jenkins

Jenkins nos permite, de una manera facil e intuitiva, programar el despliegue de nuestras aplicaciones.
Verán que instalarlo es muy simple. Aquí las instrucciones para instalarlo en cualquier S.O. En mi caso, voy a usarlo sobre Windows Server.

Por defecto, el puerto por el que escucha Jenkins es el 8080, pero podemos modificarlo para escuchar cualquier otro puerto.
Esta modificación se realiza en el archivo "jenkins.xml" que se encuentra en el directorio raiz de la instalación de Jenkins

En mi caso, utilizare el puerto 82. La configuración debera quedar asi:

<arguments>-Xrs -Xmx256m -Dhudson.lifecycle=hudson.lifecycle.WindowsServiceLifecycle -jar "%BASE%\jenkins.war" --httpPort=82 --webroot="%BASE%\war"</arguments>

Para que la configuración tenga efecto tuve que reiniciar el servicio a través del "Administrador de Servicios" de Windows.

Una vez se tenga todo listo, debe procederse a instalar los plugins recomendados por Jenkins, y después debe instalarse los siguientes plugins a través de "Administrar Jenkins"->"Administrar Plugins":

Bitbucket Build Status Notifier Plugin
Bitbucket Plugin
MSBuild Plugin
MSTest plugin

Ahora procedemos a configurar nuestro MSBuild. Esta herramienta nos permitirá compilar proyectos .Net.

Configurar MSBuild y Git

Para realizar estas configuraciones, primero debemos tener instaladas estas herramientas en el servidor de despliegue (aka. donde está Jenkins):

MsBuild
Git

Una vez tengamos instalados estos utilitarios, ingresamos a "Administrar Jenkins"->"Global Tool Configuration" para ajustar el PATH de cada ejecutable:

Podemos crear varias instancias de MsBuild, de acuerdo a la version del mismo. En mi caso estoy utilizando la versión 14, correspondiente a VisualStudio 2015.

Crear Tareas

Una vez tengamos todo configurado, podemos crear nuestra primera tarea, haciendo click en la barra lateral izquierda.

Ponemos un nombre a la tarea (yo prefiero poner el nombre de mi Solución .Net) y elegimos la opcion "Crear un proyecto estilo libre" y presionamos el boton "OK":

Ahora realizamos la configuración del Proyecto.

En mi caso voy a elegir, como origen del codigo fuente, un repositorio git en BitBucket:

Al configurar un repositorio en BitBucket, me pedirá que cree mis credenciales de acceso Git.

Tambien puedo configurar (si tengo el plugin de BitBucket), que se ejecute una "Build" cada vez que se haga un PUSH al repositorio.

Si marcamos esta opcioón, debemos configurar un WebHook en el repositorio de BitBucket apuntando hacia nuestro servidor de despliegue:

La URL del WeebHook en BitBucket debe ser:

http://USUARIO_JENKINS:PASSSWORD_JENKINS@SERVIDOR_JENKINS:PUERTO_JENKINS/bitbucket-hook/

Ahora, volviendo a la configuración de la Tarea en Jenkins, pasamos a la parte mas importante:

En el bloque de Ejecutar podemos añadir varias acciones:

1. Restaurar paquetes Nuget de la Solucion

Antes de empezar a realizar el despliegue de nuestros proyectos, es necesario restaurar los paquetes Nuget utilizados en la solución.
Si bien existen plugins para Jenkins que nos ayudan con esto, es mejor realizar la tarea a través de un paso de tipo "Ejecutar un comando de Windows"

Obviamente, esto implica que tenemos que tener instalado el ejecutable "Nuget.exe" en nuestro servidor de despliegue.

"C:\Program Files\Nuget\"nuget.exe restore ARCHIVO_DE_SOLUCION.sln

2. Ejecutar el MsBuild de Toda la solución

Para compilar toda la solución, agregamos un nuevo paso y elegimos la opcion "Build a VisualStudio project or solution using MsBuild". Despues, configuramos el paso de la siguiente forma:

En el campo "MSBuild File" se debe especificar el archivo que representa la solución (.sln).

3. Publicar el Proyecto principal

Para este paso agregamos una opción "Build a VisualStudio project or solution using MsBuild" y especificamos el Path al proyecto principal de nuestra solucion:

Ademas ponemos el siguiente argumento:

/T:Build;Package /p:Configuration=DEBUG /p:OutputPath="C:\JenkinsBuilds\NOMBRE_PROYECTO_PRINCIPAL" /p:DeployIisAppPath="/Default Web Site/NOMBRE_SITIO" /p:VisualStudioVersion=14.0

4. Desplegar al Servidor IIS

Por ultimo, agregamos otro paso de tipo "Ejecutar un comando de Windows" y especificamos el siguiente comando:

xcopy "C:\JenkinsBuilds\NOMBRE_SOLUCION\_PublishedWebsites\NOMBRE_PROYECTO_PRINCIPAL" /O /X /E /H /K /Y /d "C:\inetpub\wwwroot\NOMBRE_SITIO_EN_IIS\"

Esta instrucción copiará los archivos recurrentemente, pero sólo aquellos que han cambiado recientemente

5. Compilar AHORA y ver la tendencia de tiempo de ejecución

Una vez esté todo configurado, podemos ordenar a Jenkins realizar la compilación y verificar las estadísticas:

Documentar tu proyecto ASP.Net y mostrarlo como un formulario mas

Alonzo Vera — Fri, 21 Jun 2024 20:37:15 +0000

Ahora mostraré como puedes hacer que tu proyecto WebForms ASP.Net genere cada vez su propia documentación en base a los comentarios del código fuente y además se muestre como un formulario.

Para empezar

Para ello utilizaremos dos recursos:

VsXMd de lijunle
CommonMark.Net de Knagis

Estos dos proyectos los podemos obtener a traves de su respectivo repositorio en GitHub o a traves de Nuget.

Para nuestro propósito, vamos a trabajar con el Codigo Fuente de VsXMd y con el paquete Nuget de CommonMark.Net

Generando la documentación en XML

Como bein sabemos, VisualStudio tiene la posibilidad de generar la documentación de nuestro proyecto en un archivo XML

La documentación se genera en base a los comentarios que se realicen sobre los métodos, propiedades y atributos de las clases de nuestro proyecto.

Si no conoces cómo generar esta documentación, te sugiero que te pases por aqui

Generando la documentación en Markdown

Lo primero que tenemos que hacer es abrir de manera separada el proyecto VsXMd.
Una vez abierto, podremos compilarlo y generar sus respectivos ejecutables, tal como muestra en la figura:

Necesitamos tener el ejecutable (y todas sus dependencias) por una razon:vamos a utilizar este ejecutable para generar un Script PostCompilacion en nuestro proyecto que queremos documentar

Además, la razon por la que trabajé con el codigo fuente (y no con el paquete Nuget), fue por que con el codigo fuente tengo la libertad de poder elegir lo que quiero que aparezca en mi documentacion. Asi por ejemplo, no me interesa poner en la documentación los nombres y las descripciones de todos los controles.

Para hacer este cambio, modifiqué el metodo: private static IEnumerable ToUnits(XElement docElement) en la clase Converter.cs del proyecto Vsxmd para que quede asi:

private static IEnumerable<IUnit> ToUnits(XElement docElement)
{
    // assembly unit
    var assemblyUnit = new AssemblyUnit(docElement.Element("assembly"));

    // member units
    var memberUnits = docElement
        .Element("members")
        .Elements("member")
        .Select(element => new MemberUnit(element))
        .Where(member => member.Kind != MemberKind.NotSupported && member.Kind != MemberKind.Constants)
        .GroupBy(unit => unit.TypeName)
        .Select(MemberUnit.ComplementType)
        .SelectMany(group => group)
        .OrderBy(member => member, MemberUnit.Comparer);

    // table of contents
    var tableOfContents = new TableOfContents(memberUnits);

    return new IUnit[] { tableOfContents }
        .Concat(new[] { assemblyUnit })
        .Concat(memberUnits);
}

Si se fijan en la clausula Where (y la comparan con la que originalmente esta en el proyecto de lijunle), podrán ver que estoy excluyendo los elementos de tipo Constants.

Antes:

.Where(member => member.Kind != MemberKind.NotSupported)

Despues:

.Where(member => member.Kind != MemberKind.NotSupported && member.Kind != MemberKind.Constants)

Una vez realizado este cambio, compilo nuevamente el proyecto para obtener el nuevo archivo ejecutable

Creando el Script PostCompilación en nuestro proyecto

Ahora nos vamos a nuestro proyecto para añadir los scripts post compilación.
Primero debemos copiar el ejecutable y las DLLs del proyecto VsXMd a la carpeta de nuestra Solucion para que quede mas o menos asi:

Una vez tengamos copiados estos archivos, debemos ir a las propiedades de nuestro Proyecto, y nos vamos a la ficha de Eventos de Compilación:

En la "Linea de comandos del evento posterior a la compilación" colocamos:

"$(SolutionDir)VsXMd"\Vsxmd.exe "$(ProjectDir)App_Data\XmlDocument.xml" "$(ProjectDir)App_Data\XmlDocument.md"

En mi caso, cambie la ruta (y el nombre) del archivo XML generado por el VisualStudio, para colocarlo en la carpeta App_Data

Ahora compilamos nuestro Proyecto y verificamos que el archivo Markdown existe en la ruta especificada. Cada vez que compilemos nuestro proyecto, se generará/actualizará la documentación XML y su respectivo archivo MD

Creando el formulario para mostrar la documentación en HTML a partir del Markdown

Finalmente, podemos hacer que ese archivo Markdown sirva como fuente para uno de nuestros formularios. Aqui es donde utilizaremos el paquete CommonMark para interpretar texto en Markdown y representarlo en HTML

En éste proyecto de ejemplo, trabajé con WebForms y Bootstrap. Dentro de un nuevo WebForm (archivo aspx) creo el siguiente bloque de código:

<div class="row">
    <div class="col-lg-12 col-md-12">
        <div runat="server" id="divDocs"></div>
    </div>
</div>

En el CodeBehind, en el evento Page_Load tenemos

protected void Page_Load(object sender, EventArgs e)
{
    if (!Page.IsPostBack)
    {
        //El Markdown
        var strMarkDown = Server.MapPath("~/App_Data/XmlDocument.md");
        string text = File.ReadAllText(strMarkDown);
        divDocs.InnerHtml = CommonMarkConverter.Convert(text);
    }
}

Y listo!!! Este seria el resultado:

Si queremos hilar mas fino, podemos modificar el proyecto VsXMd para escribir los textos en español, o para modificar lo que queremos que se muestre.

Espero les sirva.

OpenLDAP con CSharp

Alonzo Vera — Fri, 21 Jun 2024 20:33:45 +0000

En mi empresa hemos empezado a trabajar con OpenLDAP, y esto implica cambiar todos los metodos de autenticacion de los sistemas desarrollados, a éste protocolo.

Al principio parecia dificil, pero no fue asi. Todo se hizo mas facil con la ayuda de algunos articulos de stackoverflow.

Al final pude armar una clase helper que me permitiera acceder a los elementos del LDAP:

public class LDAPHelper
{
    private readonly LdapConnection ldapConnection;
    private readonly string searchBaseDN;
    private readonly int pageSize;

    public LDAPHelper(
        string searchBaseDN,
        string hostName,
        int portNumber,
        AuthType authType,
        string connectionAccountName,
        string connectionAccountPassword,
        int pageSize)
    {

        var ldapDirectoryIdentifier = new LdapDirectoryIdentifier(
            hostName,
            portNumber,
            true,
            false);

        var networkCredential = new NetworkCredential(
            connectionAccountName,
            connectionAccountPassword);

        ldapConnection = new LdapConnection(
            ldapDirectoryIdentifier,
            networkCredential)
        { AuthType = authType };

        ldapConnection.SessionOptions.ProtocolVersion = 3;

        this.searchBaseDN = searchBaseDN;
        this.pageSize = pageSize;
    }

    public IEnumerable<SearchResultEntryCollection> PagedSearch(
        string searchFilter,
        string[] attributesToLoad)
    {

        var pagedResults = new List<SearchResultEntryCollection>();

        var searchRequest = new SearchRequest
                (searchBaseDN,
                    searchFilter,
                    SearchScope.Subtree,
                    attributesToLoad);


        var searchOptions = new SearchOptionsControl(SearchOption.DomainScope);
        searchRequest.Controls.Add(searchOptions);

        var pageResultRequestControl = new PageResultRequestControl(pageSize);
        searchRequest.Controls.Add(pageResultRequestControl);

        while (true)
        {
            var searchResponse = (SearchResponse)ldapConnection.SendRequest(searchRequest);
            var pageResponse = (PageResultResponseControl)searchResponse.Controls[0];

            yield return searchResponse.Entries;
            if (pageResponse.Cookie.Length == 0)
                break;

            pageResultRequestControl.Cookie = pageResponse.Cookie;
        }


    }
}

Con ésta clase, la consulta a los elementos del LDAP fue sencilla:

static void Main(string[] args)
        {
            try
            {
                var baseOfSearch = "dc=integrate,dc=com,dc=bo";
                var ldapHost = "192.168.0.101";
                var ldapPort = 389;
                var connectAsDN = "cn=admin,dc=integrate,dc=com,dc=bo";
                var pageSize = 1000;
                var secureString = "CONTRASEÑA_ADMIN_LDAP";

                var openLDAPHelper = new LDAPHelper(
                    baseOfSearch,
                    ldapHost,
                    ldapPort,
                    AuthType.Basic,
                    connectAsDN,
                    secureString,
                    pageSize);

                var searchFilter = "objectclass=posixAccount";
                //var searchFilter = "uid=rvera";
                var attributesToLoad = new[] { "sn","uid","cn","userPassword" };
                var pagedSearchResults = openLDAPHelper.PagedSearch(
                    searchFilter,
                    attributesToLoad);

                foreach (var searchResultEntryCollection in pagedSearchResults)
                    foreach (SearchResultEntry searchResultEntry in searchResultEntryCollection)
                    {
                        Console.WriteLine(searchResultEntry.Attributes["uid"][0] + ": " +
                                          searchResultEntry.Attributes["cn"][0]);
                        Console.WriteLine(searchResultEntry.Attributes["userPassword"][0]);
                        Console.WriteLine(".......");
                    }
            }
            catch (Exception exp)
            {
                Console.WriteLine(exp.Message);
                Console.WriteLine(exp.StackTrace);
            }

            Console.WriteLine("Presione una tecla para terminar...");
            Console.Read();
        }

Pueden obtener el ejemplo aqui

Aplicacion para descargar imagenes de una página web

Alonzo Vera — Fri, 21 Jun 2024 20:32:15 +0000

Hace algun tiempo tuve la necesidad de descargar las imágenes de una página web. Esto sería tarea sencilla de no ser porque existian mas de 50 imágenes en esa página. ASi que me propuse a realizar una aplicación de escritorio que se encargue de realizar ese trabajo por mi.

Pueden encontrar la aplicación y el codigo fuente aqui.

Me comentan que tal les va.

Mostrar archivo PDF alojado en un servidor FTP con C#

Alonzo Vera — Fri, 21 Jun 2024 20:30:59 +0000

Tenemos un repositorio FTP donde varias oficinas en distintos lugares van alojando archivos PDF que generan con información de su respectivo trabajo. Basicamente todos pueden acceder al FTP y consultar los documentos subidos.

Sin embargo, un nuevo requerimiento necesitaba revisar y calificar el documento. Para ello, se necesitaba que el sistema web que se maneja, muestre los archivos PDF desde el FTP (sin necesidad de descargarlos todos al servidor web).

Buscando, pude encontrar soluciones parciales, pero al final llegué a este bloque de código que me permitía visualizar el archivo requerido:

FileInfo objFile = new FileInfo(filename);
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(new Uri("ftp://" + ftpServerIP + "/" + filename));
request.Credentials = new NetworkCredential(Ftp_Login_Name, Ftp_Login_Password);

FtpWebResponse response = (FtpWebResponse)request.GetResponse();

Stream responseStream = response.GetResponseStream();
StreamReader reader = new StreamReader(responseStream);

byte[] bytes = null;
using (var memstream = new MemoryStream())
{
    reader.BaseStream.CopyTo(memstream);
    bytes = memstream.ToArray();
}

Response.Clear();
Response.ClearHeaders();
Response.ClearContent();
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.ContentType = "application/pdf";
Response.AddHeader("Content-Disposition", "inline; filename=" + objFile.Name);
Response.BinaryWrite(bytes);
Response.End();

ClosedXML y el uso de plantillas

Alonzo Vera — Fri, 21 Jun 2024 20:29:26 +0000

Para facilitar la tarea de crear reportes o documentos en formato XLS o XLSX, se tiene el paquete ClosedXML. El mismo tiene soporte para el uso de templates.

Lo primero que tenemos que hacer es instalar el paquete Nuget en nuestro proyecto:

PM> Install-Package ClosedXML

Después, el bloque de codigo necesario para mostrar un excel a partir de una plantilla es:

var strTitulo = "Titulo del reporte";
var dtReporte = ObtenerDatosReporte(); //Funcion que devolverá un DataTable

//Definimos la plantilla y la utilizamos con la libreria ClosedXML
var template = Server.MapPath("~/doc_templates/Reporte.xlsx");
using (var wb = new XLWorkbook(template))
{
    //Ponemos algunos valores en el documento
    wb.Worksheets.Worksheet(1).Cell(5, 1).Value = strTitulo;

    //Podemos insertar un DataTable
    wb.Worksheets.Worksheet(1).Cell(9, 1).InsertTable(dtReporte);
    //Aplicamos los filtros y formatos a la tabla 
    wb.Worksheets.Worksheet(1).Table("Table1").ShowAutoFilter = true;
    wb.Worksheets.Worksheet(1).Table("Table1").Style.Alignment.Vertical =
        XLAlignmentVerticalValues.Center;
    wb.Worksheets.Worksheet(1).Columns(2, 2 + dtReporte.Columns.Count).AdjustToContents();

    //Limitamos el ancho de las columnas a 60
    foreach (var column in wb.Worksheets.Worksheet(1).Columns())
        if (column.Width > 60)
        {
            column.Width = 60;
            column.Style.Alignment.WrapText = true;
        }

    wb.Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Center;
    wb.Style.Font.Bold = true;

    //Enviamos el archivo al cliente
    Response.Clear();
    Response.Buffer = true;
    Response.Charset = "";
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=\"" + strTitulo + ".xlsx\"");

    using (var myMemoryStream = new MemoryStream())
    {
        wb.SaveAs(myMemoryStream);
        myMemoryStream.WriteTo(Response.OutputStream);
        Response.Flush();
        Response.End();
    }
}

Para acceder a la documentación del proyecto, pueden ingresar a su repositorio

Generar colores hexadecimales aleatorios con Postgres

Alonzo Vera — Fri, 21 Jun 2024 20:25:18 +0000

Hoy me he visto en la necesidad de obtener Varias fechas de una tabla en PostgreSql y mostrar cada una con un color diferente en un Sistema Web.

Mi primera alternativa era buscar una funcion en PHP que me permitiera generar colores hexadecimales aleatorios, pero como tengo más experiencia en PLPgSql, decidí empezar por ahí.

Primero lo primero: todos sabemos que un color hexadecimal es la presentacion de 3 numeros en el rango de 0-255 convertidos a base 16. Pues bien por ahí es por donde empece: generar un numero aleatorio en el rango de 0 a 255.

SELECT trunc(random() * 255)::INTEGER

Ahora necesitamos una función que convierta un numero de Base 10 a Base 16: Para ello necesitamos la siguiente funcion:

CREATE OR REPLACE FUNCTION b10_b16(digits bigint, min_width integer DEFAULT 0)
  RETURNS character varying AS
$BODY$
DECLARE
    chars char[]; 
    ret varchar; 
    val bigint; 
BEGIN
    chars:=ARRAY['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'];
    val := digits; 
    ret := ''; 
    IF val < 0 THEN 
        val := val * -1; 
    END IF; 
    WHILE val != 0 LOOP 
        ret := chars[(val % 16)+1] || ret; 
        val := val / 16; 
    END LOOP;

    IF min_width > 0 AND char_length(ret) < min_width THEN 
        ret := lpad(ret, min_width, '0'); 
    END IF;

    RETURN ret;
END;
$BODY$
  LANGUAGE plpgsql IMMUTABLE
  COST 100;

El uso de ésta función es:

SELECT b10_b16(45);
--Devolverá el Dato 2D

SELECT b10_b16(11);
--Devolverá el Dato B

SELECT b10_b16(11,2)
--Devolverá el Dato 0B

Con todo ésto tenemos la Base para generar un color aleatorio:

SELECT '#' || 
        b10_b16(trunc(random() * 255)::INTEGER,2) || 
        b10_b16(trunc(random() * 255)::INTEGER,2) || 
        b10_b16(trunc(random() * 255)::INTEGER,2) AS color

--Devolvera algo así: #69A51D

Y listo!!!

Ya tenemos nuestra función que genera colores hexadecimales ALEATORIAMENTE!!!

Exportar tabla con JQuery

Alonzo Vera — Tue, 30 Jan 2024 15:54:39 +0000

¿Quién nunca ha tenido la necesidad de exportar un reporte tabulado a MS Excel?

En la red podemos encontrar muchas alternativas para lograr éste objetivo: librerías para PHP, módulos para .Net , etc.

Sin embargo, una solución para cualquier plataforma de desarrollo Web viene de la mano de jQuery. Gracias a un plugin que permite copiar el contenido de una tabla a partir de su ID.

Para acceder a éste plugin, podemos descargar los archivos necesarios desde aqui.

Si bien en ése sitio hay opciones para poder exportar una tabla a varios formatos (PDF, CSV, PNG, etc.), lo que se va a explicar aquí es la forma de exportar una Tabla a Excel:

Una vez tengamos los archivos y se hayan subido a nuestro respectivo servidor web, debemos referenciarlos en el header de la página donde se tiene la tabla para exportar:

<script type="text/javascript" src="tableExport.js">
<script type="text/javascript" src="jquery.base64.js">

Luego, en alguna parte de nuestra página, creamos un Boton para exportar nuestra tabla:

<button class="btn btn-mini download-image" title="Descargar Excel" onClick="$('#id_tabla').tableExport({type:'excel',escape:'false'});">
<img src="'.base_url().'img/excel.png" />
</button>

Recordar que nuestra tabla de tener el id “id_tabla”:

<table id="id_tabla" class="table table-striped">
...
</table>

Con éso ya tenemos nuestro exportador de Tablas a Excel

GPS Visualizer

Alonzo Vera — Tue, 30 Jan 2024 15:50:29 +0000

Hoy les voy a hablar de un servicio GRATUITO por demás interesante. GPSVisualizer nos permite realizar conversiones entre diversos formatos de archivos de mapas (GPS, GPX, KML, KMZ, etc).

Además, permite la visualización de éstos archivos. Realmente es una herramienta muy util. Puedes revisarla aqui.