package packageName_00.PackageName_01;

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.json.JSONObject;
import android.util.Log;

public class RestClient {

    public interface RequestCallback {
    	public void onError(Throwable exception);
    	public void onResponseReceived(HttpResponse response);
    }

    public static void doGet(final String url, final RequestCallback callback) {
    	Log.i("doGet", " - url: " + url);
    	final HttpClient httpClient = new DefaultHttpClient();
    	HttpConnectionParams.setConnectionTimeout(httpClient.getParams(), 10000);
    	Thread thread = new Thread(){
    		public void run() {
    	        HttpGet httpget = new HttpGet(url);
    	        HttpResponse response;
    	        try {
    	            response = httpClient.execute(httpget);
    	            callback.onResponseReceived(response);
    	        } catch (Exception ex) {
    	        	callback.onError(ex);
    	        }
    		}
    	};
    	thread.start();
    }

    public static void doPost (final String url,final JSONObject json, final RequestCallback callback) {
    	Log.i("doPost a url: " + url, "- JSON: " + json.toString());
    	final HttpClient httpClient = new DefaultHttpClient();
    	HttpConnectionParams.setConnectionTimeout(httpClient.getParams(), 10000);
    	Thread thread = new Thread(){
    		public void run() {
    			HttpPost httpPost = new HttpPost(url);
    	    	httpPost.addHeader("Accept", "application/json");
    	    	httpPost.addHeader("Content-Type", "application/json");
    	    	try {
    	    	    StringEntity entity = new StringEntity(json.toString(), "UTF-8");
    	    	    entity.setContentType("application/json");
    	    	    httpPost.setEntity(entity);
    	    	    // execute is a blocking call, it's best to call this code in a thread separate from the ui's
    	    	    HttpResponse response = httpClient.execute(httpPost);
    	    	    callback.onResponseReceived(response);
    	    	}
    	    	catch (Exception ex) {
    	    		callback.onError(ex);
    	    	}
    		}
    	};
    	thread.start();
    }

    public static void doPut (final String url,final JSONObject json,final RequestCallback callback) {
    	Log.i("doPut a url: " + url, "- JSON: " + json.toString());
    	final HttpClient httpClient = new DefaultHttpClient();
    	HttpConnectionParams.setConnectionTimeout(httpClient.getParams(), 10000);
    	Thread thread = new Thread(){
    		public void run() {
    			HttpPut httpPut = new HttpPut(url);
    			httpPut.addHeader("Accept", "application/json");
    			httpPut.addHeader("Content-Type", "application/json");
    	    	try {
    	    	    StringEntity entity = new StringEntity(json.toString(), "UTF-8");
    	    	    entity.setContentType("application/json");
    	    	    httpPut.setEntity(entity);
    	    	    HttpResponse response = httpClient.execute(httpPut);
    	    	    callback.onResponseReceived(response);
    	    	}
    	    	catch (Exception ex) {
    	    		callback.onError(ex);
    	    	}
    		}
    	};
    	thread.start();
    }

    public static void doDelete (final String url, final RequestCallback callback) {
    	Log.i("doDelete" , " - url: " + url);
    	final HttpClient httpClient = new DefaultHttpClient();
    	HttpConnectionParams.setConnectionTimeout(httpClient.getParams(), 10000);
    	Thread thread = new Thread(){
    		public void run() {
    			HttpDelete httpDelete = new HttpDelete(url);
    			httpDelete.addHeader("Accept", "application/json");
    	    	try {
    	    	    HttpResponse response = httpClient.execute(httpDelete);
    	    	    callback.onResponseReceived(response);
    	    	}
    	    	catch (Exception ex) {
    	    		callback.onError(ex);
    	    	}
    		}
    	};
    	thread.start();
    }
}

Para hacer consultas desde el emulador a un servidor en la propia máquina, esto es, una consulta ‘localhost’, debes usar la IP 10.0.2.2

Si se utiliza Firefox existe un Addon, JSONView, que hace más amigable el trato con información en formato JSON.

Para ver el ejemplo en local habría que ejecutar desde el directorio raíz del archivo descomprimido:
grails run-app
Y acceder a través de:
http://localhost:8080/GrailsRestExample/gwt/index

Si se desea generar el archivo war para proceder a su instalación en un contenedor J2EE, habría que ejecutar desde el directorio raíz del archivo descomprimido el comando:
grails war
Y proceder a su instalación como cualquier aplicación web Java. Las aplicaciones Grails son aplicaciones web Java.

No lo he complicado mucho para que el que quiera arrancar con Grails y REST se lie lo menos posible.
La aplicación consta de tres recursos, Usuario, Voto y Asunto. Se puede probar usando el programa rest-client o el Addon de Firefox ‘Poster’.

Recurso ‘Usuario’

• Si se quieren consultar los usuarios se debe hacer una petición

