lunes, 29 de abril de 2013

CRUD BÁSICO CON WCF DATA SERVICES, AJAX Y JQUERY.


En este artículo vamos a ver cómo implementar un CRUD básico a través de WCF Data Services, pero en esta ocasión lo vamos a hacer totalmente desde el lado del cliente, usando AJAX para invocar nuestros servicios de datos usando los verbos básicos de http GET, POST, PUT y DELETE, y usando el plugin jqxGrid de Jquery  en una versión no comercial, para mostrar los datos en una grilla, para esto vamos a seguir los siguientes pasos:

1.       Crear aplicación Asp.net
2.       Crear modelo de datos con Entity Framework
3.       Crear WCF Data Service
4.       Configurar WCF Data Service para acceso a nuestras entidades.
5.       Referenciar librerías para usar el jqxGrid.
6.       Crear llamados AJAX para interactuar con WCF Data Services.

Para los primeros cuatro pasos remitirse a mi anterior artículo:


5. Referenciar librerías para usar el jqxGrid.

Para usar el plugin jqxGrid, debemos referenciar las siguientes librerías y estilos:
<link rel="stylesheet" href="http://www.jqwidgets.com/jquery-widgets-demo/jqwidgets/styles/jqx.base.css"
        type="text/css" />
    <script src="http://www.jqwidgets.com/jquery-widgets-demo/scripts/jquery-1.8.2.min.js"
        type="text/javascript"></script>
    <script src="http://www.jqwidgets.com/jquery-widgets-demo/jqwidgets/jqx-all.js" type="text/javascript"></script>

6.   Crear llamados AJAX para interactuar con WCF Data Services.

En nuestro ejemplo vamos a crear un CRUD básico para la tabla Customers, visualmente es de la siguiente forma:



Para cargar nuestro grid, vamos a incluir los siguientes scripts en el encabezado del HTML:

$(document).ready(function () {

ConsultarClientes();

       $("#gridClientes").bind('rowselect', function (event) {

             $("#txtID").val(event.args.row.CustomerID);
             $("#txtNombre").val(event.args.row.ContactName);
             $("#txtCompania").val(event.args.row.CompanyName);
             $("#hfAccion").val("Modificar");
       });

       $('#gridClientes').on('rowdoubleclick', function (event) {
if (confirm("Está seguro de eliminar el cliente: " + event.args.owner.rows.records[event.args.rowindex].bounddata.ContactName))
{
EliminarCliente(event.args.owner.rows.records[event.args.rowindex].bounddata.CustomerID);
              }
       });

});

// Cargar grid con los clientes existentes
function ConsultarClientes() {
var source = {
       type: "GET",
       datatype: "json",
       datafields: [
                    { name: 'CustomerID' },
                    { name: 'ContactName' },
                    { name: 'CompanyName' }
                ],
       url: 'NorttwindAccess.svc/Customers',
       cache: false,
       root: 'data'
       };

var dataAdapter = new $.jqx.dataAdapter(source, { contentType: 'application/json; charset=utf-8',
        downloadComplete: function (data, textStatus, jqXHR) {
                                         return data.d;
                           }
            }
        );

       $("#gridClientes").jqxGrid({
                source: dataAdapter,
                columns: [
                    { text: 'ID', dataField: 'CustomerID', width: 200 },
                    { text: 'Nombre', dataField: 'ContactName', width: 200 },
                    { text: 'Compañia', dataField: 'CompanyName', width: 180 }
                ]
            });
 }


Con el código anterior cuando carga la página invocamos la función ConsultarClientes(), la cual permite invocar el servicio de datos con la url 'NorttwindAccess.svc/Customers, y luego lo carga en el grid, además de esto adjuntamos dos eventos al grid, rowselect que usamos para cargar el cliente seleccionado en los campos de texto, y el evento rowdobleclick en el cual vamos a realizar la eliminación del cliente cuando se haga doble click sobre él.
 Ahora para eliminar un cliente, agregamos la siguiente función:
// Eliminar un cliente
        function EliminarCliente(id) {
            $.ajax({
                type: "DELETE",
                url: "NorttwindAccess.svc/Customers('" + id + "')",
                data: "{}",
                contentType: "application/json; charset=utf-8",
                dataType: "json",
                success: function (data) {
                    alert("El cliente se eliminó correctamente.");
                },
                error: function (msg) {
                    alert(msg.responseText);
                }
            });
        }


