Fecha : 02 de Octubre de 2010

Lugar : Edificio 9 de julio . 9 de Julio 1449  - Corrientes -Cap-

Dirigido a estudiantes de la carrera de sistemas y pùblico en general. Las acreditaciones se realizan el mismo dìa, se entregaran certificados.

Cronograma de charlas

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.

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

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.

Todos estos managers de decision requieren un grupo de vontantes que se configuran para la votación sobre las decisiones de control de acceso. Cada votante debe implementar la interfaz AccessDecisionVoter. Un votante puede votar para garantizar el acceso, puede abstenerse de votar o puede denegar un recurso. Los resultados se representan por las constantes ACCESS_GRANTED, ACCESS_DENIED, y ACCESS_ABSTAIN que son definidos en la interfaz AccessDecisionVoter.
Por defecto si no se especifica ningún manager de decision de acceso entonces Spring va a configurar automaticamente un manager con el método AffirmativeBased con los dos siguientes votantes:

• RoleVoter: vota por una decision de control de accesos basando en el rol del usuario. Solamente procesará los atributos de acceso que contengan el prefijo ROLE_, pero este prefijo se puede configurar. Vota por garantizar el acceso si el usuario tiene el mismo rol que el requerido para accedejor al recurso. vota por denegar el acceso si el usuario carece del rol requerido. Si el recurso no tiene un atributo de acceso que comienza con el prefijo ROLE_, el vontante se abstendra de emitir su voto.
• AuthenticatedVoter: vota por una decision de control de acceso basado en niveles de autenticación de usuario. solamente procesará si el atributo de acceso es IS_AUTHENTICATED_FULLY, IS_AUTHENTICATED_REMEMBERED, and IS_AUTHENTICATED_ANONYMOUSLY. Votará afirmativamente si el nivel de autenticacion es superior que el atributo requerido. De arriba para abajo los niveles de autenticacion son: “fully authenticated,” “authentication remembered,” y “anonymously authenticated.”

Por defecto, Spring security configurará un manager de decisión de acceso si no se especifica alguno. Este managaer de decision de acceso por defecto es equivalente al definido en la siguiente configuración:

<bean id="_accessManager">
  <property name="decisionVoters">
    <list>
      <bean class=org.springframework.security.vote.RoleVoter/>
        <bean class=org.springframework.security.vote.AuthenticatedVoter/>
      </list>
    </property>
</bean>

Este manager de decision de acceso y su s votantes deberian satisfacer los requerimientos tipicos de autenticacion. No obstante, si no satisface alguno específico, se puede crear uno propio. En la mayoria de los casos, se necesitará crear un votante customizado. Por ejemplo, se puede crear un votante que tome decision en base a la direccion IP del usuario:

package com.apress.springrecipes.board.security;
import org.springframework.security.Authentication;
import org.springframework.security.ConfigAttribute;
import org.springframework.security.ConfigAttributeDefinition;
import org.springframework.security.ui.WebAuthenticationDetails;
 
public class IpAddressVoter implements AccessDecisionVoter {
  public static final String IP_PREFIX = "IP_";
  public static final String IP_LOCAL_HOST = "IP_LOCAL_HOST";
 
  public boolean supports(ConfigAttribute attribute) {
     return attribute.getAttribute() != null
     && attribute.getAttribute().startsWith(IP_PREFIX);
}
 
public boolean supports(Class clazz) {
return true;
}
 
public int vote(Authentication authentication, Object object,
   ConfigAttributeDefinition config) {
if (!(authentication.getDetails() instanceof WebAuthenticationDetails)) {
   return ACCESS_DENIED;
}
 
WebAuthenticationDetails details = (WebAuthenticationDetails) authentication.getDetails();
String address = details.getRemoteAddress();
int result = ACCESS_ABSTAIN;
for (Object element : config.getConfigAttributes()) {
  ConfigAttribute attribute = (ConfigAttribute) element;
  if (this.supports(attribute)) {
    result = ACCESS_DENIED;
    if (IP_LOCAL_HOST.equals(attribute.getAttribute())) {
      if (address.equals("127.0.0.1")) {
        return ACCESS_GRANTED;
      }
    }
  }
}
return result;
}
}

Notar que este vontante procesará los atrbutos de acceso que comienzan con el prefijo IP_. Por el momento, solamente soporta el atributo IP_LOCAL_HOST. Su el usuario es un cliente web cuya direcciones IP es iguial a 127.0.0.1, votará por un acceso permitido. De otra forma, votará por denmegar el acceso. Si el recurso no tiene un atributo que comienza con IP_, entonces se abstine de votar.
A continuación habra que definir un manager de decision de acceso personalizado  que incluya este votante:

<beans:bean id=”accessDecisionManager” class=”org.springframework.security.vote.AffirmativeBased”>
	<beans:property name=”decisionVoters”>
		<beans:list>
			<beans:bean class=”org.springframework.security.vote.RoleVoter” />
			<beans:bean class=”org.springframework.security.vote.AuthenticatedVoter” />
			<beans:bean class=”com.apress.springrecipes.board.security.IpAddressVoter” />
		</beans:list>
	</beans:property>
</beans:bean>

Ahora supongamos que nos gustaría permitir usuarios de maquinas que corren un container WEB. Habra que hacer referencia a este manager de decision de acceso desde el elemento de configuracion  <http> para agregar el atributo de acceso IP_LOCAL_HOST a la url  /messageDelete-htm*:

<http access-decision-manager-ref=”accessDecisionManager”>
	<intercept-url pattern=”/messageList.htm*” access=”ROLE_USER,ROLE_GUEST” />
	<intercept-url pattern=”/messagePost.htm*” access=”ROLE_USER” />
	<intercept-url pattern=”/messageDelete.htm*” access=”ROLE_ADMIN,IP_LOCAL_HOST” />
…
</http>

Entonces si se quiere acceder a la aplicacion board message desde localhost, no se necesitará loguearse como administrador para ejecutar la acción.

Traducido de Apress Spring Recipes A Problem-Solution Approach (2008) - Gary Mak

• 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.