Algoritmo para aplicar Base64

Si hay algo que aveces se requiere realizar es codificar un archivo binario a texto ASCII y viceversa, si este es tu caso puedes utilizar Base64, el cual es muy sencillo y rápido de implementar aunque no es del todo seguro.

Los usuarios de PHP pueden hacer uso de las funciones nativas base64_encode y base64_decode,los de Python pueden importar el paquete base64 para servirse de este, de todas formas puedes usar la siguiente herramienta en linea llamada Binary File to Base64 Encoder / Translator, ver referencia [1].

Ahora que si deseas realizar algún tipo de encriptado para tu proyecto con un mínimo de esfuerzo, puedes optar por la biblioteca jasypt, ver referencia [4].


Introduccion

¿Que es BASE64 y donde se utiliza?

El Base64 Content-Transfer-Encoding está diseñado para representar secuencias arbitrarias de octetos en una forma que no necesita ser humanamente legible. Los algoritmos de codificación y decodificación son simples, pero los datos codificados son sistemáticamente sólo alrededor del 33% más grande que los datos sin codificar.

Esta compuesta por un subconjunto 65 de caracteres US-ASCII, permitiendo 6 bits para ser representados por caracteres imprimibles. (El 65° carácter adicional, "=", se utiliza para significar una función específica para la transformación.)

Aquí 3 Bytes se representan con una cadena de texto de 4 caracteres,en total estos 24 bits se subdividen en agrupaciones de 6 bits, cada uno de los cuales se traduce en un solo dígito en el alfabeto base64. En otras palabras estos 6 bits se usan como índice en una matriz de 64 caracteres imprimibles.


Esquema de codificación de bytes del algoritmo Base64

+-primer octeto--+-segundo octeto--+--tercer octeto--+
|0 1 1 1 0 1 1 0 | 0 1 0 1 0 1 1 1 | 0 0 0 0 0 1 1 0 |
+-----------+----+-------+---------+----+------------+
|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0 |
+ carácter 4+ carácter 3 + carácter 2 + carácter 1 +


Tabla 1: El alfabeto Base64

Value Encoding Value Encoding Value Encoding Value Encoding
0 A 17 R 34 i 51 z
1 B 18 S 35 j 52 0
2 C 19 T 36 k 53 1
3 D 20 U 37 l 54 2
4 E 21 V 38 m 55 3
5 F 22 W 39 n 56 4
6 G 23 X 40 o 57 5
7 H 24 Y 41 p 58 6
8 I 25 Z 42 q 59 7
9 J 26 a 43 r 60 8
10 K 27 b 44 s 61 9
11 L 28 c 45 t 62 +
12 M 29 d 46 u 63 /
13 N 30 e 47 v
14 O 31 f 48 w (pad) =
15 P 32 g 49 x
16 Q 33 h 50 y


Todos los saltos de línea, espacios en blanco u otros caracteres que no se encuentra en la Tabla 1 deben de ser ignorado por el software de decodificación.

Esta codificación es prácticamente idéntica a la utilizada en la privacidad de Correo Mayor (PEM), también en la URL's de algunos sitios, PGP, Thunderbird y Evolution lo ocupan para el cifrado de contraseñas en los correos entre otros. Ver referencia [2].

Codificación Base64 en las URL's

Esta codificación puede ser nombrada como "base64url" y no debe considerarse igual que "base64". Esta es técnicamente idéntica a la anterior, a excepción de del carácter 62 y 63 del alfabeto, una alternativa al alfabeto sugerido es utilizar "~" como carácter en la posición 63. Debido a que el carácter "~" tiene un significado especial en algunos entornos de sistema de archivos, aunque no se recomienda.

Se ocupa para apuntar a algún nombre de archivo o dirección de manera segura en la web, es por ello que hay URL's que son lo suficientemente cortas como para cortar y pegar.Por eso la codificación de seis bits por carácter (base 64) que es mucho mejor que la codificación de cinco bits por carácter (base 32).

Por ejemplo:

http://localhost:4004/id/1b17864eeb6c68294c9b2db0324a2b773401f0da0537d82626c24a7850e15ef2d6c4265dcd5e85f1

La misma URL en base64:

http://localhost:4004/id/GxeGTutsaClMmy2wMkordzQB8NoFN9gmJsJKeFDhXvLWxCZdzV6F8Q

Se puede deducir entonces que Base64 es 17% mas compacto que Base32

Desarrollo

He implementado una clase para realizar el codificado, la cual se llama Base64Encoder.java la cual esta disponible desde este enlace [3]. En cuanto tenga listo el decodificador lo publicare aquí.

Enlaces

