Apuntes sobre progración

¿Qué es WSL? Una Introducción a Windows Subsystem for Linux

2025-02-28T19:21:00.003+01:00

Si te encanta Linux pero no quieres/puedes renunciar a Windows, ahora tienes WSL (Subsistema de Windows para Linux), y es que Microsoft pasó hace unos años del odio a Linux al amor, llegando a crear un subsistema Linux embebido en Windows.

En el mundo tecnológico actual, los desarrolladores buscan constantemente herramientas que faciliten su trabajo y les permitan ser más productivos. Una de estas herramientas es el Windows Subsystem for Linux, más conocido como WSL. En esta entrada de blog, exploraremos qué es WSL, cómo funciona y por qué ha ganado popularidad entre los desarrolladores.

¿Qué es WSL?

Windows Subsystem for Linux (WSL) es una característica de Windows 10 y versiones posteriores que permite a los usuarios ejecutar un entorno Linux directamente en su sistema operativo Windows, sin necesidad de una máquina virtual. WSL facilita el uso de herramientas y aplicaciones de Linux en un entorno Windows, lo que lo convierte en una opción atractiva para desarrolladores, programadores y entusiastas de la tecnología.

Historia y Evolución

WSL fue introducido por primera vez en 2016 con la actualización de Windows 10 Anniversary Update. En sus primeras versiones, WSL 1 ofrecía una compatibilidad básica para ejecutar comandos de Linux. Sin embargo, con el lanzamiento de WSL 2 en mayo de 2019, Microsoft mejoró significativamente la capacidad de WSL al introducir un núcleo de Linux completo, lo que brinda un rendimiento y compatibilidad mucho mejores con aplicaciones Linux.

¿Cómo Funciona WSL?

WSL actúa como una capa de compatibilidad entre Windows y Linux. La primera versión, WSL 1, traduce las llamadas del sistema Linux en llamadas del sistema Windows, lo que significa que las aplicaciones de Linux podían ejecutarse en Windows sin hardware adicional. Con WSL 2, esta traducción se eliminó, y en su lugar, se utiliza una máquina virtual ligera que alberga un núcleo Linux real.

Cómo instalar una distro Linux en WSL

Lo primero será instalar el propio Subsistema de Windows para Linux. Esto lo podemos hacer escribiendo "wsl" en el buscador de Windows

Una vez que tenemos instalado el Subsistema de Windows para Linux, tendremos que instalar una distribución de Linux: Debian, Ubuntu... Si abrimos una ventana "cmd" y escribimos "wsl" se nos mostrará un mensaje indicando cómo debemos proceder a continuación.

Ejecutando el comando "wsl --list --online" podremos obtener una lista de las distros disponibles.

Yo he optado por instalar la distro de Debian, utilizando el comando "wsl --install Debian". En unos pocos segundos quedará instalada

Y se mostrará una ventana de bienvenida:

En esta ventana encontraremos recursos útiles sobre el Subsistema Linux, como por ejemplo "Integracion de Docker Desktop" e "Integración de VS Code"

NOTA: Para volver a esta pantalla de bienvenida, escribe "wsl Settings" en el búsqueda de Windows y se abrirá la pantalla de configuración de wsl. Desde el menú de la izquierda, abajo, verás la opción "Te damos la bienvenida a WSL".

Podemos instalar otra distro (que se mantendrá como sistema independiente).

Con el comando "wsl --list" obtendremos la lista de las distros instadas, indicándonos cual es la predeterminada.

Cómo abrir una distro Linux de WSL

Escribiendo "wsl" en cmd se abrirá la distro predeterminada. También podemos escribir "wsl -d Ubuntu" para abrir "Ubuntu" (suponiendo que la hayamos instalado). Otra forma de abrir alguna de ellas es escribiendo "wsl" en el buscador de windows, y veremos las diferentes distros instaladas y podremos ejecutar clicandola que deseemos.

La primera vez que ejecutemos la distro se nos pedirá un usuario y contraseña. Y a partir de ahí tendremos un sistema linux completo ejecutándose bajo nuestro Windows:

... desde el cual podemos acceder a nuestro sistema de archivos de Windows (y viceversa)

... Podremos instalar python ($ sudo apt-get install python3) e incluso podremos instalar y ejecutar programas con interfaz gráfica, como por ejemplo Visual Studio Code (del que hablaré en otro post).

Ventajas de Usar WSL

Integración: WSL permite ejecutar herramientas de Linux y Windows de manera conjunta. Puedes utilizar editores de texto de Linux al mismo tiempo que accedes a archivos y aplicaciones de Windows.

Desarrollo Multiplataforma: Ideal para desarrolladores que trabajan en entornos tanto de Windows como de Linux. WSL facilita la creación y prueba de aplicaciones web en ambos sistemas operativos.

Sin Necesidad de Virtualización: A diferencia de las máquinas virtuales que requieren más recursos y son más lentas, WSL es más ligero y eficiente, lo que permite una mejor experiencia de usuario.

Acceso a la Terminal de Linux: Muchos desarrolladores prefieren la terminal de Linux por su flexibilidad y potencia. WSL ofrece esta opción en un entorno nativo de Windows.

Conclusión

WSL ha revolucionado la forma en que los desarrolladores y usuarios de Windows interactúan con Linux. Al proporcionar un entorno integrado y eficiente que combina lo mejor de ambos mundos, WSL facilita el desarrollo y mejora la productividad. Si trabajas en tecnología, programación o simplemente estás interesado en explorar Linux, definitivamente vale la pena considerar WSL como parte de tus herramientas de trabajo.

¡Anímate a probarlo y explora el vasto mundo de posibilidades que WSL tiene para ofrecerte!

Alternativas (free) a SugarCRM

2016-01-18T15:11:00.001+01:00

