El objetivo de la charla es compartir la experiencia de utilizar la tecnología de:

• Ruby: lenguaje de programación interpretado, reflexivo y orientado a objetos, creado por el japonés Yukihiro “Matz” Matsumoto. Combina una sintaxis inspirada en Python y Perl con características de programación orientada a objetos similares a Smalltalk.
• GTK+ o The GIMP Toolkit: conjunto de bibliotecas multiplataforma para desarrollar interfaces gráficas de usuario (GUI). GTK+ se diseñó para permitir programar con lenguajes como C, C++, C#, Java, Ruby, Perl, PHP o Python.
• MongoDB: sistema de base de datos multiplataforma orientado a documentos, de esquema libre. Se destaca su velocidad y su rico pero sencillo sistema de consulta de los contenidos de la base de datos.

Los esperamos en el edificio de la FACENA ubicado por calle 9 de Julio.

Estaré presentando la charla “Interfaces de Usuario Con Ruby y GTK” el viernes 02 de septiembre de 2011 a las 14:30 hs.

Si querés saber un poco más visitá: JOINEA

Los espero

IPCorp S.R.L estara presente en el mismo presentando  la charla  sobre “Desarrollo con RubyOnRails y PostgreSQL”  la misma sera disertada por Carlos Mathiasen y Alfredo Ramirez el sabado 21 de mayo de 2011 a las 15:00 hs.

Este evento tiene como objetivo fomentar las ventajas técnicas, sociales, políticas y filosóficas relacionadas a la utilización del software libre. En particular este año abordaremos 2 temáticas: “Hackers” y “Cultura Libre” para que podamos divertirnos entre todos de la diversidad de temas en nuestra comunidad.

Este año nuevamente contaremos con la presencia de:

- Mozilla Foundation que llevan adelante un modelo de negocio basado en software libre y conocimiento libre.
- SoLAr (Software Libre Argentina) – Asociación civil sin fines de lucro dedicada a la promoción del Soft. libre en nuestro país.

El evento constará de:
Viernes 20: Charlas y ponencias en el auditorium de la Facultad de Ingeniería – Juan Manuel de Rosas 325. Acreditación 8:00 hs – Inicio 9:15hs
Sábado 21: Charlas en las aulas “Hackers” y “Cultura Libre” (Facultad de Ingeniería). INICIO 9:00 hs
Entrada Libre y Gratuita – CERTIFICADO IMPRESO $25

<% form_remote_for @personas, :url => crear_titulares_personas_path, :method => 'POST' , :update => 'creado' do |f| %>
<%= f.text_field :nombre, :class => 'required'%>
<%= f.submit "Guardar" %>
<% end %>
 
<script type="text/javascript">
  $(document).ready(function(){
   $('#new_factor_variante').validate();
  });
</script>

Normalmente, al presionar el botón Guardar, el plugin me dice que ingrese un nombre (debido a que el campo es requerido) y no va al método del controller hasta que lo ingrese. Sin embargo me mostraba el error, pero igual se iba hasta el controller, es decir, la acción se ejecutaba igual.
Para resolver esto, después de una ardua búsqueda en google, decidí consultar la api de rails 2.3.5(es la versión que estoy usando) y encontre que podes agregar una condición en el form, para que se ejecute o no la acción y en esta condición puedo meter código javascript.
Lo que hice fue preguntar si el formulario era válido y el código me quedó así:

<% form_remote_for @persona, :url => crear_titulares_personas_path, :method => 'POST' , :condition => '$(this).valid()',  :update => 'creado' do |f| %>
<%= f.text_field :nombre, :class => 'required'%>
<%= f.submit "Guardar" %>
<% end %>
<script type="text/javascript">
  $(document).ready(function(){
   $('#new_factor_variante').validate();
  });

.valid() es un método del jquery validation que me devuelve un valor booleano según el estado del formulario.
Con esto ya pueden tener validación del lado del cliente con un formulario ajax en rails.
Espero les sirva, cualquier cosa pregunten nomás

<table>
  <tr>
    <th>Raza</th>
    <th>Nombre</th>
    <th></th>
    <th></th>
    <th></th>
  </tr>
 
<% @perros.each do |perro| %>
  <tr>
    <td><%= perro.raza.descripcion %></td>
    <td><%= vaca.nombre %></td>
    <td><%= link_to 'Show', perro %></td>
    <td><%= link_to 'Edit', edit_perro_path(perro) %></td>
    <td><%= link_to 'Destroy',perro,:confirm=>'Are you sure?',:method=>:delete%></td>
  </tr>
<% end %>
</table>

