martes, 30 de abril de 2013

Herramientas de BI: Qlikview

El pasado 26 de abril asistí al workshop de

Qlikview

organizado por Qliktech Ibérica; lo que me llamó la atención de la invitación es que debías llevar tu portátil y saldrías con tu primer cuadro de mando en

Qlikview

... y efectivamente así fue, tras los aprox. 30-45 minutos de presentación del producto (

Qlikview

11) nos pusimos manos a la obra y en unas 2.5h finalizamos la sesión habiendo realizado un ejemplo con

Qlikview

.

De lo que trata

Qlikview

, igual que todas las

herramientas de BI

, es analizar la información de la empresa (que normalmente acostumbra a ser abundante) con el fin de generar distintos escenarios, realizar simulaciones,... y así dotar a la empresa de información para la toma de decisiones y tener una ventaja competitiva. Acostumbra a utilizarse para análisis de ventas, de clientes, de productos, de líneas de negocio, de mercados, productividad, inventarios... por lo que se ven afectadas distintas áreas de la empresa: ventas, marketing, finanzas, producción...


A continuación os detallo las características que más me llamaron la atención de

Qlikview

, sin duda alguna encontraréis más información del producto en su web así como casos prácticos y descargas pero como introducción puede resultar interesante:

  • Qlikview

    utiliza la tecnología asociativa de memoria (está patentado), no trabajan con cubos (OLAP, ROLAP, MOLAP,...) sino que define su propio esquema de datos y trabaja con todos los datos en memoria; esto hace que dimensionar adecuadamente la RAM del servidor de

    Qlikview

    sea un factor clave en el éxito del proyecto. También importante al seleccionar el servidor saber que

    Qlikview

    ofrece versiones de 32 y 64 bits.

  • En la elección de cualquier herramienta (las

    herramientas de BI

    no son una excepción) siempre es recomendable consultar el cuadrante mágico de Gartner,

    Qlikview

    aparece bien posicionada en el cuadrante superior derecho junto a Cognos (de IBM), Microstrategy, PowerPivot (de Microsoft), Oracle BI...

  • En

    Qlikview

    fácilmente podemos consolidar datos de fuentes heterogéneas mediante ODBC, OLEDB, ficheros,... pero también datos externos de otras fuentes como twitter, facebook,... El siguiente esquema muestra lo que sería la estructura de un proyecto de

    Qlikview

    : diversas fuentes de datos, construcción del ETL, definición del DM e interfaz de usuario (UI).


  • Podemos integrar

    Qlikview

    con Active Directory, Google Maps, herramientas GIS,...

  • Los cuadros de mando que hagáis con

    Qlikview

    serán compatibles con distintos dispositivos móviles ya que utilizan

    HTML5

    .

  • Uno de los temas que más me gustó es la opción que tiene un usuario de

    Qlikview

    para compartir una sesión con un usuario remoto que no dispone de

    Qlikview

    (pero por supuesto sí de conexión a internet); el primero le envía una URL, el segundo accede y en ese momento esa sesión es visible para ambos, ambos pueden modificar los filtros y los cambios son visibles para los dos. Una opción mi útil, por ejemplo, para comentar un análisis de ventas entre 2 personas separadas físicamente y una sin

    Qlikview

    , por ejemplo, un vendedor de una determinada zona y su responsable desde la oficina central: una llamada, se comparte la sesión y realizar el análisis oportuno de forma conjunta.

  • Un tema no muy importante pero curioso que me llamó la atención de

    Qlikview

    11 respecto a versiones anteriores es que a los documentos/proyectos los han rebautizado como "apps", supongo que para estar más en la tendencia actual: Apple Store, Play Store (de Android), Sharepoint Apps...

  • En la zona de descargas de la web de

    Qlikview

    , tras previo registro, podremos descargar la versión Personal Edition que nos permite montar apps de

    Qlikview

    completamente operativas pero de forma local, no podemos publicarlas en ningún servidor ni ejecutarlas (extensión .qvw) en otro equipo que no sea donde se han creado; es una buena opción para empezar a probar o realizar un piloto. En el área de soporte de la web también encontraréis información que os ayudará a dar vuestros primeros pasos en

    Qlikview

    .