GET http://localhost:8080/GrailsRestExample/users?max=20&offset=2

Donde max es el número máximo de resultados devueltos (por defecto 20) y offset es el índice a partir del que se desea obtener el primer resultado (por defecto 0)

• Para obtener la información de un usuario concreto:

GET http://localhost:8080/GrailsRestExample/users/${idUsuario}

• Para borrar un usuario se debe hacer una petición:

DELETE http://localhost:8080/GrailsRestExample/users/${idUsuario}

• Para actualizar un usuario existente habría que hacer una petición:

PUT http://localhost:8080/GrailsRestExample/users/${idUsuario}
Enviando una representación JSON del usuario que se desee crear con las siguientes características:
{"username":"username", "email":"email@gruposp2p.org", "dateOfBird":"01-02-2003","enabled":"true"}

• Para crear un nuevo usuario habría que hacer una petición

POST http://localhost:8080/GrailsRestExample/users
Enviando una representación JSON del usuario que se desee crear con las siguientes características:
{"username":"username", "email":"email@gruposp2p.org", "dateOfBird":"01-02-2003","enabled":"true"}

Recurso ‘Asunto’

• Si se quieren consultar los Asuntos dados de alta en el sistema se debe hacer una petición

GET http://localhost:8080/GrailsRestExample/subjects?max=20&offset=2
Donde max es el número máximo de resultados devueltos(por defecto 20) y offset es el índice a partir del que se desea obtener el primer resultado (por defecto 0)

• Para obtener la información de un asunto concreto:

GET http://localhost:8080/GrailsRestExample/subjects/${idSubject}

• Para actualizar un asunto existente habría que hacer una petición:

PUT http://localhost:8080/GrailsRestExample/subjects/${idSubject}
Enviando una representación JSON del asunto que se desee crear que tenga siguientes características:
{"content":"Contenido del asunto 40","name":"Nombre del asunto40"}

• Para borrar un asunto:

DELETE http://localhost:8080/GrailsRestExample/subjects/${idSubject}

Recursos ‘Asuntos’ asociados a un determinado recurso ‘Usuario’

• Para obtener todos los asuntos generados por un usuario concreto

GET http://localhost:8080/GrailsRestExample/users/${idUsuario}/subjects/

• Para generar un nuevo asunto asociado al usuario ${idUsuario} habría que hacer una petición

POST http://localhost:8080/GrailsRestExample/users/${idUsuario}/subjects/
Enviando una representación JSON del asunto que se desee crear con las siguientes características:
{"content":"Contenido del asunto 40","name":"Nombre del asunto40"}

Recurso ‘Voto’

• Si se quieren consultar todos los Votos dados de alta en el sistema se debería hacer una petición

GET http://localhost:8080/GrailsRestExample/votes?max=20&offset=2
Donde max es el número máximo de resultados devueltos (por defecto 20) y offset es el índice a partir del que se desea obtener el primer resultado (por defecto 0)

• Si se quiere consultar un voto concreto

GET http://localhost:8080/GrailsRestExample/votes/${idVote}

• Si se quiere modificar un voto habrá que hacer una petición

PUT  http://localhost:8080/GrailsRestExample/votes/${idVote}
Enviando una representación JSON del asunto que se desee crear que tenga siguientes características:
{"value":"valor del voto www"}

• Para eliminar un voto:

DELETE http://localhost:8080/GrailsRestExample/votes/${idVote}

Votos asociados a un determinado usuario

• Para obtener todos los votos generados por el usuario ${idUsuario}

GET http://localhost:8080/GrailsRestExample/users/${idUsuario}/votes/

• Para generar un nuevo voto sobre el asunto ${idSubject} asociado al usuario ${idUsuario} habría que hacer una petición

POST http://localhost:8080/GrailsRestExample/users/${idUsuario}/subjects/${idSubject}
Con una representación JSON del voto que tuviera las siguientes características:
{"value":"valor del voto www"}

Votos asociados a un determinado asunto
GET http://localhost:8080/GrailsRestExample/subjects/{idSubject}/votes

Votos asociados a un determinado asunto y a un determinado usuario
GET http://localhost:8080/GrailsRestExample/users/${idUsuario}/subjects/{idSubject}/votes

En el siguiente artículo explicaré cómo usar las nueva clase TableCell que viene con GWT 2.1 utilizando los datos disponibles en estos servicios REST, la aplicación de acceso para Android la dejaré para el final de esta serie.

Es importante quedarse con los siguientes puntos:

• Existen formas de securizar los recursos.

• El desarrollo está hecho en Grails, pero utilizando principios REST pueden crearse servicios, independientes de lenguaje de programación y plataforma, accesibles a través de Internet.

• Gracias a esta técnica se separa completamente la interfaz de usuario del servicio.