SugarCRM ya no dispone de una versión "free", tal como se muestra en el cuadro editions and pricing de la compañía. Parece ser que la versión Community Edition a pasado a mejor vida... ;(

Por fortuna existen alternativas, gratuítas o de menor coste. Entre ellas he elegido algunas que ahora presento:

SplendidCRM: Dispone de una versión Community On Premise totalmente gratuíta y open-source. A diferencia de SugarCRM y las demás opciones que muestro, utiliza tecnología Microsoft, es decir, funciona sobre ASP.Net y MS SQL Server, y sus fuentes entán en C#.
Bitrix24: La versión Cloud es gratuíta hasta 12 usuarios, y la versión Standard no tiene límite de usuarios, con un coste de 99$/mes. Código fuente disponible.
SuiteCRM: Es una alternativa open source a SugarCRM, de hecho está basado en la versión Community Edition de Sugar. Es un producto open source, y según dicen en la propia web, siempre lo será. Tiene una interfaz gráfica muy cuidada, y preparada para funcionar en dispositivos móviles. Se puede acceder a demos desde aquí. Se puede descargar desde http://sourceforge.net/projects/suitecrm/.

(más info en http://uncommonbusiness.blogspot.com.es/2013/10/best-free-sugarcrm-alternatives.html y http://blog.capterra.com/free-and-open-source-crm/)

Error debido a GRUB durante arranques de instalación de Windows 10

2016-01-15T12:19:00.001+01:00

En mi nuevo puesto de trabajo me han asignado una máquina con Windows 7 no nueva. Al intentar instalar Windows 10 aparece la línea de comandos y "GRUB>" y no puedo seguir.

Para que arranque el nuevo sistema operativo hay que hacer:

GRUB> rootnoverify (hd0,0)
GRUB> makeactive
GRUB> chainloader +1
GRUB> boot

Con esto ya arranca, pero cada vez que haya que volver a arrancar tendremos volverá a ocurrir lo mismo. Para corregirlo se puede usar la utilidad "Dual-boot Repair 10", disponible en https://www.boyans.net/dual-boot-repair-windows-10.html. Se debe descargar de la url, descomprimirla y ejecutar "DualBootRepair". A continuación ejecutar Automatic Repair.

Como alternativa se puede utilizar la utilidad bootsect de Windows, tal como se explica en
http://superuser.com/questions/949219/how-to-fix-windows-10-boot-loader-from-windows.

jQueryFlot en ASP.net (II) + AJAX

2014-05-21T13:50:00.001+02:00

Siguiendo con la entrada anterior, supongamos ahora que queremos actualizar los datos de la página en función de, por ejemplo, que se seleccione un rango de fechas u otro. Y clara está, esta actualización queremos hacerla sin tener que recargar la página, es decir, mediante AJAX. Tendremos que hacer las siguientes modificaciones:

Nueva función TopMarcasJson en el controlador VentasController que retorne un objeto de tipo JsonResult que será consumido directamente por la función $.plot desde la vista
Modificar la función Top del controlador VentasController para que pase la colección TopMarcas a la vista (será la vista la que vaya a buscar los datos del modelo con la función anterior).
Modificar la vista Ventas/Top para que la función $.plot tome los datos mediante AJAX.

Nueva función TopMarcasJson en VentasController

        /// <summary>
        /// Retorna JSON que se consume mediante AJAX desde la función $.plot de la vista Ventas/Top
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public JsonResult TopMarcasJson(int año)
        {
            var currentUserId = User.Identity.GetUserId();
            var currentUser = _userManager.FindById(User.Identity.GetUserId());
            var currentUserZonas = currentUser.Zonas.Select(z => z.ZonaId);

            var ventasPorMarca = _ctx.Ventas
                .Where(v => v.Año == año)
                .Where(v => currentUserZonas.Contains(v.Zona)) // Incluir sólo los de las zonas del comercial logado
                .GroupBy(v => v.Marca)
                .Select(v => new VentaMarcaViewModel()
                {
                    Marca = v.FirstOrDefault().Marca,
                    Gama = v.FirstOrDefault().Gama,
                    Importe = v.Sum(g => g.Importe),
                    Cantidad = v.Sum(g => g.Cantidad)
                })
                .OrderByDescending(c => c.Importe);

            // Top 10 ventas por marca
            var topVentasPorMarca = ventasPorMarca
                .Take(10) // Top 10
                .ToList();

            // Resto: consolidar como uno sólo
            var restoTopVentasPorMarca = ventasPorMarca
                .Skip(10)
                .Select(v => new { Marca = "Resto", v.Importe, v.Cantidad })
                .GroupBy(v => v.Marca) // Agrupar el resto
                .Select(v => new VentaMarcaViewModel()
                {
                    Marca = "Resto",
                    Gama = "",
                    Importe = v.Sum(g => g.Importe),
                    Cantidad = v.Sum(g => g.Cantidad)
                })
                .ToList() // Lista con un único el elemento, el consolidado
                .FirstOrDefault(); // Coge el primer (y único elemento).

            // Añadir a top ventas el consolidado con el resto.
            if (restoTopVentasPorMarca != null)
                topVentasPorMarca.Add(restoTopVentasPorMarca);

            // Convertir a Json de tipo array de {label, data}
            return Json(
                topVentasPorMarca.Select(v => new { label = v.Marca, data = v.Importe }),
                JsonRequestBehavior.AllowGet
            );
        }

Modificar la función Top de VentasController

Ya no hará falta pasar la colección TopMarcas desde esta función, por lo que podemos suprimir el fragmento de código que hace referencia a eso y retornar la vista vacía (sin modelo).

Modificar script de la vista Ventas/Top

Debemos sustituir el fragmento bajo /** Recoger datos y dibujar **/ por el nuevo:

        function drawPieChart(placeholder, data0, position) {
            $.getJSON("TopMarcasJson", function (data) {
                //succes - data loaded, now use plot:
                $.plot(placeholder, data, {
                    series: {
                        pie: {
                            show: true,
                            tilt: 0.8,
                            highlight: {
                                opacity: 0.25
                            },
                            stroke: {
                                color: '#fff',
                                width: 2
                            },
                            startAngle: 2
                        }
                    },
                    legend: {
                        show: true,
                        position: position || "ne",
                        labelBoxBorderColor: null,
                        margin: [-30, 15]
                    },
                    grid: {
                        hoverable: true,
                        clickable: true
                    }
                })

            });
        }
        drawPieChart(placeholder);

Obsérvese cómo se llama a la función $.getJSON y el retorno obtenido se le pasa a $.plot.

jQueryFlot en ASP.net

2014-05-21T10:15:00.001+02:00

En esta entrada explicaré como crear una vista ASP.net como la que se muestra a continuación, en la que se muestra la lista de las 10 marcas más vendidas más un gráfico de tipo pastel. Para ello utilizo jQueryFlot sobre la plantilla wrapbootstrap-ace comentada en entradas anteriores.

En este caso se tratará de una página “estática”, que recibirá los datos a través del Model. En una entrada posterior utilizaremos json para poder actualizar los datos (y el gráfico) de la vista en función de, por ejemplo, el rango temporal que elija el usuario (este año, últimos 30 días, etc.).

Vista SQL CRM_Ventas

Partimos de una vista de SQL Server existente, cuya de definición es la siguiente:

CREATE VIEW [dbo].[CRM_Ventas]
WITH SCHEMABINDING
AS
SELECT TOP (100) PERCENT 
    Comercial as Zona, 
    [Clasif_ neumático] as Gama, 
    Marca, 
    c.Año, 
    c.Mes, 
    c.[Nº cliente] as IdCliente, 
    c.[Nombre cliente] as NombreCliente, 
    cast(SUM(c.[Imp_ ventas]) as decimal(7,2)) as Importe, 
    cast(SUM(c.[Cdad_ ventas]) as integer) as Cantidad
FROM          dbo.[Cuadro mando Neumalia] AS c
GROUP BY Comercial, [Clasif_ neumático], Marca, c.Año, c.Mes, c.[Nº cliente], c.[Nombre cliente]
HAVING      ([Clasif_ neumático] <> '')

Crear el modelo Venta

Utilizamos Code First desde base de datos para generar la entidad Venta a partir de la vista anterior, siguiendo los siguientes pasos:

En la carpta Models –> Agregar / Nuevo elemento…

ADO.Net Entity Data Model, con nombre = Ventas.

Code First desde base de datos.

Seleccionar la conexión de base de datos que nos interese.

Seleccionar la vista CRM_Ventas

Debe quedarnos algo así:

namespace NeumaliaCRM.Models
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Data.Entity.Spatial;

    [Table("CRM_Ventas")]
    public partial class Venta
    {
        [Key]
        [Column(Order = 0)]
        [StringLength(10)]
        public string Zona { get; set; }

        [Key]
        [Column(Order = 1)]
        [StringLength(30)]
        public string Gama { get; set; }

        [Key]
        [Column(Order = 2)]
        [StringLength(10)]
        public string Marca { get; set; }

        [Key]
        [Column(Order = 3)]
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int Año { get; set; }

        [Key]
        [Column(Order = 4)]
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int Mes { get; set; }

        [Key]
        [Column(Order = 5)]
        [StringLength(20)]
        public string IdCliente { get; set; }

        [Key]
        [Column(Order = 6)]
        [StringLength(30)]
        public string NombreCliente { get; set; }

        public decimal? Importe { get; set; }

        public int? Cantidad { get; set; }
    }
}

Crear el viewmodel TopVentasViewModel

La vista mostrará el top ventas por marca (tal como se muestra en la figura) y también el top ventas por cliente. Crearemos un viewmodel con la siguiente definición:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web;

namespace NeumaliaCRM.ViewModels
{
    public class TopVentasViewModel
    {
        public TopVentasViewModel(IList<VentaClienteViewModel> topClientes, IList<VentaMarcaViewModel> topMarcas)
        {
            TopClientes = topClientes;
            TopMarcas = topMarcas;
        }

        public virtual IList<VentaClienteViewModel> TopClientes { get; set; }
        public virtual IList<VentaMarcaViewModel> TopMarcas { get; set; }
    }

    public class VentaClienteViewModel
    {
        public string NombreCliente { get; set; }
        public decimal? Importe { get; set; }
        public int? Cantidad { get; set; }
    }

    public class VentaMarcaViewModel
    {
        public string Marca { get; set; }
        public string Gama { get; set; }
        public decimal? Importe { get; set; }
        public int? Cantidad { get; set; }
    }
}

Añadir el método Top al controlador VentasController

        //************//
        // Top ventas //
        //************//
        public ActionResult Top(int? año = 2014)
        {
            var currentUserId = User.Identity.GetUserId();
            var currentUser = _userManager.FindById(User.Identity.GetUserId());
            var currentUserZonas = currentUser.Zonas.Select(z => z.ZonaId);

            var topClientes = _ctx.Ventas
                .Where(v => v.Año == año)
                .Where(v => currentUserZonas.Contains(v.Zona)) // Incluir sólo los de las zonas del comercial logado
                .GroupBy(v => v.IdCliente)
                .Select(v => new VentaClienteViewModel()
                {
                    NombreCliente = v.FirstOrDefault().NombreCliente,
                    Importe = v.Sum(g => g.Importe),
                    Cantidad = v.Sum(g => g.Cantidad)
                })
                .OrderByDescending(c => c.Importe)
                .Take(10)
                .ToList();
            
            //////////////////////
            // Ventas por marca //
            //////////////////////

            var ventasPorMarca = _ctx.Ventas
                .Where(v => v.Año == año)
                .Where(v => currentUserZonas.Contains(v.Zona)) // Incluir sólo los de las zonas del comercial logado
                .GroupBy(v => v.Marca)
                .Select(v => new VentaMarcaViewModel()
                {
                    Marca = v.FirstOrDefault().Marca,
                    Gama = v.FirstOrDefault().Gama,
                    Importe = v.Sum(g => g.Importe),
                    Cantidad = v.Sum(g => g.Cantidad)
                })
                .OrderByDescending(c => c.Importe);
                
            // Top 10 ventas por marca
            var topVentasPorMarca = ventasPorMarca
                .Take(10) // Top 10
                .ToList();

            // Resto: consolidar como uno sólo
            var restoTopVentasPorMarca = ventasPorMarca
                .Skip(10)
                .Select(v => new { Marca = "Resto", v.Importe, v.Cantidad })
                .GroupBy(v => v.Marca) // Agrupar el resto
                .Select(v => new VentaMarcaViewModel()
                {
                    Marca = "Resto",
                    Gama = "",
                    Importe = v.Sum(g => g.Importe),
                    Cantidad = v.Sum(g => g.Cantidad)
                })
                .ToList() // Lista con un único el elemento, el consolidado
                .FirstOrDefault(); // Coge el primer (y único elemento).

            // Añadir a top ventas el consolidado con el resto.
            if (restoTopVentasPorMarca != null)
                topVentasPorMarca.Add(restoTopVentasPorMarca);
            
            return View(new TopVentasViewModel(
                topClientes.ToList(),
                topVentasPorMarca.ToList())
            );
        }

Crear la vista Ventas/Top

En mi caso he creado 2 vistas en la carpeta Views/Ventas: Top, y una parcial, TopMarcas (podría haberse hecho con una sola, pero en mi caso me sirve para luego crear “clones” de TopMarcas) con la siguiente definición para cada una de ellas. Obsérvese que la función $.plot requiere que se le pasen los datos en formato json, como una lista de objetos con las propiedades label y data; con código de servidor recorremos la colección Model.TopMarcas y a continuación utilizamos el helper @Html.Raw(Json.Encode(…)) para transformar el IList pasado desde el controller a un objeto json.

Views/Ventas/Top

@model NeumaliaCRM.ViewModels.TopVentasViewModel

<!DOCTYPE html>

<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <title>Index</title>

    @Scripts.Render("~/bundles/wrapbootstrap-ace/js/flot")
    <script type="text/javascript">
    jQuery(function ($) {
        $('.easy-pie-chart.percentage').each(function () {
            var $box = $(this).closest('.infobox');
            var barColor = $(this).data('color') || (!$box.hasClass('infobox-dark') ? $box.css('color') : 'rgba(255,255,255,0.95)');
            var trackColor = barColor == 'rgba(255,255,255,0.95)' ? 'rgba(255,255,255,0.25)' : '#E2E2E2';
            var size = parseInt($(this).data('size')) || 50;
            $(this).easyPieChart({
                barColor: barColor,
                trackColor: trackColor,
                scaleColor: false,
                lineCap: 'butt',
                lineWidth: parseInt(size / 10),
                animate: /msie\s*(8|7|6)/.test(navigator.userAgent.toLowerCase()) ? false : 1000,
                size: size
            });
        })

        $('.sparkline').each(function () {
            var $box = $(this).closest('.infobox');
            var barColor = !$box.hasClass('infobox-dark') ? $box.css('color') : '#FFF';
            $(this).sparkline('html', { tagValuesAttribute: 'data-values', type: 'bar', barColor: barColor, chartRangeMin: $(this).data('min') || 0 });
        });

        var placeholder = $('#piechart-placeholder').css({ 'width': '90%', 'min-height': '150px' });

        /** Recoger datos y dibujar **/

        @{
            var topMarcasJsonForPieChart = new List<object>();
            foreach (var m in Model.TopMarcas)
            {
                topMarcasJsonForPieChart.Add(new { label = m.Marca, data = m.Importe });
            }
        }
        var data = @Html.Raw(Json.Encode(topMarcasJsonForPieChart))

        function drawPieChart(placeholder, data, position) {
            $.plot(placeholder,
                data,
                {
                    series: {
                        pie: {
                            show: true,
                            tilt: 0.8,
                            highlight: {
                                opacity: 0.25
                            },
                            stroke: {
                                color: '#fff',
                                width: 2
                            },
                            startAngle: 2
                        }
                    },
                    legend: {
                        show: true,
                        position: position || "ne",
                        labelBoxBorderColor: null,
                        margin: [-30, 15]
                    },
                    grid: {
                        hoverable: true,
                        clickable: true
                    }
                })
        }
        drawPieChart(placeholder, data);

        /**
        we saved the drawing function and the data to redraw with different position later when switching to RTL mode dynamically
        so that's not needed actually.
        */

            placeholder.data('chart', data);
            placeholder.data('draw', drawPieChart);

            var $tooltip = $("<div class='tooltip top in'><div class='tooltip-inner'></div></div>").hide().appendTo('body');
            var previousPoint = null;

            placeholder.on('plothover', function (event, pos, item) {
                if (item) {
                    if (previousPoint != item.seriesIndex) {
                        previousPoint = item.seriesIndex;
                        var tip = item.series['label'] + " : " + item.series['percent'] + '%';
                        $tooltip.show().children(0).text(tip);
                    }
                    $tooltip.css({ top: pos.pageY + 10, left: pos.pageX + 10 });
                } else {
                    $tooltip.hide();
                    previousPoint = null;
                }
            });

            $('#recent-box [data-rel="tooltip"]').tooltip({ placement: tooltip_placement });
            function tooltip_placement(context, source) {
                var $source = $(source);
                var $parent = $source.closest('.tab-content')
                var off1 = $parent.offset();
                var w1 = $parent.width();

                var off2 = $source.offset();
                var w2 = $source.width();

                if (parseInt(off2.left) < parseInt(off1.left) + parseInt(w1 / 2)) return 'right';
                return 'left';
            }

            $('.dialogs,.comments').slimScroll({
                height: '300px'
            });

        })
</script>

</head>
<body>

   @Html.Partial("TopClientes", Model.TopClientes)
   @Html.Partial("TopMarcas", Model.TopMarcas)
</body>
</html>

Views/Ventas/TopMarcas

@model IEnumerable<NeumaliaCRM.ViewModels.VentaMarcaViewModel>

<div class="col-sm-5">
    <div class="widget-box">
        <div class="widget-header widget-header-flat widget-header-small">
            <h5>
                <i class="icon-signal"></i>
                Top 10 marcas
            </h5>

            <div class="widget-toolbar no-border">
                <button class="btn btn-minier btn-primary dropdown-toggle" data-toggle="dropdown">
                    Este año
                    <i class="icon-angle-down icon-on-right bigger-110"></i>
                </button>

                <ul class="dropdown-menu pull-right dropdown-125 dropdown-lighter dropdown-caret">
                    <li class="active">
                        <a href="#" class="blue">
                            <i class="icon-caret-right bigger-110">&nbsp;</i>
                            Este año
                        </a>
                    </li>

                    <li>
                        <a href="#">
                            <i class="icon-caret-right bigger-110 invisible">&nbsp;</i>
                            Año anterior
                        </a>
                    </li>

                    <li>
                        <a href="#">
                            <i class="icon-caret-right bigger-110 invisible">&nbsp;</i>
                            Este mes
                        </a>
                    </li>

                    <li>
                        <a href="#">
                            <i class="icon-caret-right bigger-110 invisible">&nbsp;</i>
                            Siempre
                        </a>
                    </li>
                </ul>
            </div>
        </div>
    
        <div class="widget-body">
            <div class="widget-main">
                <div>
                    <table class="table">
                        <tr>
                            <th>
                                @Html.DisplayNameFor(model => model.Marca)
                            </th>
                            <th>
                                @Html.DisplayNameFor(model => model.Gama)
                            </th>
                            <th>
                                @Html.DisplayNameFor(model => model.Importe)
                            </th>
                            <th>
                                @Html.DisplayNameFor(model => model.Cantidad)
                            </th>
                            <th></th>
                        </tr>

                        @foreach (var item in Model)
                        {
                            <tr>
                                <td>
                                    @Html.DisplayFor(modelItem => item.Marca)
                                </td>
                                <td>
                                    @Html.DisplayFor(modelItem => item.Gama)
                                </td>
                                <td>
                                    @Html.DisplayFor(modelItem => item.Importe)
                                </td>
                                <td>
                                    @Html.DisplayFor(modelItem => item.Cantidad)
                                </td>
                            </tr>
                        }

                    </table>                 
                </div>
                
                <div id="piechart-placeholder"></div>

                <div class="hr hr8 hr-double"></div>

                <div class="clearfix">
                    <div class="grid3">
                        <span class="grey">
                            <i class="icon-facebook-sign icon-2x blue"></i>
                            &nbsp; likes
                        </span>
                        <h4 class="bigger pull-right">1,255</h4>
                    </div>

                    <div class="grid3">
                        <span class="grey">
                            <i class="icon-twitter-sign icon-2x purple"></i>
                            &nbsp; tweets
                        </span>
                        <h4 class="bigger pull-right">941</h4>
                    </div>

                    <div class="grid3">
                        <span class="grey">
                            <i class="icon-pinterest-sign icon-2x red"></i>
                            &nbsp; pins
                        </span>
                        <h4 class="bigger pull-right">1,050</h4>
                    </div>
                </div>
            </div><!-- /widget-main -->
        </div><!-- /widget-body -->
    </div><!-- /widget-box -->
</div>

Mini-CRM en ASP.Net (IV) “En construcción!”

2014-05-20T16:07:00.001+02:00

Añadiendo la entidad VentasPorMarca

Los comerciales necesitan el cuadro de ventas por marca, en el que aparezcan cantidad e importe del año en curso y del anterior. Mis datos están en una tabla en la que cada línea es una agrupación de ventas por ejercicio, mes, zona y marca. Lo primero que necesito es una vista en que se muestren las ventas por zona y marca, del año en curso y del anterior. La creo en la base de datos así:

CREATE VIEW [dbo].[CRM_VentasPorMarcaYZona]
WITH SCHEMABINDING
AS
SELECT     TOP (100) PERCENT zm.[Clasif_ neumático] as Gama, zm.Marca, zm.Comercial as Zona, vPrev.i AS ImporteAnt, vPrev.c AS CantidadAnt, vCurr.i AS ImporteAct, 
                      vCurr.c AS CantidadAct
FROM         (SELECT     Marca, [Clasif_ neumático], Comercial
                       FROM          dbo.[Cuadro mando Neumalia] AS c
                       GROUP BY [Clasif_ neumático], Marca, Comercial
                       HAVING      ([Clasif_ neumático] <> '')) AS zm LEFT OUTER JOIN
                          (SELECT     Año, Marca AS m, Comercial AS z, SUM([Imp_ ventas]) AS i, SUM(cast([Cdad_ ventas] as integer)) AS c
                            FROM          dbo.[Cuadro mando Neumalia]
                            GROUP BY Año, Marca, Comercial
                            HAVING      (Año = DATEPART(year, GETDATE()) - 1)) AS vPrev ON zm.Marca = vPrev.m AND zm.Comercial = vPrev.z LEFT OUTER JOIN
                          (SELECT     Año, Marca AS m, Comercial AS z, SUM([Imp_ ventas]) AS i, SUM(cast([Cdad_ ventas] as integer)) AS c
                            FROM          dbo.[Cuadro mando Neumalia] AS [Cuadro mando Neumalia_1]
                            GROUP BY Año, Marca, Comercial
                            HAVING      (Año = DATEPART(year, GETDATE()))) AS vCurr ON zm.Marca = vCurr.m AND zm.Comercial = vCurr.z
ORDER BY zm.Marca

A continuación creo la clase VentasPorMarca:

namespace NeumaliaCRM.Models
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Data.Entity.Spatial;

    [Table("CRM_VentasPorMarcaYZona")]
    public partial class VentasPorMarca
    {
        [Key]
        [Column(Order = 0)]
        [StringLength(30)]
        public string Gama { get; set; }

        [Key]
        [Column(Order = 1)]
        [StringLength(10)]
        public string Marca { get; set; }

        [Key]
        [Column(Order = 2)]
        [StringLength(10)]
        public string Zona { get; set; }

        public decimal? ImporteAnt { get; set; }

        public int? CantidadAnt { get; set; }

        public decimal? ImporteAct { get; set; }

        public int? CantidadAct { get; set; }
    }
}