Y hasta aquí el artículo de hoy, espero que os sirva esta breve introducción a las

herramientas de BI

de la mano de

Qlikview

. Recordad también que dentro de

areaTIC

podéis encontrar otros artículos, no dudéis en consultar nuestro archivo, también podéis seguirnos por RSS o las principales redes sociales (twitter, facebook, linkedin...) 


martes, 23 de abril de 2013

SQL Server: ¿Qué es la fragmentación de índices?

En el artículo SQL Server: FILL FACTOR os comentaba que si para un determinado

índice

seleccionamos un fill factor demasiado elevado y hay numerosos INSERT / DELETE / UPDATE que afectan al

índice

se producen divisiones de página (para proporcionar espacio al

índice

) lo que genera la

fragmentación

. ¿En qué consiste la

fragmentación

del

índice

? Pues simplemente que los datos del

índice

no se almacenan de forma continua en disco lo que hace que sean necesarias más operaciones de E/S para su lectura.

Nos encontramos con 2 tipos de

fragmentación de índices

:

  • Fragmentación interna

    es el espacio disponible que hay entre los registros dentro de una misma página (recordad que en

    SQL Server

    el tamaño es 8Kb). Se mide en % de bytes de la página llenos, el promedio de llenado de todas las páginas del

    índice

    se conoce como

    densidad del índice

    . Este espacio (que se va generando a medida que se producen operaciones de INSERT/DELETE/UPDATE) que no es utilizado afecta al correcto aprovechamiento de la caché y requiere más operaciones de E/S lo que genera un peor rendimiento en las consultas. Otros efectos que genera este tipo de

    fragmentación

    podrían ser que el escaneo del

    índice

    es más lento, aumenta el tamaño de la base de datos, se ve afectado el rendimiento de backups y restores,...

  • Fragmentación externa

    (también denominada

    fragmentación de extensión

    ) se produce cuando el orden lógico de las páginas no coincide con el orden en el que se almacenan en disco (orden físico). Se mide en % de páginas fuera de orden (aquellas cuya siguiente página lógica no coincide con la página física). Este tipo de

    fragmentación

    penaliza el escaneo ordenado del

    índice

    , requiere de mayores operaciones de E/S,...

El siguiente gráfico nos muestra los 2 tipos posibles de

fragmentación

que podemos encontrar en un

índice

.


¿Y cómo detectamos la

fragmentación de índices

en

SQL Server

? Muy sencillo, mediante la función sys.dm_db_index_physical_stats podemos obtener información tanto de la

fragmentación interna

como de la

fragmentación externa

de nuestros

índices

.

-- Obtenemos ID de la base de datos a analizar, por ejemplo, 123
SELECT DB_ID(N'AdventureWorks')

-- Obtenemos fragmentación para la base de datos con ID 123
SELECT OBJECT_NAME(istats.OBJECT_ID) AS TableName, 
       idxs.name AS IndexName,
       index_type_desc,       
       avg_fragmentation_in_percent,
       avg_page_space_used_in_percent, 
       page_count      
FROM sys.dm_db_index_physical_stats(123,NULL,NULL,NULL,'SAMPLED') istats
INNER JOIN sys.indexes idxs 
ON idxs.OBJECT_ID = istats.OBJECT_ID and idxs.index_id = istats.index_id
ORDER BY  page_count DESC

