IPCorp Blog

En el post anterior había explicado el uso de Gbarcode, una librería para generación de códigos de barras con Ruby. El problema es que esta librería no se puede utilizar en Jruby ya que tiene extensiones nativas en C, cosa que Jruby aún no soporta.
Después de investigar alternativas de generación de codigos de barras para java como Zxing y Barbecue. Me quedé con Barcode4j por facilidad de implementación, documentación (la cual es muy completa) y sobre todo estabilidad.
A continuación paso a comentarles como utilizar esta librería en JRuby.

1) Lo primero es descargarse en paquete binario del sitio o bien de este enlace directo.
2) Al descomprimir el Zip, copiamos el contenido del directorio Build al directorio /lib de nuestra instalación de JRuby

3) Ahora vamos al código:

require 'java'

#Importamos algunas librerías que vamos a utilizar
import 'java.awt.image.BufferedImage'
import 'java.io.OutputStream'
import 'java.io.FileOutputStream'

#Importamos las librerías de los códigos de barras (Barcode4j) que necesitamos
import 'org.krysalis.barcode4j.impl.code39.Code39Bean'
import 'org.krysalis.barcode4j.impl.code128.Code128Bean'
import 'org.krysalis.barcode4j.impl.int2of5.Interleaved2Of5Bean'
import 'org.krysalis.barcode4j.impl.codabar.CodabarBean'
import 'org.krysalis.barcode4j.impl.code128.EAN128Bean'
import 'org.krysalis.barcode4j.impl.pdf417.PDF417Bean'
import 'org.krysalis.barcode4j.impl.upcean.EAN13Bean'
import 'org.krysalis.barcode4j.impl.upcean.EAN8Bean'
import 'org.krysalis.barcode4j.impl.upcean.UPCABean'
import 'org.krysalis.barcode4j.impl.datamatrix.DataMatrixBean'
import 'org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider'
import 'org.krysalis.barcode4j.tools.UnitConv'

#Creamos el Bean y establecemos los dpi y wide_factor
bean = Interleaved2Of5Bean.new()
dpi = 150
bean.wide_factor = 3

#Creamos la imagen
ofile = java.io.File.new('/home/laptop/barcodes/barcode.png')
out = FileOutputStream.new(ofile)
canvas = BitmapCanvasProvider.new(out,"image/x-png", dpi, BufferedImage::TYPE_BYTE_BINARY, false, 0)

#Generamos el código de barras
#El segundo parámetro que pasamos es el número del que deseamos generar el codigo de barras
bean.generate_barcode(canvas, '1234567890');
canvas.finish
out.close

Con esto, generamos una imagen con nuestro codigo de barras en /home/laptop/barcodes/barcode.png la cual se puede incluir en cualquier pdf/html/odf, etc.

Espero les sea útil. Cualquier duda, no duden en comentar.

Uno de los grandes problemas en el desarrollo con Ruby on Rails son los reportes multipágina. Debido a que el HTML (inclusive HTML 5) no soporta multipágina, si utilizamos Jruby tenemos la posibilidad de usar cualquier librería Java en nuestro desarrollo.
Afortunadamente en Java tenemos JasperReports (http://jasperforge.org/), una excelente solución al problema antes mencionado.

Para poder incluir un reporte realizado con JasperReports en nuestra aplicación Jruby necesitamos:

1) Descargar I-Report, la herramienta de administracion de reportes de JasperReports. http://jasperforge.org/projects/ireport y descomprimirlo.

2) Dentro del directorio del i-report, ir a modules/ext/ y copiar todos los archivos .jar (si, todos ) al directorio lib de la instalación de JRuby. De esta manera, ya incluimos las librerías necesarias y tenemos preparado nuestro JRuby para utilizar JasperReports.

3) Nos resta crear un reporte para prueba, si nunca hiciste un reporte con i-report: http://jasperforge.org//website/ireportwebsite/IR%20Website/ir_design_a_report.html?header=project&target=ireport

4) Finalmente el código para correr nuestro reporte es el siguiente:

require 'java'
import 'oracle.jdbc.OracleDriver' #Aqui necesitas Utilizar el Driver de la Base de datos que estas usando, en mi caso es oracle
import 'net.sf.jasperreports.engine.JasperCompileManager'
import 'org.apache.commons.dbcp.BasicDataSource'
import'java.util.HashMap'
import'net.sf.jasperreports.engine.JasperFillManager'
import'net.sf.jasperreports.engine.JasperExportManager'                                                                             

