Creación de Servicio Web REST CRUD

Siguiendo nuestro ejemplo de “MiTienda”, crearemos ahora un servicio REST para productos. Para lo cual, en nuestra base de datos agregaremos la tabla “Productos”, con la siguiente estructura:

Ahora, en nuestra solución .NET agregaremos un nuevo proyecto.

Cambiaremos de nombre al servicio “Service1” por “Productos”. De igual manera cambiaremos “IService1” por “IProductos”. Tambien agregaremos al proyecto las carpetas “Dominio” y “Persistencia”.

Luego crearemos la clase “Producto.cs” dentro de la carpeta “Dominio” con el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Runtime.Serialization;

namespace ProductosService.Dominio
{
    [DataContract]
    public class Producto
    {
        [DataMember]
        public string Co_Producto { get; set; }
        [DataMember]
        public string No_Producto { get; set; }
        [DataMember]
        public decimal Ss_Precio { get; set; }
        [DataMember]
        public int Qt_Stock { get; set; }
    }
}

Luego crearemos la clase “Conexion.cs” dentro de la carpeta “Persistencia”, con el siguiente código:

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

namespace ProductosService.Persistencia
{
    public class Conexion
    {
        public static string Cadena
        {
            get
            {
                return "Data Source=(local);Initial Catalog=BD_Tienda;Integrated Security=SSPI;";
            }
        }
    }
}

Luego dentro de la misma carpeta adicionaremos la clase “ProductoDAO”, con el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using ProductosService.Dominio;
using System.Data.SqlClient;

namespace ProductosService.Persistencia
{
    public class ProductoDAO
    {
        public Producto Crear(Producto productoACrear)
        {
            Producto productoCreado = null;
            productoACrear.Co_Producto = ObtenerMaximoId().ToString();
            string sql = "INSERT INTO t_producto VALUES (@Co_Producto, @No_Producto, @Ss_Precio, @Qt_Stock)";
            using (SqlConnection con = new SqlConnection(Conexion.Cadena))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    com.Parameters.Add(new SqlParameter("@Co_Producto", productoACrear.Co_Producto));
                    com.Parameters.Add(new SqlParameter("@No_Producto", productoACrear.No_Producto));
                    com.Parameters.Add(new SqlParameter("@Ss_Precio", productoACrear.Ss_Precio));
                    com.Parameters.Add(new SqlParameter("@Qt_Stock", productoACrear.Qt_Stock));
                    com.ExecuteNonQuery();
                }
            }
            productoCreado = Obtener(productoACrear.Co_Producto);
            return productoCreado;
        }

        public int ObtenerMaximoId()
        {
            int id = 0;
            string sql = "SELECT max(Co_Producto) FROM t_producto";
            using (SqlConnection con = new SqlConnection(Conexion.Cadena))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    try
                    {
                        id = (int)com.ExecuteScalar();
                    }
                    catch (Exception e) { }
                }
            }
            return id + 1;
        }

        public Producto Obtener(string Co_Producto)
        {
            Producto productoEncontrado = null;
            string sql = "SELECT * FROM t_producto WHERE Co_Producto = @Co_Producto";
            using (SqlConnection con = new SqlConnection(Conexion.Cadena))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    com.Parameters.Add(new SqlParameter("@Co_Producto", Co_Producto));
                    using (SqlDataReader resultado = com.ExecuteReader())
                    {
                        if (resultado.Read())
                        {
                            productoEncontrado = new Producto()
                            {
                                Co_Producto = resultado["Co_Producto"].ToString(),
                                No_Producto = (string)resultado["No_Producto"],
                                Ss_Precio = (decimal)resultado["Ss_Precio"],
                                Qt_Stock = (int)resultado["Qt_Stock"]
                            };
                        }
                    }
                }
            }
            return productoEncontrado;
        }

        public Producto Modificar(Producto productoAModificar)
        {
            Producto productoModificado = null;
            string sql = "UPDATE t_producto SET No_Producto = @No_Producto, Ss_Precio = @Ss_Precio, Qt_Stock = @Qt_Stock WHERE Co_Producto = @Co_Producto";
            using (SqlConnection con = new SqlConnection(Conexion.Cadena))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    com.Parameters.Add(new SqlParameter("@No_Producto", productoAModificar.No_Producto));
                    com.Parameters.Add(new SqlParameter("@Ss_Precio", productoAModificar.Ss_Precio));
                    com.Parameters.Add(new SqlParameter("@Qt_Stock", productoAModificar.Qt_Stock));                    
                    com.Parameters.Add(new SqlParameter("@Co_Producto", productoAModificar.Co_Producto));
                    com.ExecuteNonQuery();
                }
            }
            productoModificado = Obtener(productoAModificar.Co_Producto);
            return productoModificado;
        }

        public void Eliminar(string Co_Producto)
        {
            string sql = "DELETE FROM t_producto WHERE Co_Producto = @Co_Producto";
            using (SqlConnection con = new SqlConnection(Conexion.Cadena))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    com.Parameters.Add(new SqlParameter("@Co_Producto", Co_Producto));
                    com.ExecuteNonQuery();
                }
            }
        }

        public List<Producto> ListarProductos()
        {
            List<Producto> productos = new List<Producto>();
            string sql = "SELECT * FROM t_producto";
            using (SqlConnection con = new SqlConnection(Conexion.Cadena))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    using (SqlDataReader resultado = com.ExecuteReader())
                    {
                        while (resultado.Read())
                        {
                            productos.Add(new Producto()
                            {
                                Co_Producto = resultado["Co_Producto"].ToString(),
                                No_Producto = (string)resultado["No_Producto"],
                                Ss_Precio = (decimal)resultado["Ss_Precio"],
                                Qt_Stock = (int)resultado["Qt_Stock"]
                            });
                        }
                    }
                }
            }
            return productos;
        }
    }
}