Sobre las columnas que devuelve la consulta anterior:

  • TableName corresponde al nombre de la tabla que contiene el

    índice

    .

  • IndexName corresponde al nombre de del

    índice

    sobre el que se muestran datos de

    fragmentación

    .

  • avg_fragmentation_in_percent representa el % de

    fragmentación externa

    , cuanto menor sea este valor mejor, en valores por encima de un 10% sería recomendable aplicar medidas correctivas.

  • avg_page_space_used_in_percent representa la

    fragmentación interna

    , en concreto, la

    densidad del índice

    , cuanto mayor sea este valor mejor, en valores por debajo del 75% sería recomendable aplicar medidas correctivas.

  • page_count es el número de páginas que forman el

    índice

    , como norma general, deberíamos centrar nuestros esfuerzos en la corregir

    fragmentación de índices

    de más de 100 páginas.

En este punto deberíamos tener claro qué es la

fragmentación de índices

, cómo afecta a los procesos que se ejecutan en nuestro servidor

SQL Server

, cómo saber la

fragmentación

de nuestros

índices

y conocer los

índices

sobre los que hemos de aplicar medidas correctivas; ahora la cuestión es, ¿qué medidas correctivas aplico? ¿cómo lo hago? A continuación os doy unas recomendaciones (cuidado, recomendaciones, no reglas, en bases de datos la respuesta a todo siempre es "depende"):

  • No apliquemos medidas correctivas a

    índices

    con menos de 100 páginas (columna page_count) y empecemos a analizar

    índices

    de mayor a menor número de páginas.

  • Para

    índices

    donde la columna avg_fragmentation_in_percent tiene un valor inferior al 10% no aplicaremos medidas correctivas.

  • Para

    índices

    donde la columna avg_fragmentation_in_percent tiene un valor entre 10% y 35% aplicaremos ALTER INDEX ... REORGANIZE.

  • Para

    índices

    donde la columna avg_fragmentation_in_percent tiene un valor superior al 30% aplicaremos ALTER INDEX ... REBUILD. ¿Qué diferencia hay entre REBUILD y REORGANIZE? Tienen características diferentes pero lamentablemente no hay ninguna regla (sí recomendaciones) que nos indique cuándo utilizar uno u otro. Las principales características de cada uno son:

    • REBUILD:
      • Requiere crear un nuevo

        índice

        antes de eliminar el anterior lo que supone que sea necesario más espacio disponible en base de datos para el nuevo

        índice

        ; si el

        índice

        es grande esto puede ser un problema importante.
      • Puede utilizar varias CPUs por lo que se ejecuta más rápido.
      • Puede requerir bloqueos.
      • Tiene impacto mínimo sobre el registro de transacciones.
      • Reconstruye las estadísticas del

        índice

        .

    • REORGANIZE:
      • Sólo requiere de 8Kb de espacio adicional en base de datos.
      • El proceso se ejecuta en una única CPU.
      • No requiere bloqueos.
      • Queda reflejado al completo en el registro de transacciones.
      • No actualiza las estadísticas del

        índice

        .

    En resumen, REBUILD siempre reconstruirá el

    índice

    por completo independientemente del grado de

    fragmentación

    ; para un

    índice

    ligeramente

    fragmentado

    no es lo adecuado. REORGANIZE soluciona la

    fragmentación

    existente lo que es adecuado para eliminar la

    fragmentación

    de un

    índice

    ligeramente

    fragmentado

    pero no para

    índices

    muy

    fragmentados

    .

  • En ningún caso es conveniente aplicar DROP INDEX + CREATE INDEX si se trata de un

    índice

    cluster, ¿por qué? Para acceder a los datos de una tabla los

    índices

    no cluster utilizan los

    índices

    cluster. Al hacer un DROP INDEX de un

    índice

    cluster todos los

    índices

    no cluster (relacionados) se tienen que reconstruir y posteriormente, cuando se hace el CREATE INDEX del

    índice

    cluster, todos los

    índices

    no cluster (relacionados) vuelven a reconstruirse... esto no es nada óptimo. Con ALTER INDEX ... REBUILD sucede lo mismo, debemos tener en cuenta las recomendaciones que os hacía anteriormente.

Para eliminar la

fragmentación de índices

lo normal sería crear un plan de mantenimiento con cierta periodicidad (yo acostumbro a que sea semanal) donde se haga una reorganización / reconstrucción de los

