GWT – JSON dates

marzo 11, 2013

JSON no tiene un tipo de dato Date, así que cuando transfieres fechas mediante JSON debes convenir un formato de fecha -por ejemplo, yyyy-MM-dd’T’hh:mm:ss.SZ- Un ejemplo de fecha en este formato sería “2013-03-08T16:23:35.000+0000”.

Para facilitar un poco las cosas, decidí utilizar un Overlay Type para la representación de mi objeto y acceder a sus propiedades mediante getter’s y setter’s. Estos métodos realizan la conversión de cadena a fecha, y viceversa, con la ayuda de la clase DateTimeFormat.

    public class Audiencia extends JavaScriptObject {</p><pre><code>    private final static DateTimeFormat dateTimeFormat = DateTimeFormat.getFormat("yyyy-MM-dd'T'hh:mm:ss.SZ");

    public final native int getId()/*-{
        return this.id;
    }-*/;

    public final Date getInicio(){
        return dateTimeFormat.parseStrict(getInicioNative());
    };

    private final native String getInicioNative()/*-{
        return this.inicio;
    }-*/;

    public final Date getFin(){
        return dateTimeFormat.parseStrict(getFinNative());
    };

    private final native String getFinNative()/*-{
        return this.fin;
    }-*/;

    protected Audiencia() {
    }

    public static void getAudiencias(String idSala,
            final AsyncCallback&lt;Audiencia[]&gt; callback) {
        try {
            String queryParams = "?sala="+URL.encodeQueryString(idSala);
            RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,
                    Consts.REST_AUDIENCIAS + queryParams);
            rb.sendRequest(null, new RequestCallback() {

                @Override
                public void onResponseReceived(Request request,
                        Response response) {
                    if(response.getStatusCode() == 200){
                        JavaScriptObject jso = JSON.decode(response.getText());
                        DSResponse ds = new DSResponse(JSOHelper.getAttributeAsJavaScriptObject(jso, "response"));
                        if(ds.getStatus() == 0){
                            Record[] records = ds.getData();
                            Audiencia[] audiencias = new Audiencia[records.length];
                            for(int i=0;i&lt;records.length;i++){
                                audiencias[i] = (Audiencia) records[i].getJsObj();
                            }
                            callback.onSuccess(audiencias);
                        }else{
                            callback.onFailure(new Exception(ds.getAttributeAsString("data")));
                        }
                    }else{
                        callback.onFailure(new Exception(response.getStatusText()));
                    }
                }

                @Override
                public void onError(Request request, Throwable exception) {
                    callback.onFailure(exception);
                }
            });
        } catch (Exception e) {
            callback.onFailure(e);
        }
    }

}
</code></pre><p>

Esto es necesario porque el método JSON.decode) crea el objeto Javascript con propiedades (inicio y fin) de tipo String.

Para saber cuáles son las ventajas y desventajas entre un formato y otro, puedes ver la siguiente discusión

http://stackoverflow.com/questions/1256835/why-chose-xml-over-properties-files-for-log4j-configuration

Desde mi punto de vista, deberíamos usar el formato XML.

Aquí dejo un ejemplo de un archivo de configuración properties y su equivalente en xml que encontré en esta página.

log4j.properties

# Set root logger level to DEBUG and its only appender to A1.
log4j.rootLogger=DEBUG, A1

# A1 is set to be a ConsoleAppender.
log4j.appender.A1=org.apache.log4j.ConsoleAppender

# A1 uses PatternLayout.
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

log4j.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

<!-- A1 is set to be a ConsoleAppender -->
 <appender name="A1" class="org.apache.log4j.ConsoleAppender">
 <!-- A1 uses PatternLayout -->
 <layout class="org.apache.log4j.PatternLayout">
 <param name="ConversionPattern" value="%-4r [%t] %-5p %c %x - %m%n"/>
 </layout>
 </appender>

<root>
 <!-- Set root logger level to DEBUG and its only appender to A1 -->
 <priority value ="debug" />
 <appender-ref ref="A1" />
 </root>

</log4j:configuration>

Recientemente he estado trabajando en un proyecto donde es necesario insertar vídeo en un a página web. Para realizar esta tarea podemos utilizar la etiqueta de HTML5 ‘<video>‘. Bueno, pues para que nuestro vídeo se pueda ver en los navegadores principales -firefox, chrome, ie, opera, safari- es necesario tener al menos 3 fuentes (source) de vídeo en los formatos mp4 (h264), webm (vp8) y ogg (theora).

En Linux podemos utilizar el comando avconv -antes ffmpeg- de la siguiente manera:

avconv -i original.mov nuevo.mp4 nuevo.webm nuevo.ogv

tal vez sea necesario que instales el paquete libavcodec-extra. Con esto, al final tendremos 3 archivos nuevos con los formatos requeridos, ya sólo habría que agregar las fuentes a la etiqueta ‘<video>’

<video style="width: 640px; height: 360px;">
 <source src="videos/nuevo.mp4" type="video/mp4"></source>
 <source src="videos/nuevo.webm" type="video/webm"></source>
 <source src="videos/nuevo.ogv" type="video/ogg"></source>
 <!-- Opcionalmente insertar vídeo en flash para soportar navegadores antiguos -->
 Lo sentimos, tu navegador no soporta la etiqueta de video.
 </video>

Fuentes:
https://developer.mozilla.org/En/Media_formats_supported_by_the_audio_and_video_elements
http://paulrouget.com/e/converttohtml5video/

Para formatear un número a dos dígitos, de tal forma que “1” lo imprima como “01”, puedes utilizar el método String.Format() de la siguiente manera:

int mes=1;
String.format(“%02d”,mes); //regresa la cadena ’01’

Fuentes:
http://www.coderanch.com/t/422920/java/java/Display-integer-always-two-digit 

Estoy muy feliz porque nos entregaron las fotografías de nuestra boda. Sin embargo, algunas imágenes estaban en formato RAW. El visor por default en Fedora 15, Shotwell 0.10.1, no puede abrir este tipo de imágenes. Intenté con Eye fo GNOME 3.0.1 y GIMP pero tampoco tuve éxito.

Para poder abrir las imágenes en GIMP puedes instalar el plugin ufraw

Pero lo que nosotros necesitabamos era convertir unas 1,434 fotografías de RAW a JPEG :-S
Lo bueno es que existe un programa llamado DCRAW que puedes ejecutar desde la línea de comandos para convertir una imagen. Por default convierte las imágenes al formato PPM, pero también existen otras utilidades –Netpbm– para convertir de PPM a JPEG
Bueno, pues lo primero es instalar DCRAW

luego instala Netpbm

ahora si, en una terminal ve al directorio donde tienes las imágenes y ejecuta el siguiente comando

for i in *.CR2; do dcraw -c -a -h $i | ppmtojpeg > `basename $i CR2`JPEG; echo $i done; done

asegurate de poner correctamente la extensión de los archivos -CR2 en el caso de las cámaras Canon– y recuerda que Linux es sensible a minúsculas y mayúsculas 😉

Fuentes:
http://ocaoimh.ie/2005/09/18/converting-raw-to-jpeg-in-linux/
http://www.cybercom.net/~dcoffin/dcraw/dcraw.1.html


Tengo un encabezado estándar que uso en la mayoría de reportes, el cual he compartido a través de una librería. El detalle es que el título para cada reporte es diferente, así que en la plantilla coloqué etiquetas cuyo valor depende del parámetro que se les pase. Es común también que el título contenga el período que comprende el reporte. El formato de fecha que comunmente utilizamos es “dd/MM/yyyy” p. ej. 14/06/2011. Para dar este formato a las fechas -que recibo como párametros- utilizo el siguiente código en el evento “initialize” del reporte:

importPackage(Packages.java.text);
sdf = new SimpleDateFormat(“dd/MM/yyyy”);
params[“Titulo”]=”Reporte del “+sdf.format(params[“FechaInicio”])+” al “+sdf.format(params[“FechaFin”]);

Fuentes:
Eclipse Forums

Tengo un reporte en el que necesitaba mostrar una cantidad de dinero de la siguiente forma “$1,234,767.54”.
Lo que hice fue crear una variable para almacenar el valor y luego incrustarla en el reporte. Ya colocada en su lugar fui a la sección “Format Number” en la ventana de propiedades y seleccioné “Currency” en el campo “Format as”, active la casilla de “Use 1000s separator” y seleccione “$” en el campo “Symbol”.

Con esto supusé que ya iba a aparecer con el formato que esperaba, desafortunadamente no fue así y no encontraba una explicación.
Después de buscar por varios lados encontré cuál era el problema, resulta que la variable la estaba tomando como de tipo “String” y por ende no tomaba en cuenta la configuración de “Format Number”. Fue entonces cuando supe que debía indicarle de alguna forma que mi variable era númerica. Para hacer esto, sólo tienes que ir a la sección “Binding” en la ventana de propiedades y modificar el “Data Type” en “Data Column Binding” a un tipo de dato númerico, en mi caso, “Float”.