Y para terminar agregamos la siguiente función para guardar y modificar un cliente:
// guardar o modificar un cliente.
        function GuardarCliente() {

            var cliente = {
                CustomerID: $("#txtID").val(),
                ContactName: $("#txtNombre").val(),
                CompanyName: $("#txtCompania").val()
            };
            var verbo = "POST";
            var mensaje = "Cliente ingresado correctamente.";
            var URL = "NorttwindAccess.svc/Customers";
            if ($("#hfAccion").val("Modificar")) {
                verbo = "PUT";
                mensaje = "Cliente modificado correctamente.";
                URL = "NorttwindAccess.svc/Customers('"+ $("#txtID").val() +"')";
            }
            $.ajax({
                type: verbo,
                url: URL,
                data: JSON.stringify(cliente),
                contentType: "application/json; charset=utf-8",
                dataType: "json",
                success: function (data) {
                    $("#hfAccion").val("Nuevo");
                    LimpiarCajas();
                    alert(mensaje);
                },
                error: function (msg) {
                    alert(msg.responseText);
                }
            });
        }


Con esto damos por terminado nuestro ejemplo de cómo implementar un CRUD básico usando WCF Data Services mediante llamados AJAX, es una forma sencilla de realizar una implementación sin usar código del lado del servidor, espero les sea de gran utilidad, a continuación el link de descarga del código fuente, para mayor detalle, la implementación está en el archivo PruebaClientes.aspx.


Saludos.

domingo, 21 de abril de 2013

CRUD BÁSICO CON WCF DATA SERVICES


En este artículo vamos a ver cómo usar WCF Data Services para interactuar con nuestra base de datos mediante REST, para esto vamos a realizar un formulario de CRUD básico y seguiremos los siguientes pasos:

1.       Crear aplicación Asp.net
2.       Crear modelo de datos con Entity Framework
3.       Crear WCF Data Service
4.       Configurar WCF Data Service para acceso a nuestras entidades.
5.       Interactuar  con nuestro servicio desde una aplicación asp.net

¿Qué es WCF Data Services?
También conocido como ADO.NET data services, es un componente del .net Framework que permite crear servicios web usando ODATA (Open Data Protocol), para exponer y consumir datos en la web mediante REST, ODATA expone los datos como recursos que son accesibles y modificados a través de URIs, usando los verbos HTTP GET(Consultar), PUT(Modificar), POST(Ingresar) y DELETE(Eliminar).

Creando nuestro modelo de datos con la DB ejemplo Northwind.
Antes que nada para crear el modelo debemos tener la base de datos Northwind en nuestra instancia de SQl Server, dichas base de datos se adjunta en este artículo para que se sea descargada y restaurada. Una vez tengamos esta DB, en nuestro proyecto web hacemos click derecho, agregar un nuevo elemento y seleccionamos, ADO:NET Entity Data Model.




Luego configuramos la conexión con la base de datos:



Y seleccionamos las tablas que necesitemos de nuestra base de datos.



Creando nuestro WCF Data Service.
Ahora que tenemos creado nuestro modelos de datos, procedemos a crear nuestro servicio de datos, para esto hacemos clic derecho, agregar nuevo elemento, y elegimos Servicio de datos WCF.



Enseguida nos crea nuestro Data service, y nos indica que debemos especificar el origen de datos y configurar los permisos para las entidades que vamos a exponer en el servicio.

public class WcfDataService1 : DataService< /* TODO: escriba aquí el nombre de clase del origen de datos */ >
{
// Se llama a este método una única vez para inicializar directivas aplicables a todo el ámbito del servicio.
        public static void InitializeService(DataServiceConfiguration config)
        {
// TODO: establezca reglas para indicar qué operaciones de servicio y conjuntos de entidades son visibles, actualizables, etc.
            // Ejemplos:
// config.SetEntitySetAccessRule("MiConjuntoDeEntidades", EntitySetRights.AllRead);
// config.SetServiceOperationAccessRule("MiOperaciónDeServicio", ServiceOperationRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
        }
}



En nuestro caso el origen de datos es NorthwindEntities que hace referencia al modelo que creamos con entity Framework, y vamos a especificar permisos de crear, leer, actualizar y eliminar datos en la tabla Customers de nuestra DB, la configuración del servicio nos queda así:

public class NorttwindAccess : DataService<NorthwindEntities>
{
// Se llama a este método una única vez para inicializar directivas aplicables a todo el ámbito del servicio.
        public static void InitializeService(DataServiceConfiguration config)
        {
// TODO: establezca reglas para indicar qué operaciones de servicio y conjuntos de entidades son visibles, actualizables, etc.
            // Ejemplos:
// config.SetEntitySetAccessRule("MiConjuntoDeEntidades", EntitySetRights.AllRead);
// config.SetServiceOperationAccessRule("MiOperaciónDeServicio", ServiceOperationRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;

            config.SetEntitySetAccessRule("Customers", EntitySetRights.All);
            config.UseVerboseErrors = true;
        }
}