índices

; dentro de los procesos del plan las estadísticas deberían actualizarse antes que la reorganización / reconstrucción del

índice

ya que esta reorganización / reconstrucción utiliza las estadísticas y para que sea más efectivo el proceso es recomendable que sea haga con las estadísticas actualizadas.


En este punto es importante tener en cuenta que en este artículo he explicado diversos aspectos relacionados con la

fragmentación de índices

pero no he entrado en detalle de aspectos como los extents, matices distintos entre

índices

cluster / no cluster / heaps, distintas versiones de

SQL Server

(sys.dm_db_index_physical_stats sustituye a DBCC SHOWCONTIG, ALTER INDEX ... REORGANIZE a DBCC INDEXDEFRAG, ALTER INDEX ... REBUILD a DBCC DBREINDEX,...),... debéis tomar el artículo como base y a partir de ahí profundizar en los detalles que os interesen.

Y hasta aquí el artículo de hoy, ahora toca revisar la

fragmentación

de vuestros

índices

y tomar las medidas (preventivas / correctivas) adecuadas. Recordad también que dentro de

areaTIC

podéis encontrar otros artículos interesantes, no dudéis en consultar nuestro archivo, también podéis seguirnos por RSS o las principales redes sociales (twitter, facebook, linkedin...) 


LECTURAS RELACIONADAS RECOMENDADAS POR AREATIC.NET

martes, 16 de abril de 2013

Crear un cliente REST con Visual Studio 2010

Hoy veremos cómo crear un cliente REST desde Visual Studio 2010 que nos servirá para conectar a cualquier servicio REST.

Abrimos Visual Studio 2010, en primer lugar comentar que usaremos Microsoft ASP.NET Web API Client Libraries que está disponible en NuGet. Si no tenéis la extensión NuGet instalada se puede hacer siguiendo los pasos del siguiente link

Una vez ya tenemos NuGet en Visual Studio lo siguiente es ir al menú Herramientas desde Visual Studio y acceder al administrador de paquetes de la solución.

areaTIC, ASP.NET Cliente REST, Administrar Paquetes NuGet

Buscamos WebApi y añadimos el paquete que se muestra en la imagen.

areaTIC, ASP.NET Cliente REST, Descargar Microsoft ASP.NET Web API Client

Vamos ya a crear el cliente. Añadimos una clase que llamaremos RESTClient. La idea es jugar con genéricos para que la misma clase nos sirva para consumir cualquier servicio de una API que siga el patrón REST. Definiremos un constructor en el cual recibiremos los datos variables como URL base, nombre del servicio (...) y a continuación añadiremos un método para cada verbo Http.

Veamos como quedaría el código:
namespace areaTIC.REST
{
  public class RESTClient<T>
  {
    private Uri _BaseURL;
    private string _MediaTypeHeader = "application/json";
    private string _ServiceName = "";
    private HttpClient _Client;
               
    public RESTClient(Uri pBaseURL, string pServiceName) 
    {
      _BaseURL = pBaseURL;
      _ServiceName = pServiceName;

      _Client = new HttpClient();
      _Client.BaseAddress = _BaseURL;
      _Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(_MediaTypeHeader));
    }

    public List<T> Get() 
    {
      try
      {
        List<T> result;
        HttpResponseMessage response = _Client.GetAsync(_ServiceName).Result;
        if (response.IsSuccessStatusCode)
        {
          result = response.Content.ReadAsAsync<List<T>>().Result;
        }
        else
        {
          throw new Exception(string.Format("{0}: No se ha podido conectar al servicio.", response.StatusCode), new Exception(response.ReasonPhrase)); ;
        }
        return result;
      }
      catch (Exception ex)
      {
        throw ex;
      }
    }