[1]http://www.greywyvern.com/code/php/binary2base64
[2]http://www.ietf.org/rfc.html (The Internet Engineering Task Force)

- REQUEST FOR COMMENTS -

2045 Multipurpose Internet Mail Extensions (MIME) Part One: Format of
Internet Message Bodies. N. Freed, N. Borenstein. November 1996.
(Format: TXT=72932 bytes) (Obsoletes RFC1521, RFC1522, RFC1590)
(Updated by RFC2184, RFC2231, RFC5335) (Status: DRAFT STANDARD)

2046 Multipurpose Internet Mail Extensions (MIME) Part Two: Media
Types. N. Freed, N. Borenstein. November 1996. (Format: TXT=105854
bytes) (Obsoletes RFC1521, RFC1522, RFC1590) (Updated by RFC2646,
RFC3798, RFC5147) (Status: DRAFT STANDARD)

3548 The Base16, Base32, and Base64 Data Encodings. S. Josefsson, Ed..
July 2003. (Format: TXT=26363 bytes) (Obsoleted by RFC4648) (Status:
INFORMATIONAL)

4648 The Base16, Base32, and Base64 Data Encodings. S. Josefsson.
October 2006. (Format: TXT=35491 bytes) (Obsoletes RFC3548) (Status:
PROPOSED STANDARD)

5335 Internationalized Email Headers. Y. Abel, Ed.. September 2008.
(Format: TXT=27945 bytes) (Updates RFC2045, RFC2822) (Status:
EXPERIMENTAL)

[3] http://explotandocodigo.100webspace.net/Public/encode/Base64Encoder.html
[4] http://www.jasypt.org/

Guia de inicio para Ireport

| 0 comentarios

Como ya lo había prometido, a continuación un post sobre el diseñador Ireport para JasperReports. Trataré de describir la funcionalidad de este sin que este se vea comprometido con un solo sistema operativo.

OBJETIVO:

  • Conocer la utilidad de esta
  • Tener una perspectiva de manera rápida aunque no definitiva de las cosas que se pueden hacer con Ireport
  • Tener una solución bajo la manga
  • Que esta guía sea una referencia para alguien en este Cyberespacio

INTRODUCCION

¿Qué es Ireport?

  • Diseñador de reportes gráficos muy complejos si así lo requerimos para JasperReports
  • Un programa OpenSource (GPL)
  • Esta escrito al 100% en Java
  • La versión comercial de esta y la que se recomienda para la producción se llama JasperStudio la cual es mantenida por la empresa JasperSoft Corporation
  • Esta integrada en la Jasper Bussines Intelligence Suite
  • Sitio WEB

Algunas Características

  • Categoría: Bussines Intelligence
  • Soporte para TrueType
  • Manejo de múltiples fuentes de datos como: todas las bases de datos soportadas por JDBC, archivos XML, CSV, Hibernate entre otros…
  • Soporta SQL, HQL, EJBQL, MDX y Xpath
  • Wizard para la creación de reportes y sub-reportes
  • Más de 30 elementos para formatear el reporte (lineas, elipses, TextFields, charts,código de barras, etc.)
  • El núcleo de este es una biblioteca llamada JasperReports, la cual fue desarrollada por Teodor Danclu de JasperSoft Corporation
  • Los reportes generados se puede pre visualizar y/o exportar en PDF, HTML, RTF, XLS, CSV, TXT y más...

Example2

Desarrollo

Para poder ejecutar el Ireport se necesita el SDK 1.5.0 o superior, 256MB de RAM y al menos 20 megas de espacio en disco.

Estructura de los reportes

La estructura de los reportes se encuentra dividida por secciones horizontales llamadas "Bandas", las cuales son rellenadas con los datos que requerimos en una posición especifica, es aquí donde se definen las reglas del reporte

Esta divida en 9 bandas, en las cuales se pueden removidas o agregadas en el reporte, por default se muestran:

  • Titulo
  • Header de pagina
  • Header de columnas
  • Detalle
  • Pie de columna
  • Pie de pagina
  • Ultimo pie de pagina
  • Sumario




JRXML y archivos jasper

Un reporte es guardado en un archivo tipo XML el cual cada una de sus secciones se encuentra definido por jasperreport.dtd, es por eso que el archivo fuente tiene la extensión "*.JRXML" el cual contiene la configuración del reporte físicamente, las dimensiones de la pagina entre otras.

Si la compilación de este archivo se realiza de manera correcta genera entre otros un archivo con extensión "Jasper" el cual puede ser interpretado por la JVM.

Elementos y letras

Los elementos contenidos en un reporte pueden ser:

  • Lineas
  • Elipses
  • Texto estático
  • Texto Dinámico
  • Imagenes
  • Rectangulos con/sin relleno
  • Sub-reportes
  • Codigo de Barras
  • Graficas
  • HyperLink
  • etc.