#Creo el datasource
basicdatasource = BasicDataSource.new
basicdatasource.driver_class_name = 'oracle.jdbc.OracleDriver'
basicdatasource.username = 'usuario'
basicdatasource.password = 'password'
basicdatasource.url = 'jdbc:oracle:thin:@localhost:1521:XE'
basicdatasource.connection
conexion = basicdatasource.connection

#Compilamos el reporte
jasperReport = JasperCompileManager.compile_report('/url_de_tu_archivo_jrxml/reporte.jrxml')
#Para pasar los parámetros, definimos un objeto HashMap
m = HashMap.new
m.put('parametro_1','valor_parametro_1')
m.put('parametro_2','valor_parametro_2')
m.put('parametro_n','valor_parametro_n')

#Genero el reporte
jasperPrint = JasperFillManager.fill_report(jasperReport, m,conexion)                           

#Exporto el PDF
JasperExportManager.export_report_to_pdf_file(jasperprint, 'path_al_archivo_PDF.pdf')

Si deseamos generar reportes en Rails, podemos por ejemplo ubicar los reportes en el directorio public/reportes y utilizar send_file para enviarlos, por ejemplo:

JasperExportManager.export_report_to_pdf_file(jasperprint, RAILS_ROOT+"/public/reportes/reporte.pdf")
send_file RAILS_ROOT+"/public/reportes/reporte.pdf"

Espero les sea de utilidad, cualquier cosa comenten y trataré de despejar dudas

En el proceso de autenticación, una aplicación permitirá a usuarios autenticados una serie de servicios permitidos. Cuando este usuario intenta acceder a un recurso en la aplicacion, tiene que tomar la decisión sobre qué recursos son accesibles con los permisos que tiene asignados o con otras características.

La decisión si a determinado usuario se le permite acceder a un recurso dentro de la aplicación se llama “decisión de control de acceso”. Se basa en el estado de la autenticación del usuario, y de la naturaleza de los recursos y los atributos de acceso. En Spring security, las decisiones de control de acceso son llevados a cabo por los managers de decisión de acceso, los cuales deben implementar la interfaz AccessDecisionManager. Cada uno es libre de crear su propio manager de decisión de acceso implementando esta interfaz, de todas maneras Spring Security viene con tres managers que implementan esta interfaz basado en el método de votos.

Read the rest of this entry »

FindBugs es una aplicación desarrollada por la Universidad de Maryland cuyo objetivo es buscar bugs en programas Java. Está basado en el concepto de patrones de bug. Un patrón de bug es un idioma de código que a menudo es un error. Los patrones de bugs aparecen por una variedad de razones:

• Dificultad de algunas características del lenguaje.
• Falta de comprensión de los métodos de la API.
• Errores de variación cuando el código es modificado durante el mantenimiento.
• Una variedad de errores: errores de tipeo, uso incorrecto de los operadores booleanos, etc.

FindBugs usa análisis estático para inspeccionar el bytecode de Java en busca de patrones de bugs. Con análisis estático nos referimos a que puede encontrar errores simplemente inspeccionando el código de un programa: ejecutarlo no es necesario. Esto hace a FindBugs muy fácil de usar. En la práctica, la tasa de falsas advertencias reportadas por FindBugs es menor al 50%.

Instalación y ejecución

La manera más fácil de instalar FindBugs es bajar la distribución binaria que viene empaquetada en forma de archivo tar.gz o zip. FindBugs requiere JRE (or JDK) 1.5.0 o posterior para poder ejecutarse. Sin embargo puede analizar programas compilados en cualquier versión de Java. Un vez que lo bajamos lo descomprimimos de la siguiente manera:

tar -xvf findbugs-1.3.9.tar.gz
cd findbugs-1.3.9/
java -jar lib/findbugs.jar

FindBugs clasifica los bugs en las siguientes categorías

• Correcto pero probable bug: un error de codificación aparente resultando en código que probablemente no era lo que el programador tenía en mente.
• Mala Prácticas: violaciones a las prácticas de codificación esenciales y recomendadas, por ejemplo: uso incorrecto del finalize.
• Código Dudoso: esto es código confuso, anómalo, o escrito de una manera que lleva a si mismo a errores, por ejemplo: casts sin confirmar, chequeos de nulos redundantes, etc.