    public T Get(int pId) 
    {
      try
      {
        T result;
        HttpResponseMessage response = _Client.GetAsync(string.Format("{0}/{1}",_ServiceName,pId)).Result;

        if (response.IsSuccessStatusCode)
        {
          result = response.Content.ReadAsAsync<T>().Result;
        }
        else
        {
          throw new Exception(string.Format("{0}: No se ha podido conectar al servicio.", response.StatusCode), new Exception(response.ReasonPhrase)); ;
        }

         return result;
       }
       catch (Exception ex) 
       {
         throw ex;
       }
   }

   public void Post(T pValue)
   {
     try
     {
        List<KeyValuePair<string, string>> oListTest = new AreaTICJavaScriptSerializer().GetKeyValuePair(pValue);
        FormUrlEncodedContent content = new FormUrlEncodedContent(oListTest);
        HttpResponseMessage response = _Client.PostAsync(_ServiceName, content).Result;

        if (!response.IsSuccessStatusCode)
        {
          throw new Exception(string.Format("{0}: No se ha podido conectar al servicio.", response.StatusCode), new Exception(response.ReasonPhrase)); ;
        }
     }
     catch (Exception ex)
     {
        throw ex;
     }
  }

  public void Put(int pId, T pValue)
  {
    try
    {
       List<KeyValuePair<string, string>> oListTest = new AreaTICJavaScriptSerializer().GetKeyValuePair(pValue);
       FormUrlEncodedContent content = new FormUrlEncodedContent(oListTest);
       HttpResponseMessage response = _Client.PutAsync(string.Format("{0}/{1}", _ServiceName, pId), content).Result;

       if (!response.IsSuccessStatusCode)
       {
          throw new Exception(string.Format("{0}: No se ha podido conectar al servicio.", response.StatusCode), new Exception(response.ReasonPhrase)); ;
       }
    }
    catch (Exception ex)
    {
       throw ex;
    }
  }

  public void Delete(int pId) 
  {
    HttpResponseMessage response = _Client.DeleteAsync(string.Format("{0}/{1}", _ServiceName, pId)).Result;
    if (!response.IsSuccessStatusCode)
    {
      throw new Exception(string.Format("{0}: No se ha podido conectar al servicio.", response.StatusCode), new Exception(response.ReasonPhrase)); ;
    }
  }

 }
}
Con esto ya tenemos un cliente genérico que nos permitirá conectar a cualquier servicio Web API Rest. Veamos como testearlo, lo más sencillo sería usar el ejemplo de la WebAPI que publicamos la semana pasada en areaTIC o bien crear una nueva (usando la plantilla de Visual Studio 2012 son 5 minutos).

Si usáis el ejemplo de la semana pasada sería conveniente modificar la configuración del proyecto para usar IIS Local (se cambia desde el apartado "web", pulsando botón derecho Propiedades sobre el proyecto). Por ejemplo en este caso yo estoy testeando con el servicio articulo que creamos la semana pasada, pongo un breakpoint en cada método y me aseguro que llegan bien y se serializan adecuadamente las peticiones que hacemos con el cliente:
//Prueba GET - recibe el articulo con ID = 5.
  //Articulo articulo = new areaTIC.RESTClient<Articulo>(new Uri("http://localhost/WebApi/"), "api/articulo").Get(5);

  //Prueba GET - recibe una lista de articulos
  //List<Articulo> articulos = new areaTIC.RESTClient<Articulo>(new Uri("http://localhost/WebApi/"), "api/articulo").Get();

  //Prueba POST que inserta el elemento articulo que enviamos como parámetro
  //new areaTIC.REST.RESTClient<Articulo>(new Uri("http://Localhost/WebApi/"), "api/articulo").Post(new Articulo() { Titulo = "1", Descripcion = "2", Autor = "3"});
  
  //Prueba PUT que actualizará el valor del artículo con ID = 1.
  //new areaTIC.RESTClient<Articulo>(new Uri("http://localhost/WebApi/"), "api/articulo").Put(1,new Articulo() { Expediente = "1", DireccionNotaria = "2", FechaFirma = "3", Notario = "4" });

  //Prueba DELETE que elimina el articulo cuyo ID pasemos como parámetro.
  //new areaTIC.RESTClient<Articulo>(new Uri("http://localhost/WebApi/"), "api/articulo").Delete(1);
