El pasado 21 de marzo en la Universidad de Salamanca, estuvimos hablando de diferentes APIs REST.

Durante algo más de una hora vimos cómo a través de APIs Rest podemos consumir y crear contenidos desde nuestras aplicaciones. En este primer artículo de la serie, veremos cómo consumir servicios existentes, primero por consola, y luego a través de un cliente Windows 8.

Introducción, leyendo nuestros primeros datos

Al principio pudimos comprobar cómo acceder de manera sencilla a APIs como la de Youtube, usando Powershell. El primer comando nos permite tener un volcado directo de lo que nos devuelve el servicio, y el segundo nos permite tener una lista más detallada de qué estamos recibiendo:

Invoke-WebRequest -Uri "http://gdata.youtube.com/feeds/api/videos?v=2&q=harlem+shake" | Select-String Content
Invoke-RestMethod -Uri "http://gdata.youtube.com/feeds/api/videos?v=2&q=harlem+shake"

Una vez sabemos qué pinta tiene podemos crear un método para, usando HttpClient (using System.Net.Http…) y Json.NET (Install-Package NewtonSoft.Json), convertir esta información en objetos útiles. Nótese el formato jsonc, que en este caso significa json comprimido:

public async Task<List<Item>> DownloadShakes()
{
    HttpClient client = new HttpClient();
    var response = await client.GetAsync("http://gdata.youtube.com/feeds/api/videos?v=2&q=harlem+shake&alt=jsonc");
    var result = await response.Content.ReadAsStringAsync();
    return JsonConvert.DeserializeObject<RootObject>(result).data.items;
}

Para poder obtener la clase RootObject hemos de acudir a json2csharp.com, una herramienta que nos permite obtener la estructura de clases de una respuesta en formato JSON. Una vez tenemos esta información es muy sencillo trabajar con una lista.

Accediendo a una API más compleja, Trello

Trello es una magnífica aplicación de gestión de tareas que tiene tres niveles:

• Boards (tableros)
• Lists (listas)
• Cards (tarjetas)

Cada uno de estos niveles tiene sus peculiaridades, pero gracias a Json.NET podemos deserializar un objeto JSON en una única clase que tenga los mínimos elementos comunes de los tres:

public class TrelloItem
{
    public string id { get; set; }
    public string name { get; set; }

    public override string ToString()
    {
        return name;
    }
}

A continuación escribimos el código para gestionar el acceso a Trello, para el cual necesitamos, por una parte una api key (identifica la aplicación), por otro lado un token (identifica al usuario).

El token lo podemos obtener a través de una llamada a la web de trello, donde se nos pedirá (como usuarios) nuestro usuario y contraseña y se nos devolverá un objeto JSON con el mismo.

El método que realiza las descargas es similar al que hemos visto antes, solamente que en este caso usamos un genérico, el método GetBoards solamente especifica la URL:

public class TrelloService
{
    private string apiKey = "API_KEY";
    private string token = "TOKEN";

    public string GenerateFullUrl(string url)
    { 
        return "https://api.trello.com/1/" + url + "?key=" + apiKey + "&token=" + token;
    }


    public async Task<T> Download<T>(string url)
    {
        HttpClient client = new HttpClient();
        var response = await client.GetAsync(url);
        var result = await response.Content.ReadAsStringAsync();
        return JsonConvert.DeserializeObject<T>(result);
    }


    public async Task<List<TrelloItem>> GetBoards()
    {
        //get all boards from the user
        var url = "members/me/boards";
        return await Download<List<TrelloItem>>(GenerateFullUrl(url));
    }
}

Posteriormente para poder obtener las listas de un tablero o las tarjetas de una lista, empleamos un código muy similar. donde la diferencia está en los datos de entrada y la construcción de la URL

public async Task<List<TrelloItem>> GetLists(TrelloItem board)
{
    //Todo: Get for retrieving lists from board
    var url = "boards/" + board.id + "/lists";
    return await Download<List<TrelloItem>>(GenerateFullUrl(url));
}

public async Task<List<TrelloItem>> GetCards(TrelloItem list)
{
    //Todo: Get for retrieving cards from list
    var url = "list/" + list.id + "/cards";
    return await Download<List<TrelloItem>>(GenerateFullUrl(url));
}

Finalmente, para agregar datos, por una parte construimos los datos que vamos a enviar:

public async Task<TrelloItem> AddCard(string title, TrelloItem list)
{
    var card = new {idList= list.id, name= title};
    var url = "cards";
    return await Upload<TrelloItem>(GenerateFullUrl(url), JsonConvert.SerializeObject(card));
    //Todo: Post for creating a card
}

Y escribimos un método «Upload» para el mismo, como peculiaridad nótese que usamos el verbo Post, así como especificamos en las cabeceras que nuestra petición tiene formato JSON:

public async Task<T> Upload<T>(string url, string parameters)
{
    HttpClient client = new HttpClient();
    HttpContent content = new StringContent(parameters);
    content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
    var response = await client.PostAsync(url, content);
    var result = await response.Content.ReadAsStringAsync();
    return JsonConvert.DeserializeObject<T>(result);
}

Proximamente…

En el próximo artículo veremos cómo crear nuestra propia API de manera muy sencilla con Web API, y cómo consumirla, además, tendremos los ejemplos completos del código empleado.

Slides