Cabe resaltar la configuración de UseVerboseErrors en True, esto para lograr obtener el detalle completo de la excepción desde el web services, en caso de que ocurra algún error.

Ahora tenemos configurado nuestro servicio de datos, lo podemos probar ingresando a la URL  http://localhost:1995/NorttwindAccess.svc donde NorttwindAccess es el nombre de nuestro servicio.

  

Nos muestra las tablas a la cuales otorgamos permisos, en este caso solo la tabla Customeres.
También podemos hacer cualquier query a través de la URI de nuestro servicio, algunos ejemplos a continuación:

·         Seleccionar todos los registros de la tabla Customers:

·         Seleccionar los registros donde el Campo CustomerID sea igual a “ALFKI”:
·         Seleccionar todos los registros de la tabla Customers ordenados por el campo ContactNAme:

·         Seleccionar todos los registros de la tabla Customers donde el campo ContactName termine en “no”:
http://localhost:1995/NorttwindAccess.svc/Customers?$filter=endswith(ContactName, 'no')

·         Seleccionar los campos CustomerID y ContactName de la tabla Customers:

Estos son algunos ejemplos de los tantos que se pueden hacer.


Ahora procedemos a referenciar nuestro nuevo servicio de datos a nuestra aplicación web asp.net, para poder interactuar con él.



Una vez tenemos nuestro servicio de datos referenciado podemos interactuar con el desde nuestra aplicación.

En nuestro ejemplo vamos a crear un CRUD básico para la tabla Customers, visualmente es de la siguiente forma:




Para poblar el GridView con todos los Clientes, creamos el siguiente método el cual será invocado en el evento Load de nuestra página.


private void LlenarGrid()
{
var serv = new NorthwindService.NorthwindEntities(new Uri("http://localhost:1995/NorttwindAccess.svc"));

       var clientes = (from c in serv.Customers
                       orderby c.ContactName
                       select c).ToList();

       this.gvCustomers.DataSource = clientes;
       this.gvCustomers.DataBind();
}


Observemos que inicializamos nuestro modelo de datos a partir de nuestro servicios de datos, y sobre el podemos ejecutar cualquier consulta linq to entities, en este caso obtenemos  todos los registros de la tabla Customers y cargamos el GridView con los resultados.


Ahora para eliminar un registro de la tabla Customers, en el vento gvCustomers_RowDeleting
De nuestro gridView asignamos el siguiente fragmento de código:


try
{
string strID = this.gvCustomers.Rows[e.RowIndex].Cells[0].Text;
var serv = new NorthwindService.NorthwindEntities(new Uri("http://localhost:1995/NorttwindAccess.svc"));
       NorthwindService.Customers eliminarCliente = (from c in serv.Customers
                                                     where c.CustomerID.Equals(strID)
                                               select c).Single();
       serv.DeleteObject(eliminarCliente);
       serv.SaveChanges();
       this.lblError.Text = "El cliente se elimino correctamente.";
       this.LlenarGrid();
}
catch (Exception ex)
{
this.lblError.Text = string.Format("Ocurrió un error al eliminar el cliete: {0}", ex.Message);
}



Para terminar con nuestro ejemplo, vamos a observar el código alojado en el evento click del botón guardar, en el cual se ejecutan las inserciones y actualizaciones a nuestra DB:

try
{
var serv = new NorthwindService.NorthwindEntities(new Uri("http://localhost:1995/NorttwindAccess.svc"));

       if (this.hfAccion.Value.Equals("Nuevo"))
       {
NorthwindService.Customers customer = new NorthwindService.Customers
             {
                    CustomerID = this.txtID.Text,
                    ContactName = this.txtNombre.Text,
                    CompanyName = this.txtCompania.Text
             };
             serv.AddToCustomers(customer);
       }
       else
       {
                               NorthwindService.Customers modificarCustomer =

(from c in serv.Customers
              where c.CustomerID.Equals(this.txtID.Text)
              select c).Single();
              modificarCustomer.ContactName = this.txtNombre.Text;
              modificarCustomer.CompanyName = this.txtCompania.Text;
              serv.UpdateObject(modificarCustomer);
       }

       serv.SaveChanges();
       this.lblError.Text = "El cliente se actualizó correctamente.";
       this.hfAccion.Value = "Nuevo";
       this.txtID.Enabled = true;
       this.LlenarGrid();
}
catch (Exception ex)
{
this.lblError.Text = string.Format("Ocurrió un error al ingresar el cliete: {0}", ex.Message);
}

Con esto doy por terminado el artículo, espero que sea de gran utilidad para muchos, adicional el link de los fuentes de la solución y el .bak de la base de datos a continuación. En un próximo artículo estaré mostrando como consumir estos Data Services  mediante Jquery a través de una petición AJAX.
Saludos.