La clase articulo que hemos enviado como parámetro es una clase que he generado en cliente y tiene los mismos atributos que el modelo "Articulo" que creamos en la WebAPI de servidor. A parte si os fijáis en la clase RESTClient métodos POST y PUT usamos un AreaTICJavascriptSerializer para devolver una lista de KeyPairValue a partir de uno o varios objetos. Os paso también el código:
namespace AreaTIC.REST
{
  public class AreaTICJavaScriptSerializer : JavaScriptSerializer
  {
    public List<KeyValuePair<string, string>> GetKeyValuePair(string jSonText) 
    {
      List<KeyValuePair<string, string>> lstResultado = new List<KeyValuePair<string, string>>();

      //separar la cadena jSon para tener los objetos
      MatchCollection mcElementosLista = Regex.Matches(jSonText, @"(?<=\{)(.*?)(?=\})", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline);

      foreach (Match mElemento in mcElementosLista)
      {
         //separar por clave : valor
         MatchCollection mcRelacionClavesValores = Regex.Matches(mElemento.Value, @"(?<=(^|\,)).*?(?=(\,|$))", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline);
         foreach (Match mClaveValor in mcRelacionClavesValores)
         {
            //separar cadena por ':' y asignar valores
            string[] strSeparador = { "\":\"", "\":null" };
            string[] strClaveValor = mClaveValor.Value.Split(strSeparador, StringSplitOptions.None);
            if (strClaveValor.Length == 2)
            {
               string strClave = strClaveValor[0];
               string strValor = strClaveValor[1];

               if (strClave.StartsWith("\""))
                 strClave = strClave.Substring(strClave.IndexOf("\"") + "\"".Length);

               if (strClave.EndsWith("\""))
                 strClave = strClave.Substring(0, strValor.IndexOf("\""));

               if (strValor.StartsWith("\""))
                 strValor = strValor.Substring(strValor.IndexOf("\"") + "\"".Length);

               if (strValor.EndsWith("\""))
                 strValor = strValor.Substring(0, strValor.IndexOf("\""));

               if (strValor.Length == 0)
                 strValor = "null";

               KeyValuePair<string, string> kvpAux = new KeyValuePair<string, string>(strClave, strValor);
               lstResultado.Add(kvpAux);
            }
         }
      }

      return lstResultado;
   }

   public List<KeyValuePair<string, string>> GetKeyValuePair(object objectValue) 
   {
      try
      {
         List<KeyValuePair<string, string>> lstResultado = new List<KeyValuePair<string, string>>();
         System.Reflection.PropertyInfo[] propiedadesObjeto = objectValue.GetType().GetProperties();
         foreach (System.Reflection.PropertyInfo propiedad in propiedadesObjeto)
         {
            //obtener el nombre y valor de la propiedad a añadir en el Diccionario
            string strValor = "";
            object o = propiedad.GetValue(objectValue, null);
            if (o != null)
              strValor = o.ToString();
            if (strValor.Length == 0)
              strValor = "null";

            KeyValuePair<string, string> kvpAux = new KeyValuePair<string, string>(propiedad.Name, strValor);
            lstResultado.Add(kvpAux);
         }

         return lstResultado;
       }
       catch (Exception ex)
       {
         throw ex;
       }
    }
  }
}
Por último comentar que desde cliente apuntamos a localhost como servidor asumiendo que tenemos publicado en el IIS Local un site con la WebAPI correspondiente. Espero os sea útil el cliente genérico, cualquier duda o corrección ya sabéis. Que vaya bien la semana y recordar como siempre que podéis seguir areaTIC en las redes sociales!

martes, 9 de abril de 2013

MVC 4.0: Cómo crear una Web API REST usando la plantilla de Visual Studio 2012