Este código no es difícil de entender. Se empieza a poner un poco más
complicado cuando tenemos un código mas largo y con más código embebido,
por más ordenados que seamos cuesta entenderlo.
Para esto está Haml, en su página nos dice que “convierte nuestras horrorosas
plantillas en un verdadero haiku”. ¿Será cierta esta afirmación?, veamos como
queda nuestro listado:

%table
  %tr
    %th Raza
    %th Nombre
    %th
    %th
    %th
- @perros.each do |perro|
    %tr
      %td=perro.raza.descripcion
      %td=perro.nombre
      %td=link_to 'Show', perro
      %td=link_to 'Edit', edit_perro_path(perro)
      %td=link_to 'Destroy', perro, :confirm => 'Are you sure?', :method => :delete

Es un código mucho más limpio y ordenado, y sin dudas escribimos mucho menos

Según el sitio oficial de Haml , está basado en la idea de que el código de
descripción de páginas debe ser hermoso. Pensando en la simplicidad de Ruby y la
elegancia de Rails,recordando el axioma de que “la perfección se alcanza, no cuando ya
no queda nada más por agregar, sino cuando no queda nada más por eliminar”.
Como lenguaje de propósito específico está completamente diseñado para documentos XML,
y no tiene ninguna característica fuera de este ámbito.

Para instalar Haml en nuestra aplicación de rails 3, basta simplemente con editar el Gemfile
y agregar

gem 'haml'

luego en la consola ejecutamos

bundle install

y ya tenemos Haml en nuestra aplicación.
A partir de ahora los nombres de archivos html serán de la siguiente
manera index.html.haml.
La forma básica de un elemento html, sería así

%tagname{:attr1 => 'value1', :attr2 => 'value2'} Contents

Un párrafo nos quedaría así:

%p{:datatype => 'lupita'} Esto es un parrafo
 
#nos devuelve
<p datatype="lupita"> Esto es un parrafo </p>