También se puede crear a partir de la vista añadiendo

Mini-CRM en ASP.Net (III)

2014-05-02T16:10:00.001+02:00

Mostrar ventas del comercial logado

Antes de nada, algunos links interesantes:

En este apartado vamos a ver cómo hacemos un volcado de las ventas pertenecientes al comercial logado en la aplicación.

Ya comenté que cada comercial tiene asignadas unas zonas y cada venta están asociada a una zona (y no directamente a un comercial). Esto quizás suene un poco raro, pero es como lo tenemos en mi empresa… Por lo tanto, tenemos una relación N a M entre comerciales y ventas a través de las zonas. He creado una nueva tabla AspNetUsers_Zonas que relaciona los comerciales (a través del User_Id) con las ventas (a través del ZonaId):

CREATE TABLE [dbo].[AspNetUsers_Zonas](
    [User_Id] [nvarchar](128) NOT NULL,
    [ZonaId] [nvarchar](10) NOT NULL,
CONSTRAINT [PK_dbo.AspNetUsers_ZonasNeumalia] PRIMARY KEY CLUSTERED 
(
    [User_Id] ASC,
    [ZonaId] ASC
)

En el explorador de soluciones de VS, sobre la carpeta Models clicar botón derecho y Agregar Nuevo elemento. Seleccionar ADO.NET Entity Data Model y en nombre escribir Zona.

Utilizaremos Codefirst (para más info ver codefirst reverse ingeniering)

Se ha generado la nueva entidad Zona. Abrir el fichero y modificarlo tal como se muestra a continuación:

namespace NeumaliaCRM.Models
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Data.Entity.Spatial;

    [Table("AspNetUsers_ZonasNeumalia")]
    public partial class Zona
    {
        //[Key]
        //[Column("MiCRM_User_Id", Order = 0)]
        //public string UserId { get; set; }

        [Key]
        [Column(Order = 1)]
        [StringLength(10)]
        public string ZonaId { get; set; }

        [Key]
        [Column("NeumaliaCRM_User_Id", Order = 0)]
        public virtual NeumaliaCRM_User User { get; set; }
    }
}