Hace unas semanas asistí a unas sesiones técnicas donde explicaban temas interesantes sobre Service Bus en Windows Azure y allí vi como creaban servicios usando la plantilla MVC Web API de Visual Studio 2012. Me sorprendió gratamente la rapidez y facilidad para levantar un servicio REST. Hasta ahora si quería implementar una comunicación REST me hubiese creado un servicio WCF con un WebHttpBinding y jugando con atributos como WebGet, etc. hubiese modificado el comportamiento del servicio WCF para que tenga una respuesta RESTFull aunque sin duda es más complejo levantar y configurar el servicio REST con WCF que si usamos MVC WebAPI.

A continuación crearé paso a paso AreaTICWebAPI donde levantaremos un servicio 'Articulo' que más adelante usaré en futuras publicaciones para hacer alguna que otra comparativa con WCF y subir algún ejemplo sobre creación de clientes para la API.

Vamos con el ejemplo:

En primer lugar abrimos Visual Studio 2012, abrimos 'Nuevo Proyecto' tipo Web y seleccionamos la opción Aplicación Web de ASP.NET MVC 4.0.

areaTIC, ASP.NET MVC 4.0, Menú Proyecto Visual Studio

En el siguiente paso seleccionamos la plantilla WebAPI.

Veremos que automáticamente se crearán una serie de archivos en el proyecto típicos de una plantilla MVC donde tenemos una carpeta para las vistas, controlador y modelos. A parte si nos fijamos incluye un Area adicional que servirá para aportar información sobre la API a los clientes que se dispongan a usarla.

Si llegado este punto pulsamos F5 la web se ejecutará en IIS Express y nos llevará a una página "Home" donde tenemos un link API en la parte superior que nos muestra información sobre el servicio por defecto que tenemos en la WebAPI.

Ahora veremos como personalizar la vista 'Home' y sustituiremos el servicio que viene por defecto con la plantilla 'Values' por nuestro servicio 'Articulo'.

Para personalizar la vista no me he roto mucho los cuernos si no que simplemente he editado las vistas que están en la carpeta Views/Home y Views/Shared, lo mismo con Areas/HelpPage/Views/Help y Areas/HelpPage/Views/Shared dejando el diseño por defecto que propone la plantilla.

areaTIC, ASP.NET MVC 4.0, AreaTic WebApi


Veamos ahora como crear nuestro propio servicio Articulo.
  • Creamos una clase Articulo dentro de la carpeta "Models"
    namespace WebAPI.Models
    {
        public class Articulo
        {
            public int Codigo { get; set; }
            public string Titulo { get; set; }
            public DateTime Fecha { get; set; }
            public string Autor { get; set; }
            public string Descripcion { get; set; }
        }
    }
    
  • Añadimos un controlador (Botón derecho en la carpeta "Controllers" -> Agregar Controlador)

    areaTIC, ASP.NET MVC 4.0, Seleccionar controlador


    namespace WebAPI.Controllers
    {
        public class ArticuloController : ApiController
        {
            // GET api/articulo
            public IEnumerable<Articulo> Get()
            {
                //TODO: Acceder a datos y devolver una lista de artículos.
                // Para testear la API devuelvo un par de artículos de test.
    
                return new List<Articulo>() 
                { 
                    new Articulo(){ Codigo = 1, Autor = "Carlos Cañizares", Descripcion = "bla bla", Fecha = DateTime.Now, Titulo = "MVC Web Api - Server"},
                    new Articulo(){ Codigo = 2, Autor = "Carlos Cañizares", Descripcion = "bla bla", Fecha = DateTime.Now, Titulo = "MVC Web Api - Client"}
     
                };
            }
    
            // GET api/articulo/5
            public Articulo Get(int id)
            {
                //TODO: Acceder a datos en busca del artículo con Id que recibimos por filtro.
                return new Articulo();
            }
    
            // POST api/articulo
            public void Post([FromBody]Articulo value)
            {
                //TODO: implementar el acceso a datos para insertar el objeto que recibimos por parámetro.
            }
    
            // PUT api/articulo/5
            public void Put(int id, [FromBody]Articulo value)
            {
                //TODO: implementar el acceso a datos para realizar un update del Articulo que recibimos por parámetro.
            }
    
            // DELETE api/articulo/5
            public void Delete(int id)
            {
                //TODO: implementar el acceso a datos para eliminar el artículo correspondiente al identificador que hemos recibido por parámetro.
            }
        }
    }
    