• Si se desea que dos partes intercambien información a través de Internet la mejor forma de conseguirlo es empezando definiendo las interfaces REST de los recursos que se desean compartir.

El Tweet lo he soltado en caliente indignado y decía ‘Sobre temas de robo de identidad, vale que no lo sepa una persona normal, pero que un profesional no sepa lo que es OCSP señala el nivel’, algo que fuera de contexto se puede malinterpretar.

La cosa más explicada debería quedar mas o menos así, si se hacen trámites con firma electrónica las aplicaciones que hagan uso de esas firmas pueden comprobar en tiempo real si los certificados asociados son válidos. En caso de pérdida o robo la información se actualiza una vez se ha denunciado la pérdida. Alguien dedicado a la gestión de identidades electrónicas debe saber eso.

————————————————————————————————————————

Seguramente existirá otra forma mejor de conseguirlo pero lo que explico a continuación me ha funcionado.

Todavía no existe software para la versión 10.04 de Ubuntu, Ubuntu Lucid, así es que empecé descargando la versión opensc-dnie_1.4.7 que sólo existe para la Karmic Koala. La cosa no funcionó, tuve que probar con la versión 1.4.6 que existe para la Jaunty Jackalope y con eso si que he conseguido usar el DNI desde Firefox, pero seguiendo estos pasos:

Instalar, por este orden, los paquetes que traen la distribución 1.4.6 descargarbles desde el portal oficial del DNI electrónico: libopensc2_0.11.7-7_i386.deb, opensc_0.11.7-7_i386.deb y opensc-dnie_1.4.6-2_i386.deb.
Si se empieza instalando opensc-dnie, se instalarán las librerías que hay en el repositorio en vez de las que vienen con la distribución y eso me ha dado fallos.

La primera vez que lo he usado en Firefox he tenido que cargar manualmente el módulo criptográfico, para ello hay que ir a Editar > Preferencias > Dispositivos de seguridad > Cargar y seleccionar el archivo /usr/lib/opensc-pkcs11.so

Debido a este bug, el demonio pcscd no arranca automáticamente en Lucid, así es que, por lo pronto, cada vez que se quiera utilizar el DNI electrónico habrá que abrir una consola y ejecutar:
sudo /etc/init.d/pcscd start

pagar 1.00 euro -> comisión micropago=0.10, comisión normal=0.33
pagar 5.00 euros -> comisión micropago=0.30, comisión normal=0.45
pagar 10.00 euros -> comisión micropago=0.55, comisión normal=0.59
pagar 12.00 euros -> comisión micropago=0.65, comisión normal=0.65 (punto de encuentro)
pagar 14.00 euros -> comisión micropago=0.75, comisión normal=0.71
pagar 16.00 euros -> comisión micropago=0.85, comisión normal=0.76

La información se refiere a una entidad extrangera, ahora mismo no se de ninguna entidad española que trabaje con micropagos.

Para esta aplicación es necesario tener un servidor configurado para que solicite certificados al acceder a un recurso seguro, en esta página se explican los detalles

grails create-app AutentificacionDNIe
cd AutentificacionDNIe
grails install-plugin spring-security-core
grails s2-quickstart org.gruposp2p.openid.provider UserDNI RoleDNI

Se crea el controlador cuyo acceso se quiera securizar con DNI electrónico:

grails create-controller secure

Para solicitar el acceso del DNIe se configura la aplicación para que el acceso al controlador se haga exclusivamente a través del protocolo HTTPS. Para ello se edita ‘Config.groovy’ y se añade:

grails.plugins.springsecurity.useX509=true
grails.plugins.springsecurity.x509.subjectDnRegex = 'SERIALNUMBER=(.*?),'
grails.plugins.springsecurity.portMapper.httpsPort=8443
grails.plugins.springsecurity.secureChannel.definition = ['/secure/**':'REQUIRES_SECURE_CHANNEL',
	                                                          '/**': 'ANY_CHANNEL']

Para comprobar que todo funciona se edita BootStrap.groovy y se añade un usuario de pruebas

	def init = { servletContext ->
	   def adminRole = new RoleDNI(authority: 'ROLE_ADMIN').save(flush: true)
	   String password = springSecurityService.encodePassword('password')
	   def testUser = new UserDNI(username: 'NumeroNIFDelDNIConQueSePrueba', enabled: true, password: password)
	   testUser.save(flush: true)
	   UserDNIRoleDNI.create testUser, adminRole, true
	}

Crear secure/index.gsp con

<sec:ifLoggedIn>
	Buenas <sec:loggedInUserInfo field="username"/>
</sec:ifLoggedIn>
<sec:ifNotLoggedIn>
	Acceso no autorizado
</sec:ifNotLoggedIn>

Para probar la aplicación ejecutar

grails run-app

… y acceder a la aplicación