Update README.md

README.md

-Este proyecto se puede clonar. Lee las instrucciones al final de la página.
+Este proyecto NO se puede clonar. Lee las instrucciones al final de la página.
 
 # Acceso a interfaces REST. Descarga masiva de Tweets
 
@@ -499,23 +499,124 @@ Observa, depurando paso a paso y usando break points (en ocasiones entrar dentro
 
 ### Peticiones con cursores
 
-La función del API descrita en https://dev.twitter.com/rest/reference/get/statuses/user_timeline tiene un límite de 200 tweets por petición.
+La función del API descrita en https://dev.twitter.com/rest/reference/get/statuses/user_timeline tiene un límite de 300 peticiones cada 15 minutos. Pero por lo general tiene un límite total de 3200 tweets por cuenta consultada (los 3200 últimos).
 
-El problema es que los API REST no tienen estado, entonces, ¿cómo bajar los 3200?
+Pese a la limitación dura de 3200, en cada petición se pueden pedir como máximo 200 (parámetro `count` de la llamada al API)
 
-Para ello, es necesario usar cursores, elementos que le informen a Twitter a partir de qué Tweet deseas obtener los siguientes 200.
+El problema es que los API REST no tienen estado, entonces, **¿cómo bajar los 3200?**
+
+Para ello, es necesario usar **cursores**, elementos que le informen a Twitter a partir de qué Tweet deseas obtener los siguientes 200.
+
+Para ello utilizamos el parámetro `max_id` de la petición, usando la información contenida aquí https://dev.twitter.com/rest/public/timelines
 
-Para ello utilizamos el parámetro max_id de la petición, usando la información contenida aquí https://dev.twitter.com/rest/public/timelines
 Usemos una cuenta popular, cualquiera con más de 3200 Tweets. Para ello usa cualquiera de las más populares del mundo (yo voy a usar @realmadrid).
 
 De todos los tweets recibidos, hay que buscar cuál de ellos tiene menor id y usarlo como parámetro (restándole 1) para la siguiente petición.
 
-Averigua como podrías obtener más Tweets haciendo peticiones poco a poco con el método explicado (lo veremos en detalle el proximo día)
 
+```java
+package cdistRest;
+import java.io.IOException;
+import java.net.URLEncoder;
+import java.util.List;
+
+import org.apache.commons.codec.binary.Base64;
+
+import com.google.gson.Gson;
+import com.mashape.unirest.http.HttpResponse;
+import com.mashape.unirest.http.Unirest;
+import com.mashape.unirest.http.exceptions.UnirestException;
+import com.mashape.unirest.request.GetRequest;
+import com.mashape.unirest.request.body.RequestBodyEntity;
+
+public class TwitterCrawler {
+
+	private static final String oauth_consumer_key = "XXXXXXXXx";
+	private static final String oauth_consumer_secret = "XXXXXXXXXXXXXXXXXXXXXXXXXX";
+	
+	public class BearerToken
+	{
+		 private String access_token;
+         private String token_type;
+         
+	}
+
+	
+	public static String deserializeJson(String input_json)
+    {
+          Gson gson = new Gson();
+          BearerToken new_bearerToken = gson.fromJson(input_json, BearerToken.class);
+          return new_bearerToken.access_token;
+    }
+
+	public static void main(String args[]) throws IOException {
+		try {
+			/* get bearer token according to https://dev.twitter.com/oauth/application-only */
+			String URLEncoderConsumerKey = URLEncoder.encode(oauth_consumer_key, "UTF-8");
+			String URLEncoderConsumerSecret = URLEncoder.encode(oauth_consumer_secret, "UTF-8");
+			String AuthorizationHeader = URLEncoderConsumerKey+":"+URLEncoderConsumerSecret;
+			String AuthorizationHeaderB64 = Base64.encodeBase64String(AuthorizationHeader.getBytes("UTF8"));
+			System.out.println(AuthorizationHeaderB64);
+			RequestBodyEntity postReq = Unirest.post("https://api.twitter.com/oauth2/token")
+					.header("User-Agent","TwitterApp")
+					.header("host", "api.twitter.com")
+					.header("Authorization", "Basic " + AuthorizationHeaderB64)
+					.header("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8")
+					.body("grant_type=client_credentials");
 
+			HttpResponse<String> res = postReq.asString();
+			String bearer_token = TwitterCrawler.deserializeJson(res.getBody());
+			
+						
+			/* we now have a brearer token so can make requests to Twitter */
+						
+			/* PRIMEROS 200 tweets */			
+			/* https://api.twitter.com/1.1/statuses/user_timeline.json?screen_name=realmadrid&count=200 */
+			HttpResponse<String>  json_str_Response = null;
+            GetRequest getReq = null;
+            getReq = Unirest.get("https://api.twitter.com/1.1/statuses/user_timeline.json?screen_name={screen_name}&count={count}")
+            		.routeParam("screen_name","realmadrid")
+            		.routeParam("count","200")
+            		.header("Authorization", "Bearer " + bearer_token);
+            System.out.println("Request to: " + getReq.getUrl());
+            System.out.println("Authorization header Bearer " + bearer_token);
+            json_str_Response = getReq.asString();
+            System.out.println("Json : " + json_str_Response.getBody());      
+           
+            List<Tweet> tweet_list = Tweet.deserializeJsonArray(json_str_Response.getBody());
+           
+            /* buscamos ahora entre los tweets descargados para averiguar el lowest ID dado que
+                -la petición por defecto (sin el parámetro max_id) devuelve los últimos 200 (si count=200)
+                -los últimos tweets tienen los ids más altos y los más antiguos los más bajos
+                -hay que encontrar cual es el menor de todos para saber cual es el tweet más antiguo que hemos obtenido
+            */
+            long max_id = Long.MAX_VALUE;
+            for (Tweet tw : tweet_list) {
+                if (tw.id < max_id)
+                    max_id = tw.id;
+            }
+           /* obteniedo los siguientes 200 más antiguos */
+           getReq = Unirest.get("https://api.twitter.com/1.1/statuses/user_timeline.json?screen_name={screen_name}&count={count}&max_id={max_id}")
+            		.routeParam("screen_name","realmadrid")
+            		.routeParam("count","200")
+            		.routeParam("max_id", max_id-1)
+            		.header("Authorization", "Bearer " + bearer_token);
+           json_str_Response = getReq.asString();
+           System.out.println("Json : " + json_str_Response.getBody());
+           tweet_list.add(Tweet.deserializeJsonArray(json_str_Response.getBody()));
+            Unirest.shutdown();
+			
+			
+			
+		} catch (UnirestException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+}
+```
 
-## Importa el proyecto completo en Eclipse desde este repositiorio
 
-El eclipse que usamos dispone de un plugin de Git. Para importar ese proyecto (así como otros que veremos en clase) sigue este manual:
+Averigua como podrías obtener más Tweets haciendo peticiones poco a poco con el método explicado.
+**Modifica el código con un bucle para descargar más tweets**
 
-[Clonar un proyecto de eclipse contenido en un repositorio de Gitlab] (https://gitlab.pervasive.it.uc3m.es/tutorials/clone_project_with_Eclipse_egit)
\ No newline at end of file