Y modificar también el fichero IdentityModels:

using Microsoft.AspNet.Identity.EntityFramework;
using System.Data.Entity;
using NeumaliaCRM.Models;
using System.Collections.Generic;

namespace NeumaliaCRM.Models
{
    // You can add profile data for the user by adding more properties to your ApplicationUser class (NeumaliaCRM_User), please visit http://go.microsoft.com/fwlink/?LinkID=317594 to learn more.
    public class NeumaliaCRM_User : IdentityUser
    {
        public virtual IList<Zona> Zonas { get; set; }
    }

    public class MyDbContext : IdentityDbContext<NeumaliaCRM_User>
    {
        public MyDbContext()
            : base("AESQL2008ConnectionString")
        {
        }

        public DbSet<Venta> Ventas { get; set; }
    }
}

A continuación creamos mediante scaffolding un nuevo controlador y nueva vista para las ventas: botón derecho sobre Controllers, Agregar Controller. Abrir el nuevo controlador y añadir el código necesario que se muestra a continuación:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using NeumaliaCRM.Models;
using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.EntityFramework;

namespace NeumaliaCRM.Controllers
{
    [Authorize]
    public class VentasController : Controller
    {
        private MyDbContext _ctx;
        private UserManager<NeumaliaCRM_User> _userManager;

        public VentasController()
        {
            _ctx = new MyDbContext();
            _userManager = new UserManager<NeumaliaCRM_User>(new UserStore<NeumaliaCRM_User>(_ctx));
        }

        //
        // GET: /CuadroDeMando/Ventas/
        public ActionResult Index()
        {
            var currentUserId = User.Identity.GetUserId();
            var currentUser = _userManager.FindById(User.Identity.GetUserId());
            var currentUserZonas = currentUser.Zonas.Select(z => z.ZonaId);

            var ventas = _ctx.Ventas.Where(v => currentUserZonas.Contains(v.ZonaId)).Select(v => v);

            return View(ventas);
        }

Mini-CRM en ASP.Net (II)

2014-04-28T17:47:00.000+02:00

Creación del proyecto

Desde VS Express 2013 para Web he creado un nuevo proyecto de tipo aplicación ASP.Net MVC con autenticación de tipo cuentas de usuario individuales (es el defecto).

Al crear el proyecto se muestra una página con información sobre los siguientes pasos a realizar en el proyecto. A tener en cuenta en mi proyecto:

La opción Autenticación, si se selecciona, muestra cómo registrarse e iniciar sesión
Creación de temas mediante Bootstrap
Asegurarse de que la aplicación esté lista para el entorno de producción

Si clicamos cualquiera de los 2 primeros nos redirige a:

[…]
This topic explains the options for creating ASP.NET web projects in Visual Studio 2013 with Update 2.
The new dialogs and templates include the following new features compared to earlier versions of Visual Studio:

A simple UI for creating projects that offer support for multiple ASP.NET frameworks (Web Forms, MVC, and Web API).
ASP.NET Identity, a new ASP.NET membership system that works the same in all ASP.NET frameworks and works with web hosting software other than IIS.
The use of Bootstrap to provide responsive design and theming capabilities.
New features for Web Forms that used to be offered only for MVC, such as automatic test project creation and an Intranet site template.

[…]

En este momento nos centraremos en el apartado ASP.Net Identity.

Autenticación mediante ASP.Net Identity

ASP.Net Identity es el nuevo sistema de autenticación para ASP.Net, tal como se explica en ASP.Net Identity. Para añadirlo a mi proyecto sigo los pasos que se explican en el link:

Adding ASP.NET Identity to an Empty or Existing Web Forms Project

A modo de resumen:

Para añadir ASP.Net Identity al proyecto, se puede utilizar NuGet tal como muestra la siguiente figura:

Para mi proyecto cambio la conexión que viene por defecto por una a mi propia base de datos lo cual hace que se generen automáticamente en ella las tablas necesarias.

De momento no necesito utilizar proveedores externos (facebook, gmail…)

Bootstrap (responsive web)

Las plantillas de proyecto de Visual Studio 2013 utilizan Bootstrap para proporcionar un diseño responsive, lo que significa que los diseños pueden adaptarse dinámicamente a los diferentes tamaños de ventana del navegador, y por tanto, al tamaño de los diferentes dispositivos consumidores.

En bootswatch.com podemos encontrar temas alternativos al que aparece por defecto en nuestra nueva aplicación (aquí se explica en detalle cómo proceder). Además de los temas free también existen otros mucho más elaborados de pago (rondan los 8$ a 18$). Es el caso de los que podemos encontrar en {wrap}bootstrap. Para nuestro mini-CRM hemos comprado la plantilla denominada Ace.

Aquí hemos tenido que dedicar unas cuantas horas a encajar la nueva plantilla.

Descomprimir el paquete descargado y añadirlo al proyecto
A partir de index.html de la nueva plantilla, crear una nueva vista _LayoutAce.cshtml con la que reemplazar la actual _Layout.cshtml. Para que el proyecto use la nueva plantilla, cambiar la una por la otra en _ViewStart.cshtml.
```
@{
    Layout = "~/Views/Shared/_LayoutAce.cshtml";
}
```
Crear los bundles de la nueva plantilla (ver bundling and minification). Para ello en AppStart/BundleConfig.cs añadir las siguientes líneas:
```
// Bundles de wrapbootstrap-Ace
bundles.Add(new ScriptBundle("~/bundles/wrapbootstrap-ace/js").Include(
    "~/templates/wrapbootstrap_ace/assets/js/*.js", "~/templates/wrapbootstrap_ace/assets/js/uncompressed/*.js"));

bundles.Add(new StyleBundle("~/bundles/wrapbootstrap-ace/css").Include(
    "~/templates/wrapbootstrap_ace/assets/css/*.css", "~/templates/wrapbootstrap_ace/assets/css/ace.min.css"));
```
Adaptar _LayoutAce.cshtml. Cambios principales:

[…]
<head>
    <meta charset="utf-8" />
    <title>Mi CRM</title>

    <meta name="description" content="Common form elements and layouts" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />

    @Styles.Render("~/bundles/wrapbootstrap-ace/css")

    @Scripts.Render("~/bundles/jquery")
    @Scripts.Render("~/bundles/jqueryval")
    @Scripts.Render("~/bundles/modernizr")
    @Scripts.Render("~/bundles/bootstrap")
    @Scripts.Render("~/bundles/wrapbootstrap-ace/js")

[…]

   <li class="light-blue">
        @Html.Partial("_LoginPartial")
   </li><!—login-->

[…]
   <div class="page-content">
        @RenderBody()
   </div>

Adaptar la pantalla de inicio de sesión Account/Login.cshtml:

@model NeumaliaCRM.Models.LoginViewModel

@{
    Layout = null;
}
@{
    ViewBag.Title = "Inicio de sesión";
}

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="utf-8" />
    <title>CRM Neumalia - @ViewBag.Title</title>

    <meta name="description" content="User login page" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />

    <!-- basic styles -->

    <link href="~/templates/wrapbootstrap_ace/assets/css/bootstrap.min.css" rel="stylesheet" />
    <link rel="stylesheet" href="~/templates/wrapbootstrap_ace/assets/css/font-awesome.min.css" />

    <!--[if IE 7]>
      <link rel="stylesheet" href="~/templates/wrapbootstrap_ace/assets/css/font-awesome-ie7.min.css" />
    <![endif]-->
    <!-- page specific plugin styles -->
    <!-- fonts -->

    <link rel="stylesheet" href="~/templates/wrapbootstrap_ace/assets/css/ace-fonts.css" />

    <!-- ace styles -->

    <link rel="stylesheet" href="~/templates/wrapbootstrap_ace/assets/css/ace.min.css" />
    <link rel="stylesheet" href="~/templates/wrapbootstrap_ace/assets/css/ace-rtl.min.css" />

    <!--[if lte IE 8]>
      <link rel="stylesheet" href="~/templates/wrapbootstrap_ace/assets/css/ace-ie.min.css" />
    <![endif]-->
    <!-- inline styles related to this page -->
    <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
    <!--[if lt IE 9]>
    <script src="~/templates/wrapbootstrap_ace/assets/js/html5shiv.js"></script>
    <script src="~/templates/wrapbootstrap_ace/assets/js/respond.min.js"></script>
    <![endif]-->
    