Con esto ya tendríamos el servicio, si pulsamos F5 y vamos al link "API" que se muestra en la parte superior derecha de la página home accederemos a la referencia de la API donde ya debería aparecer nuestro servicio Articulo.

areaTIC, ASP.NET MVC 4.0, Web Api


areaTIC, ASP.NET MVC 4.0, Web Api Referencia servicio artículo


Como veis ya aparece el servicio automáticamente en la página de ayuda simplemente con añadir el controlador en la carpeta correspondiente, la misma plantilla se encarga de generar la documentación de ayuda correspondiente para los métodos que se han definido en el servicio.

Hasta aquí el artículo de hoy, la semana que viene publicaré un artículo donde crearemos un cliente que sea capaz de interactuar con cualquier servicio de la API que siga este patrón. Cualquier corrección o duda es bienvenida como siempre podéis enviarla por email o comentarios. Recordar que podéis seguir también areaTIC en las redes sociales!! Que vaya bien la semana!


martes, 2 de abril de 2013

ownCloud con Active Directory: montando nuestro propio Dropbox

Llevaba tiempo persiguiendo a mi amigo Eduardo para que hiciera una colaboración en areaTIC.net... al final ha sacado tiempo de su apretada agenda para hacernos llegar este vídeo que nos muestra cómo montar nuestro propio " Dropbox" mediante la herramienta open source ownCloud y vinculado con Active Directory.

Antes de nada haceros una breve presentación de Eduardo Campos Jiménez, actualmente es administrador de sistemas en el Institut d'Estudis Catalans, experto en administración de sistemas (UNIX/Linux/Windows) con amplia experiencia en el sector servicios TI y especialista en distintas tecnologías: virtualización de sistemas con VMware vSphere o Hyper-V de Microsoft, Sistemas UNIX-Linux, Cloud Computing (Amazon Web Services, ownCloud), sistemas Windows Server 2k3/8/12, Active Directory Domain Services, montaje de clústeres, redes y conectividad, Google Apps, bases de datos Oracle 10/11g, SQL Server 2005/2008, MySQL, servidores web IIS, Apache, Tomcat, sistemas de gestión de contenidos (Drupal, Joomla, Word Press), backup (Veeam, Symantec Netbackup Server y Backup Exec), servidores de correo (sistemas Exchange 2k3/7/10 y Linux), sistemas antivirus y de seguridad,... Y por si no tuviera bastante también es autor del blog Mundo TIC que sin duda os recomiendo visitar.


¿En qué consiste ownCloud? ownCloud ofrece un acceso a archivos a través de una interfaz web; también proporciona una plataforma para ver fácilmente y sincronizar contactos, calendarios y favoritos entre distintos dispositivos. Tiene mínimos requisitos de instalación, no necesita permisos especiales y es rápido. ownCloud dispone de una API simple pero potente además de otras funcionalidades como versionado de ficheros, visor de documentos, diferentes temas... Sin más rodeos os dejo con este vídeo sobre la herramienta open source ownCloud y cómo vincularlo con Active Directory, disfrutadlo!!



Si queréis más información sobre ownCloud podéis visitar su sitio web; hasta aquí el artículo de hoy, espero poder robarle más tiempo a Eduardo y que nos haga aportaciones tan interesantes como esta de ownCloud. Recordad también que dentro de areaTIC podéis encontrar otros artículos, no dudéis en consultar nuestro archivo, también podéis seguirnos por RSS o las principales redes sociales (twitter, facebook, linkedin...)