Archivos de la Categoria ‘Desarrollos’

Cliente REST Android

Junio 17th, 2010

Si quieres jugar haciendo operaciones REST con JSON en Android, y no tienes nada hecho, esto te puede servir de ayuda.

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

Principal diferencia entre pago normal y micropago

Mayo 7th, 2010

La principal diferencia entre los pagos normales y los micropagos se encuentra en las comisiones que se cobran al realizar los mismos. Para entenderlo basta mirar estos datos:

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.

Configuración de Grails para usar el DNI electrónico como mecanismo de autentificación

Mayo 1st, 2010

Entorno -> Grails 1.2.2

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

Intercambio de atributos OpenID (AX)

Abril 22nd, 2010

El Intercambio de Atributos OpenID puede ser utilizado para intercambiar cualquier tipo de información entre la Parte Consultante y el Proveedor del Servicio, siempre y cuando ambas partes se hayan puesto de acuerdo en definirlo como atributo. Este es el motivo principal por el que he parado el desarrollo del sistema de micropagos con OAuth que llevaba en marcha y lo estoy adaptando a OpenID, mediante esta extensión del protocolo se puede intercambiar la información de la transacción entre las partes.

Como me encanta matar varios pájaros de un tiro estoy aprovechando el tiempo invertido para desarrollar un proveedor OpenID que utilice el DNI electrónico como mecanismo de autentificación, mecanismo que pienso utilizar en el sistema de recogida de firmas y votaciones no anónimas dniesign. Quise presentarlo al desafio abredatos, pero mi manejo de Grails todavía no es fluido … todavía =)

He aprovechado el cambio para adoptar como framework de desarrollo GrailsGrails es con diferencia el mejor framework para desarrollo web que he visto hasta la fecha. No se de ningún framework que maneje con más claridad la persistencia de objetos que GORM.

ControlDatosGob

Enero 27th, 2010

Bueno del primer arreón que le he dado al desarrollo de la aplicación de control de datos ha salido http://bit.ly/deBh8V, ahora dejaré reposar un poco el tema y con lo aprendido retomaré el desarrollo de la aplicación de voto con DNI electrónico. El código se puede descargar desde aquí http://code.google.com/p/controldatosgob/ y cumple con la creo que es la mejor fórmula para desarrollar aplicaciones web -> GWT + Rest -Jersey + JPA Hibernate + Hibernate Search.

GWT como framework para desarrollar interfaces de usuario me garantiza que con muy pocos retoques el mismo código sirva para los principales navegadores.

No se los dispositivos que saldrán en los proximos años lo que si se es que tendrán conexión a Internet, eso quiere decir que tendrán acceso a todos los servicios REST que sea capaz de ofrecer. La mejor forma de asegurarse de que los servicios de tu servidor serán accesibles en el futuro desde el mayor número posible de programas o dispositivos es desarrollarlos siguiendo los principios REST, las arquitecturas REST están pensadas para sacarle el máximo partido a Internet.

No se la base de datos que usaré, lo que si que se es que la mejor manera de interactuar con una base de datos es usando un framework de persistencia de objetos, JPA es un estándar apoyado por los principales actores en el negocio de las base de datos. No está controlado por una única organización, es a día de hoy la opción más avanzada para realizar persistencia de objetos y con muy poco esfuerzo el mismo desarrollo se puede usar en la mayoría de las base de datos.

El DNI electrónico es la clave para poder garantizar que estás tratando con quien dice ser y para poder crear sistemas de mensajería seguros y de intercambio de archivos firmados … anda y que no hay cosas que hacer con esto.

De Hibernate Search hablé en el último post.

No se como será el futuro, lo que si se es que cada vez hay más gente que utiliza la red para informarse y hacer sus gestiones, la cantidad de gente y el número de horas que pasan conectados crece día a día. Conforme van apareciendo nuevos servicios las combinaciones para crear soluciones sobre ellos se multiplican y para hacer cosas lo único que se necesita es un ordenador con una conexión a Internet.

Hibernate Search

Enero 20th, 2010

Si tienes un montón de documentos digitalizados y quieres realizar búsquedas de texto sobre ellos, Hibernate search puede ayudarte a resolver muchos de los problemas con los que te vas a encontrar.

Hibernate Search resuelve las carencias de SQL para realizar búsquedas complejas de texto utilizando para ello como motor de búsqueda Apache Lucene. Permite:

  • Mantener actualizados y sincronizados el índice que se crea para la búsqueda de textos y los datos de la base de datos.
  • Obtener objetos persistentes a partir de las búsquedas de texto
  • Crear índices respetando relaciones entre objetos del modelo.

Dispone de un analizador que permite:

  • Hacer búsquedas por aproximaciones fonéticas, por sinónimos o palabras no acentuadas…
  • Puntuar los resultados de una búsqueda.

La mayor parte del esfuerzo consiste en la optimización de las consultas de búsqueda. Es la herramienta que tienes que utilizar si quieres añadir búsquedas profesionales del estilo Amazon o Google a los datos que manejan tus bases de datos.

Control de gastos de reuniones

Enero 9th, 2010

Mi amigo Oscar me comentó que estaría bien disponer de una aplicación que sirviera para poder hacerse una idea clara de los gastos de una reunión. De esa conversación ha nacido Control de gastos de reuniones, el código se puede descargar desde aquí.

Es un prototipo pero creo que la idea está clara, la evolución ahora dependerá de los estímulos que se reciban.

De esa forma cuando nos juntemos y no sepamos de qué hablar, cosa que nunca ha pasado, siempre podremos sacar la aplicacioncita y mejorarla en algo.

Firmas con el DNI electrónico

Diciembre 19th, 2009

He creado una applicación que utiliza el DNI electrónico para firmar documentos XML.
El objetivo del proyecto es crear un sistema de recogida de firmas y mostrar una manera de distribuir proyectos libres.

Por lo pronto sólo he subido la parte del cliente y todavía le falta, pero tiene cosas que pueden interesar a una persona que se dedique a esto.
Pasos a seguir para obtener un ejecutable de la aplicación a partir de los fuentes:

svn checkout http://dniesign.googlecode.com/svn/trunk/DNIeGP2P/DNIeGP2PClient
cd DNIeGP2PClient
mvn assembly:assembly

cd target
java -jar DNIeGP2PClient-1.0-SNAPSHOT-jar-with-dependencies.jar

En las sucesivas semanas iré explicando el sistema.