    @*extraído de site.css...*@
    <style>
        /* styles for validation helpers */
        .field-validation-error {
        color: #b94a48;
        font-size:small;
        }

        .field-validation-valid {
        display: none;
        }

        input.input-validation-error {
        border: 1px solid #b94a48;
        }

        input[type="checkbox"].input-validation-error {
        border: 0 none;
        }

        .validation-summary-errors {
        color: #b94a48;
        }

        .validation-summary-valid {
        display: none;
        }
    </style>

</head>

<body class="login-layout">
    <div class="main-container">
        <div class="main-content">
            <div class="row">
                <div class="col-sm-10 col-sm-offset-1">
                    <div class="login-container">
                        <div class="center">
                            <h1>
                                <i class="icon-group green"></i>
                                <span class="red">CRM</span>
                                <span class="white">Neumalia</span>
                            </h1>
                            <h4 class="blue">&copy; AutoEquip</h4>
                        </div>

                        <div class="space-6"></div>

                        <div class="position-relative">
                            <div id="login-box" class="login-box visible widget-box no-border">
                                <div class="widget-body">
                                    <div class="widget-main">
                                        <h4 class="header blue lighter bigger">
                                            <i class="icon-coffee green"></i>
                                            Introduce tus credenciales
                                        </h4>

                                        <div class="space-6"></div>

                                        @using (Html.BeginForm("Login", "Account", new { ReturnUrl = ViewBag.ReturnUrl }, FormMethod.Post, new { @class = "form-horizontal", role = "form" }))
                                        {
                                            @Html.AntiForgeryToken()
                                            @Html.ValidationSummary(true)

                                            <fieldset>
                                                <label class="block clearfix">
                                                    <span class="block input-icon input-icon-right">
                                                        @Html.TextBoxFor(m => m.UserName, new { @class = "form-control", @placeholder="Nombre de usuario" })
                                                        @Html.ValidationMessageFor(m => m.UserName)
                                                        <i class="icon-user"></i>
                                                    </span>
                                                </label>

                                                <label class="block clearfix">
                                                    <span class="block input-icon input-icon-right">
                                                        @Html.PasswordFor(m => m.Password, new { @class = "form-control", @placeholder="Contraseña" })
                                                        @Html.ValidationMessageFor(m => m.Password)
                                                        <i class="icon-lock"></i>
                                                    </span>
                                                </label>

                                                <div class="space"></div>

                                                <div class="clearfix">

                                                    @Html.CheckBoxFor(m => m.RememberMe)
                                                    @Html.LabelFor(m => m.RememberMe)

                                                    <button type="submit" class="width-45 pull-right btn btn-sm btn-primary">
                                                        <i class="icon-key"></i>
                                                        Iniciar sesión
                                                    </button>
                                                </div>

                                                <div class="space-4"></div>
                                            </fieldset>
                                        }

                                    </div><!-- /widget-main -->

                                </div><!-- /widget-body -->
                            </div><!-- /login-box -->

                        </div><!-- /position-relative -->
                    </div>
                </div><!-- /.col -->
            </div><!-- /.row -->
        </div>
    </div><!-- /.main-container -->
    
</body>
</html>

Adaptar _LoginPartial.cshtml:

@using Microsoft.AspNet.Identity
@if (Request.IsAuthenticated)
{
    using (Html.BeginForm("LogOff", "Account", FormMethod.Post, new { id = "logoutForm", @class = "navbar-right" }))
    {
        @Html.AntiForgeryToken()
    }

    <a data-toggle="dropdown" href="#" class="dropdown-toggle">
        <img class="nav-user-photo" src="~/templates/wrapbootstrap_ace/assets/avatars/avatar2.png" alt="Foto usuario" />
        <span class="user-info">
            <small>Hola,</small>
            @User.Identity.GetUserName()
        </span>

        <i class="icon-caret-down"></i>
    </a>

    <ul class="user-menu pull-right dropdown-menu dropdown-yellow dropdown-caret dropdown-close">
        <li>
            <a href="/Account/Manage">
                <i class="icon-cog"></i>
                Configurar cuenta
            </a>
        </li>

        <li>
            <a href="#">
                <i class="icon-user"></i>
                Perfil
            </a>
        </li>

        <li class="divider"></li>

        <li>
            <a href="javascript:document.getElementById('logoutForm').submit()">
                <i class="icon-off"></i>
                Cerrar sesión
            </a>
        </li>
    </ul>
}
else
{
    <ul class="nav navbar-nav navbar-right">
        @*<li>@Html.ActionLink("Registrarse", "Register", "Account", routeValues: null, htmlAttributes: new { id = "registerLink" })</li>*@
        <li>@Html.ActionLink("Iniciar sesión", "Login", "Account", routeValues: null, htmlAttributes: new { id = "loginLink" })</li>
    </ul>
}

Mini-CRM en ASP.Net (I)

2014-04-28T12:34:00.000+02:00

Las próximas entradas de mi blog las dedicaré a recoger mi implementación de una aplicación ASP.Net de principio a fin. No pretende enseñar nada, simplemente reflejar mis observaciones, aprendizajes, conclusiones…

En esta primera entrega haré una pequeña introducción mencionando los requisitos tanto funcionales como técnicos, explicaré porqué he descartado utilizar alternativas ya existentes, y por último comentaré las herramientas de desarrollo, tecnologías y lenguaje de programación que utilizaré.

Requisitos

Mi empresa necesita una aplicación para sus comerciales que cumpla con los siguientes requisitos funcionales iniciales:

A cada comercial se le deben mostrar los datos referentes a los clientes de la(s) zona(s) que tiene asignada(s).
Top clientes.
Ventas/mes (unidades e importe), del año en curso y del anterior.
Ventas/marca, idem.
Ventas/canal, idem.
Ventas/provincia, idem.
Visitas a la web.
Histórico de facturas/presupuestos/pedidos.
Nuevo presupuesto/pedido para un cliente.

Y los siguientes requisitos técnicos:

Consumible desde fuera de la intranet, a ser posible desde distintos dispositivos (portátil/PC, tablet, móvil…)
Sólo pueden entrar usuarios autorizados (los comerciales).

1as decisiones: ¿desarrollo desde cero o utilizar algo ya existente?

Siempre que se pide una aplicación de este tipo debemos hacernos la pregunta de si no iremos a reinventar la rueda, es decir, si ya existen CRMs (tanto comerciales como open source) para qué vamos a implementar el nuestro propio.

En mi empresa hemos descartado las alternativas de pago por motivos presupuestarios (y por alguna mala experiencia anterior con un CRM muy conocido), y nos hemos dado un par de días para hacer un sondeo de las alternativas open source existentes.

Si buscamos CRMs en OpenPYME, codeplex.com o en sourgeforce.com encontraremos infinidad de alternativas. En nuestro caso hemos acotado la búsqueda centrándonos en aquellos que cumplen los siguientes requisitos:

Preferentemente desarrollados en .Net (porque es la tecnología que más dominamos).
Que estén en un estado correcto.

Después de mucho buscar, la opción que más me gustó fue Dolibarr. Uno de sus puntos fuertes es que es muy fácil de instalar y funciona a la primera. No me voy a extender en describir el producto porque en su web está muy bien detallado y porque para quien le interese creo que lo mejor es instalárselo y probarlo.

Dolibarr, no obstante, es mucho más que un CRM, es también ERP y más cosas. Y yo lo que necesito es simplemente un pequeño CRM, con una funcionalidad bastante limitada y concreta.

Examinando un poco más detenidamente el código de esta fantástica alternativa llego a la conclusión de que me voy a meter en un gran berenjenal intentando recortar todo aquello que no necesito, adaptando lo que sí y acabando de añadir lo que le falta para cumplir con mis requisitos.

En definitiva, para lo que mi empresa me pide, creo que tampoco en una buena solución lo de adoptar Dolibarr.

¿Y entonces?

Construiré mi propio mini-CRM.

Herramientas y tecnologías a utilizar

Dado que uno de los requisitos es que sea una aplicación que se pueda consumir desde diferentes tipos de dispositivos y a través de internet, crearemos una aplicación web (todos los CRMs que conozco lo son).

Y dado que la tecnología con la que más cómodos nos sentimos es .Net, crearemos un nuevo proyecto ASP.Net.

La herramienta de desarrollo natural (que además es gratuita!) es Visual Studio Express 2013 para Web, y es lo que utilizaré.

Manejar excepciones en ASP.Net Web API (Handling Exceptions in ASP.NET Web API)

2013-10-30T17:58:00.001+01:00

Cuando en una aplicación ASP.Net Web API se produce una excepción en una función interna (por ejemplo busco un cliente que no existe y no tengo controlada esta situación), si no se captura la excepción se enviará un error HTTP 500 (Internal Server Error) con el mensaje genérico

<Error><Message>An error has occurred.</Message></Error>

Si queremos enviar un mensaje que aporte más información al cliente podemos crear una clase derivada de
ExceptionFilterAttribute, tal como esta

public class MyExceptionFilter:ExceptionFilterAttribute
{
public override void OnException(HttpActionExecutedContext context)
{
HttpResponseMessage msg = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("Se ha producido un error en la app."),
ReasonPhrase = "Se ha producido un error en la app."
};
context.Response = msg;
}
}

Para usarla de forma global (que todos los controllers la usen) podemos añadir la siguiente línea al Application_Start() de Global.asax:

GlobalConfiguration.Configuration.Filters.Add(new WebAPIExceptionsDemo.MyExceptionFilter());

O bien, para usarla para determinados controllers, añadir a estos el atributo creado:

[MyExceptionFilter]
public class CustomerController
{
...

Esta entrada es un extracto del artículo http://www.codeguru.com/csharp/.net/net_asp/handling-exceptions-in-asp.net-web-api.htm.

Estrategia a seguir para el manejo de excepciones (Exception handling strategy)

2013-10-30T17:34:00.005+01:00

En esta entrada copio el post http://stackoverflow.com/questions/14973642/how-using-try-catch-for-exception-handling-is-best-practice tal cual por parecerme muy interesante:

[...]

My exception handling strategy is :

To catch all unhandled exceptions by hooking to the Application.ThreadException event, then decide :
- For a UI application: to pop it to the user with an apology message (winforms)
- For a Service or a Console application: log it to a file (service or console)

Then I always enclose every piece of code that is run externally in try/catch :

All events fired by the Winforms infrastructure (Load, Click, SelectedChanged...)
All events fired by third party components

Then I enclose in 'try/catch'

All the operations that I know might not work all the time (IO operations, calculations with a potential zero division...). In such a case, I throw a new ApplicationException("custom message", innerException) to keep track of what really happened

Additionally, I try my best to sort exceptions correctly. There are exceptions which:

need to be shown to the user immediately
require some extra processing to put things together when they happen to avoid cascading problems (ie: put .EndUpdate in the finally section during a TreeView fill)
the user does not care, but it is important to know what happened. So I always log them:
- In the event log
- or in a .log file on the disk

It is a good practice to design some static methods to handle exceptions in the application top level error handlers.

I also force myself to try to:

Remember ALL exceptions are bubbled up to the top level. It is not necessary to put exception handlers everywhere.
Reusable or deep called functions does not need to display or log exceptions : they are eigher bubbled up automatically or rethrown with some custom messages in my exception handlers.

So finally :

Bad:

// DON'T DO, THIS IS BAD
try
{
    ...
}
catch 
{
   // only air...
}

Useless:

// DONT'T DO, THIS IS USELESS
try
{
    ...
}
catch(Exception ex)
{
    throw ex;
}

What I do at the top level:

// i.e When the user clicks on a button
try
{
    ...
}
catch(Exception ex)
{
    ex.Log(ex); // Log exception
    // ex.LogAndDisplay(ex); // Log exception, then show it to the user with apologies...
}

What I do in some called functions:

// Calculation module
try
{
    ...
}
catch(Exception ex)
{
    // Add useful information to the exception
    throw new ApplicationException("Something wrong happened in the calculation module :", ex);
}

// IO module
try
{
    ...
}
catch(Exception ex)
{
    throw new ApplicationException(string.Format("I cannot write the file {0} to {1}", fileName, directoryName), ex);
}

There is a lot to do with exception handling (Custom Exceptions) but thoses rules I try to keep in mind are enough for the simple applications I do.

Herramienta para crear entradas en blogger.com

2013-06-03T18:43:00.001+02:00

Para mí la mejor Windows Live Writer.

Consumir ASP.NET Web API desde Excel

2013-06-03T18:38:00.001+02:00

En Excel existe la posibilidad de importar datos de una aplicación ASP.NET Web API, lo que nos permite trabajar con ellos y/o analizarlos de forma sencilla. Para ello se debe pulsar la opción Datos / Desde Web e indicar la URL adecuada.

Sin embargo, si no se indica lo contrario, Excel recogerá los datos en formato json, lo cual no sirve. Para solventar este problema se puede forzar a que la aplicación Web API retorne xml (aunque eso impedirá que podamos ver formato json en otros clientes, por ejemplo los navegadores, tal como se explica en el post anterior).

Para forzar a la aplicación que siempre envíe formato xml se puede añadir al método Application_Start de Global.asax la siguiente sentencia:

    GlobalConfiguration.Configuration.Formatters.Remove(         GlobalConfiguration.Configuration.Formatters.JsonFormatter     );

Obtener Json en vez de XML (o al revés) en ASP.NET Web API

2013-06-03T14:20:00.000+02:00

ASP.NET Web API permite retornar XML ó Json modificando los parámetros adecuados en el Application_Start() del Global.asax. Así por ejemplo:

    GlobalConfiguration.Configuration.Formatters.Remove( GlobalConfiguration.Configuration.Formatters.JsonFormatter );

elimina el formato Json y por lo tanto siempre retorna xml. Otras posibilidades son:

    GlobalConfiguration.Configuration.Formatters.XmlFormatter.UseXmlSerializer = true; //Retorna json!!!???
    GlobalConfiguration.Configuration.Formatters.JsonFormatter.UseDataContractJsonSerializer = true;

    GlobalConfiguration.Configuration.Formatters.Add(GlobalConfiguration.Configuration.Formatters.XmlFormatter);

     GlobalConfiguration.Configuration.Formatters.Add(GlobalConfiguration.Configuration.Formatters.JsonFormatter);

Si no se cambia esta configuración en el Application_Start(), el retorno será Json ó xml dependiendo del request header

enviado. Así, si por ejemplo utilizamos el Internet Explorer para probar el web api implementado, el resultado lo obtendremos

en un fichero en formato json, mientras que si lo probamos con Firefox o Chrome el resultado lo obtendremos en formato

xml. Esto es porque cada uno de los navegadores envía un request header diferente.

Lo mismo ocurrirá con

nuestra aplicación cliente: dependiendo del request header que use, la aplicación servidor web api retornará un formato

u otro (json ó xml). Así si queremos forzar a que nos retorne json habría que forzar Accept: json/xml en el request header,

mientras que si nos interesa xml habría que forzar Accept: text/xml ó Accept: application/xml.

Si nos interesa utilizar como cliente un navegador web, habría que hacer algo similar utilizando alguna extensión. Por

ejemplo, para Chrome podemos utilizar la extensión Header Hacker que nos permite configurar los request headers. Para

obtener json (que es más legible) habría que añadir una línea para reemplazar:

    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

por:

    Accept: json/xml

De forma análoga, para Firefox se puede utilizar la extensión Modify Headers.

Mostrar entidad relacionada como lista desplegable (combo) en ASP.Net

2013-04-25T18:35:00.002+02:00

En un proyecto ASP.Net, supongamos que 2 entidades relacionadas como por ejemplo Cliente y Provincia (relación N a 1). En la ficha de Cliente podemos mostrar la Provincia como una lista desplegable de selección (combo) de la siguiente forma:

1) En la acción Edit (y/o Create) del ClientesController añadir:

      var ctx = new MyProject.Models.MyContext();
      ViewData["ProvinciaId"] = new SelectList(ctx.Provincias, "Id", "Name");

...donde Id y Name son campos de la entidad Provincias.

OJO: El identificador del ViewData debe llamarse exactamente igual que el campo de la entidad principal que hace referencia a la entidad relacionada.

Si queremose un elemento seleccionado por defecto, podemos hacerlo así:

      var ctx = new MyProject.Models.MyContext();
      var provinciasSelectList =

            from p in ctx.Provincias

            select new { Value = p.Id, Text = p.Name, Selected = (p.Name == "Málaga") };

      ViewData["ProvinciaId"] = new SelectList(provinciasSelectList , "Value", "Text");

2) En al vista que toque (Clientes/Edit y/o Clientes/Create) añadir:

     Html.DropDownList("ProvinciasList")

Sentencia SQL que retorna el número de registros en cada fecha

2013-04-24T10:17:00.005+02:00

Imaginemos que tenemos una tabla ArticleIds que contiene un campo CreationDate definido como datetime con valor predeterminado = getDate( ), y queremos averiguar cuántos registros se han creado cada día entre las 9:00 y las 12:00:

Sentencia SQL:

SELECT t.Fecha, COUNT(*) AS Cuenta FROM (
SELECT CONVERT(CHAR(10), creationDate , 103) AS Fecha, CONVERT(CHAR(8), creationDate , 114) as Hora
    FROM [AESQL2008].[dbo].ArticleIds
    WHERE CONVERT(CHAR(5), creationDate , 114) > '09:00' AND CONVERT(CHAR(5), creationDate , 114) < '12:00'
) t
GROUP BY t.Fecha
ORDER BY t.Fecha

Resultado:

Fecha           Cuenta
04/17/2013    113
04/18/2013    1050
04/19/2013    8278
04/20/2013    1889
04/22/2013    1936
04/23/2013    1269
04/24/2013    235

Exinten otras maneras de hacer lo mismo (p.e. utilizando DATEADD como se explica aquí) pero ésta quizás es la más simple.

Qué tecnología de UX usar para una nueva aplicación (Silverlight/WPF, Metro ó HTML5)

2012-10-09T16:27:00.000+02:00

Etiquetas de Technorati: Silverlight,WPF,Metro,HTML5

Fuente: http://www.telerikwatch.com/2011/09/how-to-pick-your-platform-silverlight.html

Lanzamiento de Visual Studio 2012

2012-10-09T14:04:00.001+02:00

El pasado jueves 4 de octubre asistí al evento de lanzamiento del nuevo Visual Studio 2012. En este post quiero resumir lo más destacable.

9:30 Bienvenida David Carmona (Microsoft)

Tendencias actuales en el mundo del software: movilidad + cloud.
Apps modernas: centradas en el usuario (no tanto en el proceso de negocio), social (integración con otros: Yammer, Twitter, Facebook…), democratización de los datos de la empresa de forma que estén integrados en los procesos de todos los usuarios (Bigdata), y, que permitan la mejora continua.
VS2012, herramienta para el desarrollo de apps modernas y ALM (Gestión del ciclo de vida de las aplicaciones).
Apps desktop vs apps para dispositivos conectados. Las primeras siguen siendo los reyes para entrada de datos. Para las segundas está emergiendo con fuerza HTML5.
Typescript (alineado con ECMAScript 6): capa sobre javascript que permite intellisense, refactoring…
Vuelven las herramientas para Compact Framework (en VS2010 se habían sacado).
Phonegap y Mono no acaban de cuajar.
LightSwitch se integra en el IDE de Visual Studio con muchas mejoras.
SignalR (NodeJS) es una capa de abstracción sobre Web Sockets para comunicación bidireccional entre cliente y servidor.
Ciclo de vida de las aplicaciones modernas: feedback continuo, calidad continua, entrega continua.

10:30 Desarrollo de aplicaciones Modernas. Caso Estudio: Acciona

La empresa Acciona (apoyados por Plain Concepts) ha desarrollado su propia aplicación para el control en tiempo real de las plantas de generación de energía: SCADA. A destacar:

NoSQL
“Tabletas, Windows 8 y la interfaz Windows Store abren las puertas definitivamente a la movilidad”.
Sensores (GPS, Giroscopios…)
Bigdata
Hadoop (gratuito)