Ahora editaremos el archivo “Productos.svc” con el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
using ProductosService.Persistencia;
using ProductosService.Dominio;

namespace ProductosService
{
    public class Productos : IProductos
    {
        private ProductoDAO dao = new ProductoDAO();

        public Producto CrearProducto(Producto productoACrear)
        {
            return dao.Crear(productoACrear);
        }

        public Producto ObtenerProducto(string Co_Producto)
        {
            return dao.Obtener(Co_Producto);
        }

        public Producto ModificarProducto(Producto productoAModificar)
        {
            return dao.Modificar(productoAModificar);
        }

        public void EliminarProducto(string Co_Producto)
        {
            dao.Eliminar(Co_Producto);
        }

        public List<Producto> ListarProductos()
        {
            return dao.ListarProductos();
        }
    }
}

Luego editaremos el archivo “IProductos.cs” con el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
using ProductosService.Dominio;

namespace ProductosService
{
    [ServiceContract]
    public interface IProductos
    {
        [OperationContract]
        [WebInvoke(Method = "POST", UriTemplate = "Productos", ResponseFormat = WebMessageFormat.Json)]
        Producto CrearProducto(Producto productoACrear);

        [OperationContract]
        [WebInvoke(Method = "GET", UriTemplate = "Productos/{Co_Producto}", ResponseFormat = WebMessageFormat.Json)]
        Producto ObtenerProducto(string Co_Producto);

        [OperationContract]
        [WebInvoke(Method = "PUT", UriTemplate = "Productos", ResponseFormat = WebMessageFormat.Json)]
        Producto ModificarProducto(Producto productoAModificar);

        [OperationContract]
        [WebInvoke(Method = "DELETE", UriTemplate = "Productos/{Co_Producto}", ResponseFormat = WebMessageFormat.Json)]
        void EliminarProducto(string Co_Producto);

        [OperationContract]
        [WebInvoke(Method = "GET", UriTemplate = "Productos", ResponseFormat = WebMessageFormat.Json)]
        List<Producto> ListarProductos();
    }
}

Ahora, dar clic derecho sobre el archivo “Productos.svc” y escoger la opción “Ver Marcado”, y adicionar la última línea que se muestra en la siguiente imagen:

Insertar algunos registros en nuestra tabla productos para poder probar el listado de productos.

Ahora sobre el mismo archivo “Productos.svc” dar clic derecho y escoger la opción “Ver en el Explorador”.

En la pantalla que nos aparecerá, agregar al final de la url lo siguiente: /Productos/1

Luego probar con: /Productos

Podemos verificar la respuesta generada en formato JSON.

Espero que este tema les haya sido de utilidad, en el próximo tema veremos como realizar pruebas unitarias para un servicio REST, siguiendo este mismo ejemplo.

Gracias !!!