Esta se encuentra en la barra de herramientas

BarraIreport

Expresiones dentro del reporte

Las expresiones que se pueden manejar dentro de un reporte son instrucciones en lenguaje Java siempre y cuando el resultado sea un objeto (Que extienda de Object pues).

Entonces desde una expresión se puede referir a parámetros, variables fields y lo que se encuentre definido dentro del reporte, aquí algunas sintaxis:



$F{field} Especifica el nombre de un Field
$V{variable} Especifica el nombre de una Variable
$P{parametro} Especifica el nombre de un Parametro
$P!{parametro} Una sintaxis especial usada en una consulta SQL, indica que
el parametro no debe de ser tratado como un valor por ejemplo:

SELECT * FROM empleado $P!(ID)}
Que equivale a decir dado que ID=5
SELECT *FROM empleado WHERE ID = 5


Además se puede usar Groovy como lenguaje dentro de las expresiones

Creación de una conexión con JDBC (Datasources)

Ireport tiene la capacidad de soportar lenguajes de consulta como: SQL, HQL, EJBL, MDX y XPath. Ahora que si no se va a utilizar una consulta a la Base de Datos, no necesitas una consulta dentro del reporte; sino un DATASOURCE

Un datasource es un objeto que itera sobre un record parecido a una tabla. JasperReport provee algunas implementaciones de DataSources que pueden ser envueltas en estructuras de datos genericas como: Arrays o Colecciones de javaBeans, result sets, table models, CSV y archivos XML.

Aquí una lista de datasource y conexiones provistas por Ireport



Plugin para NetBeans

Aqui un tutorial para poder agregar y configurar el plugin necesario para poder trabajar con Ireport desde Netbeans, el ejemplo esta basado en la distro GNU/Linux Ubuntu [2] y aqui otro hecho desde MAC [3].

CONCLUSIÓN

Espero haber logrado los objetivos planeados.

REFERENCIAS

[1] http://jasperforge.org/plugins/project/project_home.php?group_id=83
[2] http://wiki.netbeans.org/Avbravotutorialbasiconetbeansreports
[3] http://wiki.netbeans.org/NBDemoIReport

Convertir un numero a su descripcion en letras (JAVA)

| 11 comentarios

Recientemente tuve la necesidad de realizar la conversión de un numero en su descripción en letras o mejor dicho en pesos mexicanos. Creo que el algoritmo se llama "Conversión del importe" o "Función del importe en letras" y la web habla tendido y largo de esto.

* Para los que programan en Visual Basic(Pronto me incluiré en esta lista), en la web hay una buena cantidad de ejemplos (GUILLE)

Me llamo la atención este código hecho en Visual Basic, el cual adapte a Java