Metodología ágil (SCRUM)

12:00 Definición: Requisitos y Planificación continua (Danisoft y Microsoft)

(Ésta me la perdí…)

12:30 Desarrollo: Entrega continua / Habilitando la Calidad de forma continua Rodrigo Corral (Plain Concepts)

Tendencia actual: Agile methods con entregas más frecuentes frente y por lo tanto con menor riesgo frente a Waterfall methods donde se hacen entregas que agrupan muchas más novedades y por lo tanto tienen mayor riesgo.

VS2012:

Backlog
My work en TFS
Testeo unitario “run after build”, Test manager y Testeo exploratorio.
Feedback manager
Detección de código duplicado.
DevOps
Web and load testing.

15:30 Caso de Estudio Transmediterránea Rido (Microsoft)

Migración de Mainframe de IBM (DB2, Ciqs, Cobol) a Azure (MSFT) (Windows Server (AppServer), Azure Platform as a Service, .Net).
Objetivo: ahorro costes de mantenimiento. La migración y mantenimiento de la nueva aplicación se paga en 5 años con la misma cuota mensual que se pagaba de mantenimiento por la original.
Se mantiene la capa transaccional (un 20% aprox. del código original) y se crea un interface que simula el original (consola).

En el punto de venta: “Pues si no ha cambiado nada!”
Equipo técnico: “De eso se trataba (objetivo cumplido)”

En una fase posterior se rediseñará la interfaz de usuario.
A destacar:

Impresoras desde Azure.
Tests, tests, tests…
Metodología KISS (Keep It Stupid & Simple)

16:00 Integre las Operaciones para una entrega continua (Kabel / Certia)

DevOps
SCOMLAB (Operations Manager)

16:30 Novedades en el Desarrollo Web & Cloud David Salgado (Microsoft)

Charla entretenida e interesante, de la que podemos encontrar un amplio resumen en el blog del ponente (http://dasalga.wordpress.com/2012/10/08/charla-de-web-cloud-en-vslaunch/). Habló de:

Novedades en VS2012 para desarrolladores Web:
HTML5, javascript, CSS
Movilidad
Comunicación
Cloud (Azure)

Plataforma virtualmente ilimitada
Autoservicio
Elástico
Pago por uso

Lo que se traduce en:

Economía
Agilidad
Foco

Diferentes opciones a la hora de exponer un desarrollo web al mercado móvil:

No hacer nada ^^ Si, así, con 2 narices. No hacemos nada… el usuario accede a nuestra web tradicional y se verá más o menos, además, como los navegadores móviles cada vez son mejores, pues hala. (En este escenario recomendamos al menos el uso de viewports)
Adaptative/Response UI. trabajar con media queries para que la interfaz se adapte a los tamaños de pantalla. Visita www.mediaqueri.es para hacerte una idea.
Un desarrollo móvil específico… donde utilicemos librerías como JQuery mobile (incluida ahora en VS) para desarrollar el sitio.

Typescript
WebAPI
SignalR
Page inspector

17:30 Desarrollo para Dispositivos: nuevas experiencias de usuario (Icinetic)

Apps full-semantic (habilitar pinzado, etc)
Comportamiento diferenciado en horizontal y vertical.
Tecnologías: Azure, Web Services, MVC, HTML5
Blend para probar distintas configuraciones de pantalla.
Sensores
Demos

Modelo POCO a partir de ADO.NET Entity Data Model

2012-09-26T15:47:00.000+02:00

Si decidimos utilizar Entity Framework para diseñar nuestro modelo de datos, tenemos la opción de utilizar el diseñador gráfico (siguiendo el patrón Database-First o Model-First dependiendo de si partimos de una base de datos existente o no), o crearlo “a pelo” (siguiendo el patrón Code-First). Para más info sobre estos patrones ver el post Database first vs Model first vs Code first.

Ambas formas de trabajar tienen sus gracias y sus inconvenientes:

La primera nos simplificará el trabajo de modelado de entidades y conexión con la base de datos, y además nos aporta una representación gráfica que siempre ayuda.

Para ello simplemente tenemos que añadir a nuestro proyecto un elemento de tipo ADO.NET Entity Data Model:

La segunda forma de trabajar (sin utilizar el diseñador gráfico que proporciona ADO.NET Entity Data Model) nos dará mayor libertad para crear nuestras entidades y basarnos por ejemplo en un modelo de objetos POCO.

Una de las posibilidades más interesantes es partir del modelo gráfico de ADO.NET Entity Data Model y a partir de él generar las entidades POCO y el contexto de BDD. Esto se puede conseguir utilizando un generador de código desde el diseñador:

Como se ve existen multitud de plantillas entre las que elegir, y no es objetivo de este post explicar cada una de ellas. Para generar un modelo de objetos POCO nos pueden servir por ejemplo ADO.NET POCO Entity Generator y ADO.NET DbContext Generator.

ADO.NET Entity Data Model y Data Annotations

2012-09-26T11:31:00.000+02:00

Data Annotations permite añadir validaciones al modelo de datos que luego tendrán reflejo en la vista. A continuación mostraré un ejemplo de aplicación hecha con ASP.NET con una única entidad (Team) definida en el modelo de datos y su controlador y vistas creadas por scaffolding (ver post Cómo crear un CRUD (mantenimiento) básico Web utilizando ASP.Net MVC y Entity Framework).

Supongamos que partimos de una entidad Team definida así:

using System.ComponentModel;
using System;

using System.Collections.Generic;

namespace PruebaEF
{
    public partial class Team
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public string City { get; set; }
    }
}

Si creamos el controlador y las vistas mediante scaffolding y ejecutamos el proyecto tendremos (ojo, tendremos que añadir /teams a la URL inicial).

Si modificamos la entidad añadiendo Data Annotations podemos conseguir algunas validaciones sin necesidad de modificar ni el controlador ni la vista. Veamos el siguiente ejemplo:

using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System;
using System.Collections.Generic;

namespace PruebaEF
{

    public partial class Team
    {
        [DisplayName("Identificador")]
        public int Id { get; set; }

        [DisplayName("Nombre del club")]
        [StringLength(10)]
        public string Name { get; set; }

        [DisplayName("Ciudad")]
        public string City { get; set; }
    }
}

El resultado sería el siguiente (sin necesidad de modificar ni el controlador ni las vistas):

Pero si las entidades las generamos utilizando ADO.NET Entity Data Model tal como se explica en el post anterior (Modelo POCO a partir de ADO.NET Entity Data Model), cada vez que hagamos una modificación desde el diseñador, perderemos las Data Annotations. ¿Y qué podemos hacer al respecto? Tenemos varias opciones aunque ninguna me parece perfecta:

Utilizar el patrón Database-First / Model-First para crear una primera versión del modelo de datos (tal como se explica en el post anterior (Modelo POCO a partir de ADO.NET Entity Data Model) y a partir de ahí eliminar el fichero edmx y pasar a utilizar el patrón Code-First. Siempre podríamos añadir después un elemento de tipo Diagrama de clase para tener una visión gráfica del modelo ;P
Utilizar el generador de código (desde el diseñador) de ADO.NET POCO Entity Generator With Data Annotations. La pega es que sólo sirve para el patrón Database-First y no se pueden añadir o modificar validaciones en el modelo.
Utilizar el patrón Code-First (ver Code-First Development with Entity Framework 4). Si partimos de una BDD existente, podemos utilizar Reverse Engineer Code First (ver Entity Framework Power Tools) para crear las entidades POCO a partir de los objetos de la BDD. Este sistema tampoco me convence porque crea unas clases para el mapeo mediante Fluent-API.
Crear una clase a banda que contenga las anotaciones e indicarlo a la entidad original mediante el atributo MetadataType (ver Validation with the Data Annotation Validators).
Desde el diseñador de ADO.NET Entity Data Model, como generador de código, utilizar ADO.NET Self-Tracking Entity Generator + Data Annotations, que permite añadir validaciones en el diseñador (propiedad Validations de cada una de las entidades). La pega es que esto no genera clases POCO (que es lo que yo estaba buscando).
Utilizar Portable Extensible Metadata (ver Introducing the Portable Extensible Metadata), aunque con esto tampoco conseguiríamos tener clases POCO con anotaciones.

Cómo consumir un Web Service desde PHP

2012-09-13T11:08:00.001+02:00

A continuación un ejemplo sencillo en php que consume un Web Service en este caso de Navision (aunque eso es lo de menos):

<?php

define('USERPWD','192.168.0.150\Administrador:xxx'); // Sustituir xxx por la contraseña del servidor 
include("NTLMStream.php");  
include("NTLMSoapClient.php");
 
stream_wrapper_unregister('http');
stream_wrapper_register('http','NTLMStream') or die("Fallo al registrar protocolo");
$pageURL = 'http://192.168.0.150:7047/dynamicsnav/ws/Autoequip/Codeunit/NEUMALIAWS'; // El Web Service 
$params = array();
$params["param1"] = "2855519MDIAMARISVR"; // param1 es el nombre el primer parámetro.

$params["param2"] = "2";

$params["param3"] = "1024";

$client = new NTLMSoapClient($pageURL);
stream_wrapper_restore('http');
$result = $client->ImportPedNeumalia($params); // El método del Web Service 
$numped = $result->return_value;
echo 'Pedido creado: '.$numped;
die();
?>

Los módulos php incluídos son:

NTLMStream.php

<?php
class NTLMStream 
{ 
    private $path; 
    private $mode; 
    private $options; 
    private $opened_path; 
    private $buffer; 
    private $pos; 
    /** 
     * Open the stream 
      * 
     * @param unknown_type $path 
     * @param unknown_type $mode 
     * @param unknown_type $options 
     * @param unknown_type $opened_path 
     * @return unknown 
     */ 
    public function stream_open($path, $mode, $options, $opened_path) { 
        $this->path = $path; 
        $this->mode = $mode; 
        $this->options = $options; 
        $this->opened_path = $opened_path; 
        $this->createBuffer($path); 
        return true; 
    } 
    /** 
     * Close the stream 
     * 
     */ 
    public function stream_close() { 
        curl_close($this->ch); 
    } 
    /** 
     * Read the stream 
     * 
     * @param int $count number of bytes to read 
     * @return content from pos to count 
     */ 
    public function stream_read($count) { 
        if(strlen($this->buffer) == 0) { 
            return false; 
        } 
        $read = substr($this->buffer,$this->pos, $count); 
        $this->pos += $count; 
        return $read; 
    } 
    /** 
     * write the stream 
     * 
     * @param int $count number of bytes to read 
     * @return content from pos to count 
     */ 
    public function stream_write($data) { 
        if(strlen($this->buffer) == 0) { 
            return false; 
        } 
        return true; 
    } 
    /** 
     * 
     * @return true if eof else false 
     */ 
    public function stream_eof() { 
        return ($this->pos > strlen($this->buffer)); 
    } 
    /** 
     * @return int the position of the current read pointer 
     */ 
    public function stream_tell() { 
        return $this->pos; 
    } 
    /** 
     * Flush stream data 
     */ 
    public function stream_flush() { 
        $this->buffer = null; 
        $this->pos = null; 
    } 
    /** 
     * Stat the file, return only the size of the buffer 
     * 
     * @return array stat information 
     */ 
    public function stream_stat() { 
        $this->createBuffer($this->path); 
        $stat = array( 
            'size' => strlen($this->buffer), 
        ); 
        return $stat; 
    } 
    /** 
     * Stat the url, return only the size of the buffer 
     * 
     * @return array stat information 
     */ 
    public function url_stat($path, $flags) { 
        $this->createBuffer($path); 
        $stat = array( 
            'size' => strlen($this->buffer), 
        ); 
        return $stat; 
    } 
    /** 
     * Create the buffer by requesting the url through cURL 
     * 
     * @param unknown_type $path 
     */ 
    private function createBuffer($path) { 
        if($this->buffer) { 
            return; 
        } 
        $this->ch = curl_init($path); 
        curl_setopt($this->ch, CURLOPT_RETURNTRANSFER, true); 
        curl_setopt($this->ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); 
        curl_setopt($this->ch, CURLOPT_HTTPAUTH, CURLAUTH_NTLM); 
        curl_setopt($this->ch, CURLOPT_USERPWD, USERPWD); 
        $this->buffer = curl_exec($this->ch); 
        $this->pos = 0; 
    } 
}
?>

NTLMSoapClient.php

<?php

class NTLMSoapClient extends SoapClient { 
    function __doRequest($request, $location, $action, $version) { 
        $headers = array( 
            'Method: POST', 
            'Connection: Keep-Alive', 
            'User-Agent: PHP-SOAP-CURL', 
            'Content-Type: text/xml; charset=utf-8', 
            'SOAPAction: "'.$action.'"', 
        ); 
        $this->__last_request_headers = $headers; 
        $ch = curl_init($location); 
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); 
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers); 
        curl_setopt($ch, CURLOPT_POST, true ); 
        curl_setopt($ch, CURLOPT_POSTFIELDS, $request); 
        curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); 
        curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_NTLM); 
        curl_setopt($ch, CURLOPT_USERPWD, USERPWD); 
        $response = curl_exec($ch); 
        return $response; 
    } 
 
    function __getLastRequestHeaders() { 
        return implode("\n", $this->__last_request_headers)."\n"; 
    } 
}
?>

NOTA: Debemos asegurarnos que la extensión php_soap está habilitada; de lo contrario se producirá un error similar a este:

En el caso de tener WAMP como servidor de Apache/PHP/MySQL, esta opción la encontraremos dentro de las PHP_Extensions.

Herencia y Entity Framework (ADO.NET)

2012-08-29T18:07:00.000+02:00

A continuación un ejemplo de herencia con Entity Framework utilizando el patrón Model first. Si no se está familiarizado con alguno de los conceptos que aquí aparecen, recomiendo leer antes el post dedicado a la creación de un mantenimiento con Entity Framework.

1. Creamos el modelo utilizando ADO.NET Entity Data Model

2. Generamos la base de datos a partir del modelo:

3. Creamos los controladores (ActivitiesController, EmailsControllers y TasksControllers) y las vistas asociadas (haciendo Agregar Controller sobre la carpeta Controllers). A modo de ejemplo:

CUIDADO: En el EmailsController hay que sustituir db.Activities por db.Activities.OfType<Email>() para que funcione correctamente.

        // GET: /Emails/

        public ViewResult Index()

            return View(db.Activities.OfType<Email>().ToList());

//

        // GET: /Emails/Details/5

        public ViewResult Details(int id)

            Email email = db.Activities.OfType<Email>().Single(e => e.Id == id);

            return View(email);

Ya podemos ejecutar la aplicación. Para ver la lista de las actividades podemos añadir /Actividades a la URL (por ejemplo, en mi caso, http://localhost:50411/Actividades), y si queremos ver los emails podemos añadir /Emails a la URL.

Obsérvese que si creamos un nuevo email, éste aparecerá como actividad en la lista de actividades, mientras que si creamos una nueva actividad, ésta no aparecerá en la lista de emails.

Cómo crear un CRUD (mantenimiento) básico Web utilizando ASP.Net MVC y Entity Framework

2012-08-29T17:32:00.003+02:00

En este post explicaré paso a paso cómo crear rápidamente un mantenimiento básico Web (sin añadir una línea de código) que puede servirnos de base para crear una aplicación Web completa.

1. En Visual Studio 2010 crear un nuevo proyecto de tipo ASP.NET MVC 4 Web Application. Cuando hagamos Aceptar se nos preguntará por la plantilla a utilizar. En nuestro caso elegiremos Internet Application y Razor.

2. A continuación vamos a crear el modelo de datos que consistirá en una entidad Team (equipo) y otra Player (jugador) relacionadas entre sí como 1 a N. Para ello añadiremos un nuevo elemento a la carpeta Models de nuestro proyecto (haciendo click con el botón derecho sobre dicha carpeta en el Explorador de Soluciones de Visual Studio).

Después de pulsar Agregar se nos preguntará si queremos partir desde una base de datos o desde un modelo vacío. Dependiendo de esta elección trabajaremos siguiendo el patrón Database first o Model first. Para nuestro ejemplo, utilizaremos Model first, ya que carecemos de una base de datos previa (ir a esta entrada del blog para más información sobre estos patrones de diseño).

En el diseñador de Entity Framework, abriremos el menú contextual para agregar las nuevas entidades

Completar las entidades con las propiedades pertinentes

Desde el diseñador abrir el menú contextual para Generar base de datos desde el modelo. Esto genera un script de SQL para generar la base de datos a partir del modelo. Es necesario ejecutarlo (desde el propio diseñador del recién creado fichero .sql).

3. Añadir controlador y vistas: Sobre la carpeta Controllers abrir el menú contextual para crear un nuevo Controller. Si elegimos la segunda o la tercera opción de Template nos creará automáticamente unas vistas asociadas al controlador (si no aparece el Model class y Data context class), compilar el proyecto (Generar). La tercera además implementa paginación y ordenación mediante Ajax.

Y… ¡listo! Ya podemos probar la aplicación ejecutándola con F5. Para ver la página correspondiente al mantenimiento que acabamos de crear podemos añadir a la url /Team (lógicamente en nuestra aplicación final lo que tendremos que hacer es crear un link).

Database first vs Model first vs Code first

2012-08-29T16:38:00.001+02:00

Actualmente con Entity Framework podemos elegir entre 3 enfoques diferentes para crear el modelo conceptual:

· Database First: El modelo conceptual se crea a partir de una base de datos existente.

· Model First: se crea el modelo conceptual y se genera la base de datos.

· Code First: nuevo a partir de EF 4.1. Un enfoque simplificado que permite mapear nuestras clases POCO a la base de datos usando convención, Data Annotations o Fluent API.

Más info en:

Caché de Base de Datos Local en .Net (Occasionally Connected Application)

2012-08-23T15:25:00.001+02:00

Visual Studio 2008 y .Net Framework 3.5 soportan un nuevo paradigma de conexión a base de datos conocido como Occasionally Connected Application (Aplicación Conectada Ocasionalmente), donde las aplicaciones cliente pueden aprovechar el poder de una base de datos Compact SQL Server 3.5 local para almacenar en caché los datos requeridos, en lugar de acceder a la base de datos principal en un equipo remoto cada vez que necesitan. Esto puede mejorar enormemente el rendimiento y la escalabilidad de las aplicaciones del cliente.

Ejemplo:

1. Crear un nuevo proyecto de tipo WPF.

2. Añadir al proyecto un nuevo elemento de tipo Caché de base de datos local.

3. Configurar la conexión al servidor, al cliente (lo que pone por defecto nos servirá) y seleccionar las tablar a sincronizar.

4. Configurar el origen de datos. En nuestro caso usaremos Entity Framework.

* NOTA: En el punto 3 se crear automáticamente la conexión con la base de datos del servidor (ServerXXXConnectionString) y la conexión con la local (ClientXXXConnectionString). Utilizaremos la local.

5. Añadir un DataGrid (con AutogenerateColumns="True") y un botón a la ventana principal. En manajedor del click del botón añadir el código siguiente:

                var ctx = new ClientBDDCtx();
                this.dataGrid1.ItemsSource = ctx.Employees;

Esto rellenará el grid con los datos de la BDD local, sincronizados con la del servidor cuando se creó la caché de base de datos local (puntos 2 y 3).

Podemos desconectar el cable de red para comprobar que efectivamente al clicar el botón sigue rellenándose el grid.

6. Si hacemos modificaciones en la base de datos del servidor estas no se reflejan automáticamente en el cliente. Para sincronizar los cambios tendremos que añadir el código siguiente:

                var s = new LocalDataCache1SyncAgent();
                s.Synchronize();

Para más información:

http://www.youtube.com/watch?v=OEwc2rkmMtQ
http://www.youtube.com/watch?v=sYRK099kkBM
Google-Videos Occasionally Connected Applications.