Para cuando queremos utilizar un div, por ser este un elemento muy común no
necesita que pongamos %div. simplemente tenemos que poner el nombre del id (#) o
de la clase (.).

#show Esto es un div
 
//nos devuelve
<div id="show">Esto es un div</div>

De la misma manera si queremos agregar un id o una clase a cualqier tag, sería de esta
forma

%tagname#id.class

En Haml no se cierran los tags, esto se hace automáticamente, gracias a que es muy estricto
con la identación. Genera todo el html siguiendo la estructura de nuestro código

%ul
  %li Perro
  %li Gato
 
#nos devuelve
<ul>
  <li>Perro</li>
  <li>Gato</li>
</ul>

Y lo que más nos interesa. Si queremos embeber código ruby tenemos dos símbolos.
Si queremos mostrar algo usamos el igual (=), si no queremos que se vea usamos el guión medio(-).

%h1= @perro.nombre
- if @perro.agresividad > 5
  %p Es muy agresivo

Bueno, esto es una pequeña introducción a todo lo que podemos llegar a hacer con
haml. Y lo lindo que nos va a quedar nuestro código escrito de esta forma. Y es una muy
buena manera de aprender a indentar también. Para tener información un poco
más completa, tenemos su página oficial y su api
Espero que les guste y hasta la próxima.

Las inscripciones se realizan del 14 al 18 de febrero en el laboratorio de informática de 14 a 21 hs, o bien por correo electrónico a cursosveranofacena@gmail.com

Para más información de los contenidos de cada curso: http://exa.unne.edu.ar/docs/Informatica-Cursosdeverano2011-contenidos.pdf

Si querés obtener más información sobre los cursos dictados por el staff de IPCorp, podés enviar un email a contacto@ipcorp.com.ar, detallándonos tus consultas.

El otro día necesitaba eliminar un registro de una tabla, pero si este registro tenia algún registro asociado en otra tabla este no podía ser eliminado. La forma más fácil era hacer un NombreDeModelo.find() en todas las tablas asociadas y ver si existen registros. El problema es si esa tabla tiene asociadas muchas tablas y cada una de estas muchos registros, tomaría su tiempo.
La solución que se me ocurrió fué saber cuales son las tablas asociadas e ir haciendo los NombreDeModelo.find() de a uno y si alguno encuentra algo que tire un mensaje.
Rails tiene un método muy interesante que nos resuelve esto, se llama reflections.
Lo que hace es devolvernos un hash con todas las relaciones definidas en el modelo, veamos un poco de código:

Departamento.reflections
 
=> { :designaciones=>#<ActiveRecord::Reflection::AssociationReflection:0x46c04fc1 @name=:designaciones, 
                                  @active_record=Departamento(id: integer, descripcion:string), 
                                  @options={:class_name=>"Designacion"}, 
                                  @macro=:has_many>, 
       :localidades=>#<ActiveRecord::Reflection::AssociationReflection:0x261c2628 
                              @name=:localidades, 
                              @active_record=Departamento(id: integer, descripcion: string), 
                              @options={}, 
                              @macro=:has_many>}

Como vemos nos devuelve un hash, donde el key esta dado por el nombre que le dimos en el modelo a la relación y el value
es un objeto de la clase Reflection. Este objeto contiene 4 atributos:
@name: Nombre de la relación
@active_record: Este no entendí mucho, ya que no lo usé, si alguien me explica estaría bueno para agregarlo.
@options : las opciones que definimos en las relaciones, como el :class_name, foreign_key, :through, etc.
@macro: El tipo de relación

Con esto ya tenemos casi terminado el problema antes descripto, hacemos uso de un bloque y nos queda así:

Departamento.reflections.each do |ref|   
      if ref[1].macro.to_s == 'has_many' 
        registro = eval('@departamento.' + ref[1].name.to_s + '.first')     
      end
      unless registro.blank?
        existe_registro = 1
        break
      end
    end

Lo que hacemos es recorrer el hash hasta que encontramos un registro. Cuando encontramos uno cortamos la ejecución del bloque para que no siga buscando en la base de datos y problema resuelto.

Estoy seguro que debe haber miles de formas de hacer esto y quiza mucho más fácil, estaría bueno que comenten sus experiencias, siempre es bueno escuchar otra campana.

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 comenzar tenemos que incluir las librerias del plugin en el aplication.html.erb

 <% javascript_include_tag :default, 'multiple-file-upload/jquery.MultiFile.js', 'multiple-file-upload/jquery.MetaData.js' %>

En nuestra vista creamos el formulario, para subir los archivos

<% form_for(:archivo_digital, :html => {:multipart => true },:url => create_archivo_digital_path) do |f| %>
<ul id="form">
	    &lt;%= file_field_tag :files, :class =&gt; 'multi file', :name =&gt; 'pdf_files[]'%&gt;
	<li>
            &lt;%= f.submit 'Subir' %&gt;
            &lt;%= f.submit 'Cancelar' %&gt;</li>
</ul>
&lt;% end %&gt;

Expliquemos un poco el código:

En necesario establecer :multipart => true, para que el formulario admita la carga de archivos.
file_field_tag nos crea el tag para poder abrir el cuadro de diálogo de carga de archivos de un navegador:
:class => ‘multi file’, esta clase es la que utiliza MultiFileUpload para hacer la magia de subir varios archivos
:name => ‘pdf_files[]‘ esto es muy necesario, porque el plugin crea un arreglo con todos los archivos, pero para que ruby sepa
que nos referimos a un arreglo tenemos que poner [].
Por último tenemos dos botones, el de Subir, que va a subir todos los archivos de una sola vez y el de Cancelar, que hará lo propio.

En nuestro controller vamos a tener

#Renderiza el formulario para subir los archivos
  def new
    @archivo_digital = ArchivoDigital.new
    respond_to do |format|
      format.html
    end
  end
 
  def create
    respond_to do |format|
      if params[:commit] == "Subir"
        unless params[:pdf_files].blank?
          params[:pdf_files].each do |archivo|
            params[:archivo_digital][:nombre_archivo] = archivo
            params[:archivo_digital][:archivo] = archivo.read
            @archivo_digital = ArchivoDigital.new(params[:archivo_digital])
            if @archivo_digital.save
              flash[:notice] = 'Archivo agregado'
            end
          end
          format.html{redirect_to archivos_digitales_path}
        else
          flash[:error] = 'Debe seleccionar al menos un archivo'
        end
      else
           format.html{redirect_to archivos_digitales_path}
      end
    end
  end

Expliquemos un poco el código:
Sobre el primer método no hay mucho que decir, solo nos renderiza el formulario que creamos en el paso anterior
El método create es el que hace todo, para empezar tenemos una condición donde pregunta si params[:commit] == “Subir”
esto es para que diferencie entre el botón subir y el cancelar. Cuando presionamos un botón, rails inmediatamente manda un parámetro, llamado
commit con el nombre del botón. Con está condición lo que hacemos es darle tareas diferentes a cada botón.
Si no se cumple la condición, es porque se presionó el botón “Cancelar” y nos redirigirá al listado de archivos.
En caso de que la condición se cumpla, tenemos otro condicional: unless params[:pdf_files].blank?, esto es para saber si se seleccionó algun archivo_digital
y caso contrario muestra un flash[:error]. Si se cumple la condición, recorremos el arreglo y vamos guardando en nuestra base de datos el nombre del
archivo y el archivo en sí.

Bueno, esto es una manera sencilla de subir archivos de forma “masiva” con Jquery y Rails, cualquier cosa no duden en preguntar