Public Function Num2Text(ByVal value As Double) As String
Select Case value
Case 0 : Num2Text = "CERO"
Case 1 : Num2Text = "UN"
Case 2 : Num2Text = "DOS"
Case 3 : Num2Text = "TRES"
Case 4 : Num2Text = "CUATRO"
Case 5 : Num2Text = "CINCO"
Case 6 : Num2Text = "SEIS"
Case 7 : Num2Text = "SIETE"
Case 8 : Num2Text = "OCHO"
Case 9 : Num2Text = "NUEVE"
Case 10 : Num2Text = "DIEZ"
Case 11 : Num2Text = "ONCE"
Case 12 : Num2Text = "DOCE"
Case 13 : Num2Text = "TRECE"
Case 14 : Num2Text = "CATORCE"
Case 15 : Num2Text = "QUINCE"
Case Is < 20 : Num2Text = "DIECI" & Num2Text(value - 10)
Case 20 : Num2Text = "VEINTE"
Case Is < 30 : Num2Text = "VEINTI" & Num2Text(value - 20)
Case 30 : Num2Text = "TREINTA"
Case 40 : Num2Text = "CUARENTA"
Case 50 : Num2Text = "CINCUENTA"
Case 60 : Num2Text = "SESENTA"
Case 70 : Num2Text = "SETENTA"
Case 80 : Num2Text = "OCHENTA"
Case 90 : Num2Text = "NOVENTA"
Case Is < 100 : Num2Text = Num2Text(Int(value \ 10) * 10) & " Y " & Num2Text(value Mod 10)
Case 100 : Num2Text = "CIEN"
Case Is < 200 : Num2Text = "CIENTO " & Num2Text(value - 100)
Case 200, 300, 400, 600, 800 : Num2Text = Num2Text(Int(value \ 100)) & "CIENTOS"
Case 500 : Num2Text = "QUINIENTOS"
Case 700 : Num2Text = "SETECIENTOS"
Case 900 : Num2Text = "NOVECIENTOS"
Case Is < 1000 : Num2Text = Num2Text(Int(value \ 100) * 100) & " " & Num2Text(value Mod 100)
Case 1000 : Num2Text = "MIL"
Case Is < 2000 : Num2Text = "MIL " & Num2Text(value Mod 1000)
Case Is < 1000000 : Num2Text = Num2Text(Int(value \ 1000)) & " MIL"
If value Mod 1000 Then Num2Text = Num2Text & " " & Num2Text(value Mod 1000)
Case 1000000 : Num2Text = "UN MILLON"
Case Is < 2000000 : Num2Text = "UN MILLON " & Num2Text(value Mod 1000000)
Case Is < 1000000000000.0# : Num2Text = Num2Text(Int(value / 1000000)) & " MILLONES "
If (value - Int(value / 1000000) * 1000000) Then Num2Text = Num2Text & " " & Num2Text(value - Int(value / 1000000) * 1000000)
Case 1000000000000.0# : Num2Text = "UN BILLON"
Case Is < 2000000000000.0# : Num2Text = "UN BILLON " & Num2Text(value - Int(value / 1000000000000.0#) * 1000000000000.0#)
Case Else : Num2Text = Num2Text(Int(value / 1000000000000.0#)) & " BILLONES"
If (value - Int(value / 1000000000000.0#) * 1000000000000.0#) Then Num2Text = Num2Text & " " & Num2Text(value - Int(value / 1000000000000.0#) * 1000000000000.0#)
End Select
End Function



* Para lo que usen Crystal report, ya tienen la solución en la mesa
* Hay algoritmos que sobrepasan el numero 999 999 999
* Esta fue mi propuesta por supuesto que no es una solución definitiva (Considerando que los números que usaré no son muy grandes)


/**
* @author Gabriel Mtz.
*/
public class Converter {
Integer counter=0;
String value="";

public String getStringOfNumber(Integer $num){
this.counter = $num;
return doThings($num);
}

private String doThings(Integer _counter){
//Limite
if(_counter >2000000)
return "DOS MILLONES";

switch(_counter){
case 0: return "CERO";
case 1: return "UN"; //UNO
case 2: return "DOS";
case 3: return "TRES";
case 4: return "CUATRO";
case 5: return "CINCO";
case 6: return "SEIS";
case 7: return "SIETE";
case 8: return "OCHO";
case 9: return "NUEVE";
case 10: return "DIEZ";
case 11: return "ONCE";
case 12: return "DOCE";
case 13: return "TRECE";
case 14: return "CATORCE";
case 15: return "QUINCE";
case 20: return "VEINTE";
case 30: return "TREINTA";
case 40: return "CUARENTA";
case 50: return "CINCUENTA";
case 60: return "SESENTA";
case 70: return "SETENTA";
case 80: return "OCHENTA";
case 90: return "NOVENTA";
case 100: return "CIEN";

case 200: return "DOSCIENTOS";
case 300: return "TRESCIENTOS";
case 400: return "CUATROCIENTOS";
case 500: return "QUINIENTOS";
case 600: return "SEISCIENTOS";
case 700: return "SETECIENTOS";
case 800: return "OCHOCIENTOS";
case 900: return "NOVECIENTOS";

case 1000: return "MIL";

case 1000000: return "UN MILLON";
case 2000000: return "DOS MILLONES";
}
if(_counter<20){
//System.out.println(">15");
return "DIECI"+ doThings(_counter-10);
}
if(_counter<30){
//System.out.println(">20");
return "VEINTI" + doThings(_counter-20);
}
if(_counter<100){
//System.out.println("<100");
return doThings( (int)(_counter/10)*10 ) + " Y " + doThings(_counter%10);
}
if(_counter<200){
//System.out.println("<200");
return "CIENTO " + doThings( _counter - 100 );
}
if(_counter<1000){
//System.out.println("<1000");
return doThings( (int)(_counter/100)*100 ) + " " + doThings(_counter%100);
}
if(_counter<2000){
//System.out.println("<2000");
return "MIL " + doThings( _counter % 1000 );
}
if(_counter<1000000){
String var="";
//System.out.println("<1000000");
var = doThings((int)(_counter/1000)) + " MIL" ;
if(_counter % 1000!=0){
//System.out.println(var);
var += " " + doThings(_counter % 1000);
}
return var;
}
if(_counter<2000000){
return "UN MILLON " + doThings( _counter % 1000000 );
}
return "";
}
}



El resto depende de lo que quieran lograr con este algoritmo. Podrían adaptarlo para que sea especifico a un Locale, Moneda o tal vez para cierto idioma =)