Rafinguer Blog: El blog de tecnología

Tecnillusions estrena nueva web

2009-11-01T17:05:00.002+01:00

Ya está disponible la nueva web de Tecnillusions, una compañía especializada en soluciones tecnológicas a medida. Su nueva web está basada en tecnología Flex y Flash, en donde se presenta la compañía y su apuesta por las nuevas tecnologías en base a la sencillez y el diseño. La nueva web está tanto en castellano como en inglés, y en ella se ha plasmado el espíritu y la filosofía de la misma.

Algunas de las pantallas de esta nueva Web son las siguientes:

Enlace a la página web: http://www.tecnillusions.com

Trazalogic: Software para trazabilidad de alimentos

2009-10-31T06:16:00.001+01:00

Trazalogic es un proyecto actualmente en desarrollo para dar cobertura a la trazabilidad de alimentos para empresas de elaboración y manipulación de alimentos. Las principales características de Trazalogic con respecto a otros productos similares son las siguientes:

Costes mínimos:

Desarrollado bajo estándares de software libre:

Servidor de aplicaciones Apache Tomcat

Procesos de negocio servidos mediante Java

Base de datos PostgreSQL

Front-end basado en Adobe AIR/Flash

Mínimo mantenimiento

Libertad de licencias:

Sin restricciones en cuanto a equipos instalados

Sin restricciones en cuanto a tiempo

El soporte es opcional, y sólo se paga por el plan deseado acorde al uso del mismo

Sencillez y productividad optimizadas:

Interfaces de usuario ricas

Sistema de inteligencia que anticipa los procesos

Menos operaciones manuales y más procesos automatizados

Entorno muy intuitivo que apenas requiere aprendizaje

Pensado también para pantallas táctiles

Arquitectura web:

Instale un único servidor, acceda desde múltiples puestos en cualquier lugar

Versatilidad en configuraciones de acceso

Acceso restringido a usuarios previamente configurados

Sistema abierto para acceso mediante servicios web, de cara a que otras aplicaciones se puedan integrar con Trazalogic (con requerimiento de firma)

Múltiples idiomas: Inicialmente en castellano y en inglés, pero sería fácil agregar cualquier otro idioma con sistema de caracteres latinos

Múltiples plataformas: Puede ser utilizado en Windows y en Linux

Las principales características funcionales de Trazalogic son las siguientes:

Sistema de administración:

Gestión de usuarios

Gestión de clientes

Gestión de proveedores

Gestión de inventario

Gestión de puntos de control y almacenes

Gestión de recetas o preparación de alimentos

Trazabilidad de actividad del sistema

Trazabilidad de los alimentos

Estadísticas y cuadros de mando

Informes

Sistema de operación:

Gestión de lotes (entrada y salida)

Gestión de productos

Recepción de alimentos primarios

Gestión de almacenamiento de alimentos (entrada y salida)

Elaboración de alimentos

Gestión del envasado

Gestión de salida de productos elaborados

A continuación algunas pantallas de Trazalogic en acción:

Puede solicitar información sin compromiso sobre Trazalogic, a través del correo electrónico: info@tecnillusions.com

Tecnillusions: http://www.tecnillusions.com

Firma de libros en la Conferencia de SPI en Pontevedra

2009-10-25T20:42:00.002+01:00

El pasado viernes, 23 de Octubre de 2009, se celebró en Pontevedra una conferencia sobre SPI, a la que fui invitado por la presidenta de la AESPI, Esperanza López Maquieira. El acto fue presidido, además de por la presidenta de la AESPI, por la vicepresidenta Teresa Pinto, la tesorera Mª Jesús Catalán, el doctor Diego García-Borreguero y el vicepresidente de la diputación de Pontevedra D. José Juan Durán.

En el acto se presentó mi libro "SPI: el demonio que me despierta mientras duermo", que se entregó al final de la conferencia entre los asistentes, y a los que, gustosamente, firmé.

A los interesados, podéis conseguir información sobre el SPI y descargaros mi libro, desde la página de la AESPI: http://www.aespi.net

Existe un foro donde podrás encontrar información de todo tipo (asociaciones, médicos, consultas, tratamientos, noticias, etc.): http://groups.google.com/group/sindrome-de-piernas-inquietas

Flex/AIR: Error de conversión a ArrayCollection de ObjectProxy en llamadas HTTPService

2009-10-20T19:17:00.003+02:00

Me he encontrado con un problema habitual, y ocurre cuando uno hace una llamada a un HTTPService, y en la función que gestiona (handle) la llamada, al asignar el resultado del XML a un ArrayCollection, se encuentra con que no puede asignarse un objeto ObjectProxy al ArrayCollection. Este tipo de operaciones son habituales cuando hay que cargar una lista o un ComboBox. Este problema ocurre cuando solamente se tiene un elemento en la lista, mientras que si hay más de uno, este problema no ocurre. Asimismo, si no hay resultado, también puede dar un error de null. Creo que se trata de un bug de Flex, ya que en estos casos, automáticamente debería dar un ArrayCollection de todas maneras, con cero, uno o más de un item.

Antes de continuar, indicar que este post no contiene un ejemplo completo para poder probar, si no que explica detalladamente como resolver esta situación.

Tras dar vueltas y vueltas al problema, he realizado una pequeña "ñapa" o "parche" para que la carga del ArrayCollection se realice sin problemas.

En primer lugar voy a presentar el XML que devuelve el HTTPService:



<?xml version="1.0" encoding="ISO-8859-1" ?>

<products_providers_in_use>
  <product_provider_in_use>
    <data>6</data>
    <label>Bill Gates</label>
    <id_product>21</id_product>
    <name_product>Escalope de ternera</name_product>
    <total>0</total>
  </product_provider_in_use>
  ...
<products_providers_in_use>

La definición del HTTPService permite definir en qué funciones delegar la ejecución en caso de error (fault) o de éxito (result), así como la URL al HTTPService (url).



<!-- Call to srvGetProductsProvidersInUse service -->
<mx:HTTPService 
  result="handleProductsProvidersInUse(event);"
  fault="handleFault(event);" 
  id="nombre_del_servicio" resultFormat="object"
  url="url_al_httpservice"
  useProxy="false">
</mx:HTTPService>

Es necesario definir el ArrayCollection como una variable de ámbito local, que pueda ser accedida por todas funciones del módulo, componente, etc.



[Bindable]
import mx.collections.ArrayCollection;

private var acInUse:ArrayCollection;

La llamada al HTTPService se realiza mediante el objeto HTTPService (referenciando el nombre indicado en la propiedad id) y al método "send" en el momento que sea necesario (en el creationComplete, al pulsar un botón, etc.):



nombre_del_servicio.send();

Una vez se ejecuta el HTTPService, éste accederá a dicho servicio para obtener un XML. En el caso de que no se haya producido ningún problema en la comunicación, se delegará la ejecución en la función definida en "result". El código para leer correctamente este XML en todos los casos (ya corregido el bug) es el siguiente:



private function handleProductsProvidersInUse(event:ResultEvent):void {
  try {
    acInUse = 
      event.result.products_providers_in_use.product_provider_in_use
        as ArrayCollection;
  }
  catch (err:Error) {
    acInUse=new ArrayCollection();
  }
  if (acInUse==null) {
    var o:Object;
    o=event.result.products_providers_in_use.product_provider_in_use;
    acInUse = new ArrayCollection(
      [{data:o.data,label:o.label,id_product:o.id_product,
      name_product:o.name_product,total:o.total}]);
  }
}

Para controlar las excepciones se abre un bloque try...catch para intentar acceder al XML recogido. Lo normal es asignar al ArrayCollection la colección de datos del XML que se repite. El XML está contenido dentro del parámetro de evento, y en la propiedad "result". El primer elemento del XML ("products_providers_in_use") no se repite, y marca el principio y fin del grupo de datos. Por ello hay que llegar hasta el siguiente nivel del XML: "product_provider_in_use". En teoría, este nivel retornaría un ArrayCollection. En el caso de que tenga más de un elemento no hay problema, pero si hay un sólo elemento, no produce ninguna excepción, pero, inexplicablemente, nos retorna un null. Por ello, tras el catch se hace una comprobación de si es nulo, en cuyo caso se crea un ArrayCollection nuevo, se recoge el único elemento del resultado en un objeto genérico, y se crea un elemento con la información recogida en el XML. En el caso de que el XML estuviera vacío o tuviera algún problema, saltaría una excepción, la cual es recogida por el bloque "catch" y crea un ArrayCollection nuevo, pero vacío, pero no null.

Espero que este ejemplo corte definitivamente el tiempo que os haya hecho perder esta singular situación.

Flex/AIR: Listas personalizadas con ItemRenderer

2009-10-20T11:17:00.009+02:00

Una de las mayores virtudes de Flex es que es posible personalizar la vista de una lista o de un Datagrid, pudiendo añadir elementos que no son estándares (la típica etiqueta o texto), sino que se pueden añadir también elementos gráficos o incluso elementos de interfaz de usuario.

Para ver una muestra de ello, la siguiente imagen muestra una lista con un icono a la izquierda, dependiendo del estado del item:

Como puede apreciarse, aunque sea un ejemplo sencillo, da alas a multitud de posibilidades, tanto de visualización como de edición.

El poder de ItemRenderer es poder incrustar en lugar de un item un componente. Esto es, en lugar de una fila en una lista, o de una columna en un DataGrid.

Planteamiento
El planteamiento de este componente o, mejor dicho, su utilidad, es poder realizar una lista que nos permita seleccionar un elemento, pero que, dependiendo de su estado, se pueda interactuar de una manera u otra.

Por ejemplo, imaginemos una lista de frutas asociadas a un pedido. Puede haber frutas que han sido ya entregadas (estado false o no disponibles) y otras que aún no han sido entregadas (estado true o disponibles). De esa lista, es posible quitar frutas para que no sean servidas. Obviamente, aquellas que ya han sido entregadas no podrán quitarse del pedido, y sí aquellas aún no han sido entregadas. Además del dato de estado, una ayuda visual se agradece, indicando con un pequeño icono o algún estilo de texto cuáles están disponibles y cuáles no.

Componente de contenido

El componente de contenido será aquel que será renderizado en el item. En nuestro caso será un simple HBox, que contendrá una imagen de 20x20 (en formato png, por las transparencias), y una etiqueta con el texto a visualizar.

El código de este componente es el siguiente:

Es importante señalar que en una lista la interacción de los datos ha de coordinarse, pues al hacer clic sobre el item, éste también debe retornar la información. Si no fuera así, sólamente sería un elemento decorativo y no se podría seleccionar. Es por ello que se haya sobreescrito (override) los método set data y get data. Cuando la lista comienza a dibujar (render) cada item, utiliza este componente que hemos utilizado, y le pasa (set) los datos. Internamente, cuando recibe los datos, llama al método refresh para pintarlos adecuadamente. Por otro lado, cuando el usuario hace clic sobre el item, éste debe devolverle (get) a la lista los datos para que pueda seleccionarse e interactuar con el código.

Otra cosa importante a señalar es el uso de la función loadImage:



// This function loads the image
private function loadImage(imgURL:String):void {
  var loader:Loader = new Loader();
  loader.contentLoaderInfo.addEventListener(Event.COMPLETE,
    function (e:Event):void {
      itImage.source=e.currentTarget.content; });
           
  loader.load(new URLRequest(encodeURI(imgURL)));          
}

Se le llama con la ruta donde se alojan las imágenes (puede ser en disco duro, o una URL externa, o una referencia desde el directorio raíz). En el ejemplo, se ha creado un directorio "resources" dentro del raíz del código Flex, y por ello se indica en la ruta como "resources/imagen". Esta función es más recomendable que usar simplemente la propiedad source de la imagen, pues además permite recoger la información correspondiente a la imagen si queremos hacer uso de ella.

LISTA

En el ejemplo, se visualizará la lista correspondiente a partir de unos datos almacenados en un ArrayCollection. Estos datos están incrustados en el código, pero podrían ser leídos de un HTTPService o de un servicio Web.

Los campos de información son los siguientes:
- label: etiqueta o texto a visualizar en la lista
- data: código numérico del producto (no se visualiza)
- state: true/false. Indica la disponibilidad del item

El código es el siguiente:

El punto de inflexión está en la propiedad itemRenderer de la lista, en donde se indica qué componente va a dibujarse en el item de la lista.

El resultado será, además del visual, el que cuando un usuario seleccione un item de la lista, se mostrará una alerta con los datos del item seleccionado, tal y como muestra la siguiente imagen:

Flex/AIR: Teclado virtual avanzado para pantallas táctiles

2009-10-18T13:02:00.007+02:00

Ya está disponible una nueva versión del teclado virtual para pantallas táctiles, con las siguientes mejoras y cambios:

- Posibilidad de elegir entre un texto simple (una línea) o un texto multilínea.
- Se ha evitado los estados para hacer más sencilla la recepción del texto, con tan sólo cerrar la ventana.
- La tecla "Aceptar" se ha sustituito por el "Intro" o retorno de carro.
- Se ha agregado el botón "Anular", con el que se anula por completo el texto actual.
- Se puede interactuar con el teclado tradicional, haciendo editable el display. De esta manera, cuando el texto sea más grande que el display, se hará scrolling, accediendo a la zona de edición (en la versión anterior se cortaba, pues sólo se veía el principio).
- Es posible editar texto para su sustitución por un carácter pulsado en el teclado, o por la tecla borrar.
- Es posible especificar el tamaño máximo del texto (número de caracteres).
- Se ha incluido un status en el que se visualiza cuántos caracteres hay escritos y cuántos caracteres se pueden escribir (tamaño máximo del texto).

En la segunda demo, se ha incluído un fondo para ver cómo el teclado utiliza las transparencias con el fondo. Hay una caja de texto simple y una TextArea. La edición de ambas cajas de texto se realiza, simplemente, haciendo click sobre cada una de ellas.

Cajas de texto simple y multilínea

Teclado virtual avanzado editando multilínea

El código de la demo es el siguiente:

La explicación del código es muy similar a la del ejemplo anterior (mirar http://rafinguer.blogspot.com/2009/10/flexair-teclado-virtual-para-pantallas.html para el detalle). Tan sólo añadir que se pasa al componente, a través de la función "setTextType()", el tipo de texto a visualizar: TYPE_SINGLE (opcional) o TYPE_MULTILINE (en caso de querer un texto multilínea). Asimismo, también se especifica el tamaño máximo a editar para el texto, mediante la función "setMaxChars()".

Otro detalle a considerar es que ahora, al no tener estados o acciones (sólo el cierre de la ventana del teclado), el evento a gestionar es de tipo "Event.CLOSE", cuya función delegada simplemente ha de obtener el texto (función "getText()") sin necesidad de evaluar estados.

Para ver la demo en directo: http://www.tecnillusions.com/demos/DemoKeyboard2/DemoKeyboard2.html

Para descargarse el código fuente y el ejecutable: http://www.tecnillusions.com/demos/DemoKeyboard2/DemoKeyboard2.zip

Flex/AIR: Teclado virtual para pantallas táctiles

2009-10-17T21:40:00.006+02:00

En esta ocasión no voy a explicar algún detalle sobre alguna técnica concreta, si no que voy a publicar, íntegramente un componente que muestra un teclado virtual que puede ser utilizado en lugar del teclado físico, ya sea con el ratón o bien en una pantalla táctil.

El teclado es de tipo QWERTY, y tiene tres modos: normal (minúsculas), mayúsculas y símbolos. Incluye también los números.

Otro detalle importante es que posee transparencia con el fondo y posee efectos especiales al utilizar los botones. ¿Qué más se puede pedir?

El aspecto que presenta es el siguiente:

Modo normal

Modo Mayúsculas

Modo Símbolo

El modo de utilizarlo es muy sencillo. El código para el ejemplo es el siguiente:

El ejemplo parte de que el componente está en la misma carpeta que la aplicación. Si no fuese así, habría que hacer el "import" correspondiente.

El ejemplo es muy sencillo: en una caja de texto escribiremos parte de un texto. Cuando se pulse el botón "Teclado" aparecerá el el teclado virtual con el texto escrito. En ese momento se modificará el texto con este teclado. Al darle al botón "Aceptar", el nuevo texto aparecerá en la caja de texto. Si se cerrase la ventana con el botón de cierre, mostrará un texto indicando que el texto no fue aceptado, y no habrá cambio alguno.

El componente KeyboardWindow es un "TitleWindow" o PopUp. Hay que importar la clase PopUpManager y declarar una variable de este tipo KeyboardWindow:

import mx.managers.PopUpManager;
import mx.controls.Alert;

private var wKeyboard:KeyboardWindow;

Cuando el usuario haga click sobre el botón "Aceptar" se ejecutará la función "showKeyboard()":

private function showKeyboard():void {
  wKeyboard = KeyboardWindow(PopUpManager.createPopUp(
    this, KeyboardWindow, true));

  wKeyboard.addEventListener(Event.REMOVED, checkText);
  PopUpManager.centerPopUp(wKeyboard);
  wKeyboard.setText(myText.text);
}

La primera sentencia crea la ventana emergente (PopUp), indicando cual es el contenedor padre (this o la propia aplicación), así como de qué tipo es la ventana hija (KeyboardWindow).

La segunda sentencia agrega el evento Event.REMOVED que permite escuchar cuándo la ventana emergente se cierra, enviando la ejecución del código a la función checkText.

La tercer sentencia se encarga de centrar la ventana emergente dentro del contenedor (en nuestro caso, la aplicación).

La cuarta sentencia le pasa al teclado virtual el texto que tenemos en la caja de texto, para su gestión.

Por último, queda la función checkText(), cuyo código es el siguiente:

private function checkText(e:Event):void {
  if (wKeyboard.action==wKeyboard.ACTION_OK)
    myText.text = wKeyboard.getText();
  else if (wKeyboard.action==wKeyboard.ACTION_CANCEL)
    Alert.show("Texto no aceptado");
}

El componente KeyboardWindow tiene una variable que contiene el estado o acción realizada antes de cerrar la ventana. Si se hizo click sobre el botón "Aceptar", el estado será ACTION_OK. Si se hizo click sobre el botón de cierre de la ventana, la acción o estado será ACTION_CANCEL. En el primer caso, se recogerá el texto gestionado por el teclado virtual mediante el método getText(), y se colocará en la caja de texto principal. En el segundo caso, se mostrará una alerta indicando que el texto no fue aceptado.

El aspecto final de este ejemplo es el siguiente:

Para ejecutar el ejemplo en directo:
http://www.tecnillusions.com/demos/DemoKeyboard/DemoKeyboard.html

Para descargar el componente y el código fuente:
http://www.tecnillusions.com/demos/DemoKeyboard/DemoKeyboard.zip

¿Razones para apostar por la tecnología OLED?

2009-10-17T13:44:00.000+02:00

Sólo una:

Software por la patilla

2009-10-16T08:37:00.013+02:00

OFICINA

MindRaider: Excelente gestor de ideas, a modo de mapa conceptual. Disponible para Windows y Linux.

PDF Creator: Permite convertir cualquier documento en formato PDF. Para ello, imprimir el documento seleccionando PDFCreator como impresora. Para Windows.

MULTIMEDIA

Gom Player: Fantástico reproductor multimedia para Windows, que incluye la mayor parte de codecs para vídeos y música.

Irfanview: Excelente visor de imágenes y reproductor de vídeos, que tiene en su haber el contar con el mayor catálogo de formatos. Para Windows.

PROGRAMACION

Aptana Studio: Increíble entorno (IDE) de desarrollo basado en eClipse, y que permite desarrollar en Java, Ruby on Rails, AIR (Adobe), HTML, CSS, Python, PHP, Ajax y Javascript. Disponible en Windows, Linux y Mac.

UTILIDADES

Defraggler: Una utilidad imprescindible. Permite organizar y ordenar (defragmentar) los datos en el disco duro. A medida que se usa el ordenador, la información se va degradando y haciéndose más lento. Defragmentar el disco permite acceder más rápidamente a la información y realizar menos accesos. Para Windows.

Nexus: Nexus añade un dock al escritorio de Windows. Esto es una herramienta muy útil que permite, entre otras cosas, tener a mano los iconos más utilizados y les permite añadir efectos especiales, o cambiar el aspecto completo del escritorio y de los elementos de ventana (hay varios temas).

FBackup: Potente y sencilla herramienta para realizar copias de seguridad de cualquier unidad de almacenamiento, permitiendo comprimir la copia y protegerla con contraseña. Para Windows.

MBR Wizard: Utilidad para recuperar el Master Boot Record (o gestor de arranque) del disco duro, en el caso de que esté corrupto, permitiendo definir la partición activa.

SEGURIDAD

Avast Antivirus Protection: Completa solución contra virus, rookits, troyanos y P2P. La versión gratuita está disponible para Windows y Linux.

INTERNET

Opera: Para mí, el navegador más innovador de todos, además del más rápido y eficaz, capaz de cargar páginas hechas específicamente para Explorer y para Firefox. Para Windows, Linux, Mac y Mobile.

Digsby: Cliente de mensajería que permite conectar con todas los protocolos y redes existentes, incluyendo correo electrónico y redes sociales. Todo en uno. Para Windows.

TI Facturas v2009 ha sido liberado como Freeware

2009-10-14T07:32:00.003+02:00

TI Facturas ahora es completamente funcional, sin limitaciones Y GRATIS. Puede descargarse la versión completa con total libertad, y poder utilizarla en entornos de producción y sin limitaciones de tiempo, máquinas o usuarios. Únicamente, no incluye soporte ni garantía, que puede ser contratado de manera opcional.

TI Facturas es el software imprescindible e ideal para que cualquier PYME o cualquier trabajador autónomo pueda gestionar de forma sencilla y económica sus presupuestos y facturas. Se ha optimizado al máximo la sencillez del programa, para que empezar a trabajar con él no sea un reto, y que el día a día sea algo natural y no consuma mucho tiempo, el cual se requeriría o se aprovecharía para otras actividades más importantes.

Para más información y descarga:

http://www.tecnillusions.com/TIFacturas/principal.html

Flex/AIR: Reemplazar datos en tiempo de visualización

2009-10-13T18:23:00.008+02:00

Hay ocasiones en las que ha de tratarse los datos que se van a visualizar. Por ejemplo, imaginemos una tabla en la que se visualiza los datos recogidos de una consulta, pero el valor de cierto campo posee datos que puedan ser ambiguos, tales como un número (códigos, por ejemplo) o valores true/false. Los datos son almacenados así en el origen de datos, pero mostrarlos al usuario puede ocasionarle confusión. En estos casos sería de gran utilidad poder definir qué valores se van a visualizar (como el texto correspondiente a cada código o un texto en lugar de true o false).

Aunque este post vaya dirigido al DataGrid y el AdvancedDataGrid, sirve también para otros componentes que muestren la información basada en un ArrayCollection, tales como una lista, un combo o un Tree.

Flex/AIR nos permite controlar el modo en que se van visualizando los datos a partir de la colección de datos. Esto se puede controlar gracias a la propiedad labelFunction, que estos componentes.

El funcionamiento es muy sencillo. Se indica en esta propiedad el nombre de una función o método que se ejecutará cada vez que trate el dato (en cada fila y columna en el caso de los DataGrid). En la definición del correspondiente DataGridColumn o de AdvancedDataGridColumn (el que contenga la revisión de la información a tratar). Ejemplo:

<mx:AdvancedDataGridColumn
  dataField="product_raw"
  labelFunction="replaceValuesColumn"/>

La función se definiría así:

private function replaceValuesColumn(
  item:Object, column:AdvancedDataGridColumn):String
{
  // Código que tratará cada dato
}

Los parámetros dependerán de cada tipo de componente. En el caso de un DataGrid, el parámetro 'column' será de tipo DataGridColumn. Las listas no tienen este parámetro.

Esta función se lanzará cada vez que el DataGrid (en este caso) vaya a rellenar esa columna en la fila actual. Aquí se evaluará los valores y, en consecuencia, decidir qué dato visualizar, el cual será indicado en el return de la función en formato String. En nuestro caso, el campo' product_raw' contiene los datos true o false, que indican si el producto es un ingediente o un producto elaborado.

El código a utilizar dentro en la función 'replaceValuesColumn' (se puede dar el nombre que uno quiera) sería el siguiente:

private function replaceValuesColumn(
  item:Object, column:AdvancedDataGridColumn):String
{
  var result:String="";
  if (item.product_raw==true)
    result="Ingrediente";
  else if (item.product_raw==false)
    result="Elaborado";

  return result;
}

Resumiendo: los componentes, a la hora de rellenar cada dato en el componente, permiten utilizar una función para el tratamiento específico de dicho dato. Dicha función evalúa el dato y devuelve el valor que se ha de utilizar para visualizarlo.

En el caso de un AdvancedDataGrid, si hace uso de un agrupamiento, el tratamiento del item se complica, pues la estructura interna a la hora de agrupar varía.

Como ejemplo vamos ver el siguiente AdvancedDataGrid:

En este caso tenemos un agrupamiento por el campo "name_product_type" (tipo de producto), y además un campo resumen (Total). Al depurar la función, veremos que cuando se trata del agrupamiento, se crea un nivel de colección children con los datos del item en su interior, mientras que si trata directamente las filas de datos (ya agrupadas), este nivel no existe. Para tratar este caso, el código a utilizar sería el siguiente:

private function replaceValuesColumn(
  item:Object, column:AdvancedDataGridColumn):String
{
  var result:String="";

  try {
    if (item.product_raw==true)
      result="Ingrediente";
    else if (item.product_raw==false)
      result="Elaborado";
  }
  catch (e:Error) {
    if (item.children[0].product_raw==true)
      result="Ingrediente";
    else if (item.children[0].product_raw==false)
      result="Elaborado";
  }

  return result;
}

Flex/AIR: Estilos personalizados para Alert

2009-10-12T22:36:00.008+02:00

Los diálogos Alert de Flex/AIR no son componentes propiamente dichos, si no un objeto previamente definido por defecto en la interfaz de usuario, que se muestran como un PopUp. Este tipo de diálogo hereda los mismos atributos de visualización que el contenedor padre que lo invoca.

Es posible modificar sus atributos mediante CSS, de la siguiente manera:

<mx:Style>
  .alertTitle{
    color:#aaaaff;
    fontWeight:bold;
  }
  Alert {
    backgroundColor:#AAAAAA;
    backgroundAlpha: 0.8;
    color: #aaaaff;
    borderColor: #000000;
    borderAlpha: 0.8;
    headerHeight:25;
    themeColor: #666666;
    titleStyleName:alertTitle;
    dropShadowEnabled:true;
    shadowDirection:right;
    cornerRadius:10;
  }
</mx:Style>

Pero para que funcione, estos estilos no se deben definir desde un componente, si no desde la aplicación principal (Application en el caso de Flex, y WindowedApplication en el caso de AIR). Los estilos definidos aquí para Alert serán válidos para todos los Alert de la aplicación, en cualquier componente contenido.

Para más información sobre estilos que se pueden aplicar:
http://www.cristalab.com/tips/personalizar-diseno-del-componente-alert-de-flex-con-css-c47959l/

Molinux Zero: una pequeña maravilla

2009-10-11T21:07:00.002+02:00

Tengo mi viejo portátil Pentium III con unos 500 Mhz de velocidad, y con apenas 128 MB RAM. Si bien mi inglés es bueno y mis conocimientos sobre Linux son un poco avanzados, he decidido delegar este equipo a mi hija, con 8 años, para que comience a aprender a utilizar el ordenador y usarlo para sus deberes del colegio.

Ya Windows 95 (el sistema original de este equipo) era un poco pesado, y, sobre todo inextable. Windows XP es mejor ni pensarlo, si no quieres morir con sobredosis de cafeína tomando un café entre clic de botón y que empiece a funcionar algo.

La solución es Linux, con un entorno gráfico y con herramientas de Office y de escritorio con lo que poder empezar a adentrarse en este mundillo. Eso sí: en castellano.

Encontrar una distribución Linux muy, muy ligera, sencilla y por ende en castellano, se convierte en una tarea un tanto difícil. Las opciones son aquellas que tengan un escritorio ligero, tales como FluxBox, XFCE o LXDE. La lista se reduce considerablemente. Xubuntu es una distro que funciona muy bien, y, desde luego, la recomiendo.

Pero probé Molinux Zero, por curiosidad, y me ha encantado por su velocidad y por la cantidad de recursos con los que cuenta, con apenas 100 MB de ISO, y que es un "Puplet" o derivado de la distribución "Puppy". Podéis encontrar esta distro en la siguiente URL:

http://ceslcam.com/molinux/ver-categoria.html

La distro es un live-CD, que solicitará en su inicio algunos parámetros de configuración, como el idioma, el teclado, la resolución de pantalla, el ratón... Una vez cargado en memoria, impresiona la velocidad a la que se ejecuta, incluso funcionando con un docklet en la parte superior (similar a la del MacOS X), y con unos widgets en la parte derecha, similar a la del Windows Vista.

Tiene multitud de opciones de configuración, así como aplicaciones de escritorio, de red, de seguridad, diseño gráfico, internet, multimedia, etc.

Os recomiendo bajaros y probar on live esta distribución. Merece la pena darle una segunda oportunidad a ese viejo ordenador.

Jugar al Spectrum online sin emulador

2009-10-05T10:36:00.007+02:00

Los nostálgicos estamos de enhorabuena. Por fin podemos jugar a los juegos del Spectrum sin necesidad de instalarnos ningún software emulador, gracias a una pequeña maravilla. En la siguiente URL:

http://www.zxspectrum.net

Podemos encontrar un emulador online realizado en Java, en el que podremos cargar cientos de juegos (a la izquierda) del mítico Spectrum. Además, podemos escribir nuestros programillas en Basic o en ensamblador, pues la consola está disponible. ¿A qué esperas para echarte una pachanga?

Flex/AIR: Imágenes en DataGrid

2009-10-03T14:06:00.005+02:00

El ejemplo que hoy nos ocupa es muy sencillo y no pretende ambiciosos objetivos. Básicamente, permitirá a un DataGrid visualizar una imagen en una determinada celda que va vinculado al valor que lo contiene. Aunque esta entrada esté dedicada a un DataGrid, lo mismo puede aplicarse a las listas.

Para ilustrar el ejemplo, vamos a ver una captura del resultado final:

Como puede observarse, la columna Type (tipo) visualiza el tipo de lote (batch) mediante un simple gráfico: entrada (verde) o salida (rojo).

No voy a exponer cómo cargar los datos en el DataGrid, pues aquí, lo que nos ocupa es precisamente cómo cargar esas imágenes dependiendo del valor de la columna.

En este caso, sólo hay dos valores posibles, por lo que en la tabla de la base de datos sólo almacena en el campo "input_batch" los valores true o false, y para los mismos valores se han creado dos imágenes de 20x20, llamadas "true.png" y "false.png".

Por defecto, los DataGrids y las listas muestran la información en formato texto. Pero Flex/AIR puede permitir representar la información en formato gráfico. Para ellos existen lo que se denominan renderers (presentadores). Existen varios tipos de renderers, como cellRenderer o itemRenderer. Para nuestro ejemplo vamos a utilizar un itemRenderer de forma muy sencilla:

<mx:DataGrid id="dgBatches"
  dataProvider="{batchesList}"
  left="18" right="18" top="50" bottom="18">

  <mx:columns>
    <mx:DataGridColumn dataField="date" headerText="Date" width="80"/<
    <mx:DataGridColumn dataField="id_batch" headerText="Batches"/>
    <mx:DataGridColumn dataField="input_batch" headerText="Type" width="50">
      <mx:itemRenderer>
        <mx:Component>
          <mx:HBox width="100%" horizontalAlign="center">
            <mx:Image source="/resources/batches/{data.input_batch}.png" />
          </mx:HBox>
        /mx:Component>
      </mx:itemRenderer>
    </mx:DataGridColumn>
  </mx:columns>
</mx:DataGrid>

El punto clave está en la columna "input_batch", la cual recoge el tipo de lote (entrada (true) o salida (false). Esta columna contiene un elemento de tipo "itemRenderer", que es el encargado de presentar el valor de dicha celda. En su interior se crea un componente simple, compuesto únicamente por un HBox como contenedor, y como contenido tendrá una imagen que apuntará a la imagen a cargar. En este caso se encuetra en el directorio "/resources/batches/" y el nombre del archivo es el propio valor del campo (data.input_batch" con la extensión ".png".

Este mismo ejemplo podría servir para cargar imágenes ya predefinidas, en lugar de dos valores únicos de tipo true/false. También podrían residir en una URL concreta en lugar de en el disco duro.

Los renderers son muy flexibles y potentes, y permiten también introducir elementos de interfaz de usuario, como listas desplegables, campos numéricos, de texto, checkboxes, etc.

Flex/AIR: Eventos personalizados

2009-09-30T19:34:00.007+02:00

La dinámica de desarrollo en Flex está orientada a crear componentes independientes lo más atomizado posible, con el fin de componer interfaces ricas de forma ergonómica e independiente, lo que además, permite aislar problemas concretos dentro de las interfaces, además de contribuir a la reutilización de los mismos.

Para entender un poco mejor el párrafo anterior imaginemos una interfaz típica en la que hay un grid con el conjunto de datos, y además una ficha de registro. Podemos pensar en realizar todo en un mismo contenedor, ya sea en la misma visualización, activando desactivando opciones según se requieran, o bien crear estados para activar o desactivar el modo lista o el modo ficha.

Para ir un poco más finos, se puede crear un componente lista que se encargue de forma exclusiva de presentar los datos en un DataGrid, y operar con unos filtros para búsquedas más concretas de información.

Para ser lo más interactivos posibles, habría un botón "Agregar" para añadir un nuevo registro, con lo que presentaría la ficha vacía. Para editar o eliminar un dato concreto, cuando el usuario haga clic sobre una fila determinada se mostraría la ficha con los datos.

El componente ficha aparecería cuando se pulse el botón "Agregar" en modo edición y vacío. Si se hace clic sobre una fila, aparecería en modo visualización, con la opción de editarlo o eliminarlo. Como acciones tendría "Guardar", "Eliminar", "Cancelar" y "Cerrar". Su objetivo es tratar individualmente los datos de un registro específico.

El contenedor padre únicamente insertaría estos componentes y realizar las relaciones entre ambos según se requieran, pero los objetivos concretos están dentro de cada componente, y en el caso de depurar, corregir, modificar o agregar funcionalidades, el nivel de aislamiento permite claramente "tocar" sólo la parte responsable.

Espero que con este planteamiento esté claro la organización de una funcionalidad clásica de tratamiento y gestión de datos.

Ahora bien, un pensamiento típico para aquel que empieza a desarrollar con componentes es crear las relaciones con elementos (propiedades, variables o métodos) públicos). Esto, además de complicar el desarrollo, la sincronización entre las partes estaría forzada de forma implícita por código, lo que haría un sistema un tanto inestable e inseguro, amén de sacrificado por el esfuerzo que requiere después modificaciones o correcciones. A esto se le denomina acoplamiento fuerte, y todo depende de otras acciones u operaciones.

Es posible hacer más sencillo este desarrollo realizando un acoplamiento débil, y que no sea todo tan dependiente y preocuparnos de las relaciones cuando deban ocurrir, y de una forma menos forzosa. Para ello, podremos definir nuestros propios eventos en los componentes, y a través de ellos pasar información (como los datos de una fila o la acción a emprender).

Para empezar, recomiendo utilizar dos clases en ActionScript. La primera de ellas será una clase para almacenar la información que se pasará al evento, como los datos de la fila seleccionada o la acción solicitada por el usuario. Puede declararse en la carpeta o paquete que uno requiera.

package com.agenda
{
  public class Agenda
  {
    public static const ACTION_NEW:int=0;
    public static const ACTION_SELECT:int=1;
    public var accion:int;
    public var nombre:String;
    public var direccion:String;
    public var telefono:String;

    public function Agenda()
    {
      accion=ACTION_NEW;
      nombre="";
      direccion="";
      telefono="";
    }

    public function toString():String
    {
      return "accion:"+accion+"|"+
        nombre+"|"+
        direccion + "|" +
        telefono;
    }

  }
}

Básicamente define los campos, un constructor por defecto (con una carga inicial de datos) y un método toString() que muestra la información de la instancia actual.

La segunda clase define el evento personalizado, y para ello se crea una clase que hereda de la superclase base Event y, al igual que la otra clase, podemos colgarla del paquete que creamos más oportuno (en este caso en el mismo paquete que la anterior):

package com.agenda
{
  import flash.events.Event;

    public class AgendaEvent extends Event
    {
      public var agenda:Agenda;

      public function AgendaEvent(agenda:Agenda, type:String)
      {
        super(type);
        this.agenda=agenda;
      }

      public override function clone():Event {
        return new AgendaEvent(agenda, type);
      }
    }
}

La clase Event es la clase básica para cualquier evento, y por ello, esta clase hereda (extiende) aquella, añadiendo una funcionalidad propia. En primer lugar se crea una propiedad que contiene un objeto de tipo Agenda (definido en la clase anterior), conteniendo la información necesaria. A continuación se crea un constructor especial, en donde se pasa el objeto Agenda a tratar y el tipo de evento a construir (que será de este tipo). El constructor invoca a su superclase indicando este tipo, y asigna la información al objeto Agenda.

Se sobreescribe el método clone(), el cual crea y devuelve un objeto evento de sí mismo (mejor no entremos en detalle, pero es un punto importante a implementar).

El siguiente paso será ir al componente que va a generar el evento, en nuestro caso al componente del DataGrid, que es el que contiene la lista de datos. En este componente hay que declarar el evento para que sea visible por el resto de componentes que lo utilicen. Para ello, hay que crear este código justo después del comienzo de la declaración del componente (el contenedor que lo forma. Canvas, HBox, VBox...), que sea el primer código del mismo (no es esencialmente así, pero sí recomendable):

<?xml version="1.0" encoding="utf-8"?>
<mx:Canvas
xmlns:mx="http://www.adobe.com/2006/mxml"
width="450"
height="400"
>


<mx:Metadata>
[Event(name="selectAgenda",type="com.agenda.AgendaEvent")]
[Event(name="addAgenda",type="com.agenda.AgendaEvent")]
</mx:Metadata>

  ...

</Canvas>

El bloque Metadata declara dos eventos para este componente:
- selectAgenda -> cuando el usuario hace clic sobre una fila del DataGrid
- addAgenda -> cuando el usuario hace clic sobre el botón "Agregar"

Ambos eventos son del tipo AgendaEvent.

Esta parte sólo declara los eventos, para que sea visible por el componente padre que utiliza a éste (se puede probar a insertar el componente y con Ctrl+Espacio extraer las propiedades y métodos de este componente, donde aparecerán estos dos eventos). En realidad la declaración no hace que se produzcan, pues hay que controlar cuándo y cómo se lanzan estos dos eventos.

El primero de ellos se lanza cuando el usuario hace clic sobre una fila del DataGrid. Para ello, se captura el evento de la selección:

<mx:DataGrid id="dgAgenda"
  itemClick="selectItemAgenda();"
  ...

El código correspondiente para despachar el evento "selectAgenda" es el siguiente:

private function selectItemAgenda():void
{
  var miAgenda:Agenda = new Agenda();
  miAgenda.action = Agenda.ACTION_SELECT;
  miAgenda.nombre = dgAgenda.selectedItem.nombre;
  miAgenda.direccion = dgAgenda.selectedItem.direccion;
  miAgenda.telefono = dgAgenda.selectedItem.telefono;
  var e:AgendaEvent = new AgendaEvent(agenda, "selectAgenda");
  this.dispatchEvent(e);
}

Se instancia la clase Agenda para almacenar la información que se va a utilizar en el componente principal o padre. La información se extrae del DataGrid (dgAgenda), de la fila actualmente seleccionada (selectedItem) y de cada uno de los campos definidos en el DataGrid (nombre, direccion y telefono).

A continuación se crea un objeto de tipo evento AgendaEvent, pasando esta información, y dando el nombre del evento "selectAgenda" que ya fue declarado (bloque MetaData). Por último, se despacha el evento (dispatchEvent), que saltará en el componente padre cuando éste se produzca.

Para el evento addAgenda el código es similar. Al hacer clic sobre el botón se invoca al método que despachará el evento:

<mx:Button id="btnAdd" click="addItemAgenda();" />

El código a implementar sería el siguiente:

private function addItemAgenda():void
{
  var agenda:Agenda = new Agenda();
  var e:AgendaEvent = new AgendaEvent(agenda, "addAgenda");
  this.dispatchEvent(e);
}

Cuando el usuario haga clic sobre el botón "Agregar" se creará el evento "addAgenda", que será lanzado hacia los componentes padre que utilicen este componente.

Ahora queda la parte en que estos eventos son capturados por el componente padre o que contiene a este componente. He de reconocer que me volví un poco loco porque creí que no me funcionaba todo lo anterior, ya que al incrustar el componente del DataGrid dentro del componente principal, al intentar ver los eventos, métodos y propiedaes con Ctrl+Espacio en el editor de Flex, no me aparecía nada. Incluso traté de declarar el evento para lanzar un método simple o lanzar un Alert, pero no funcionaba. Si esto os ocurre os contaré por qué.

Utilizo un paquete específico para los componentes. Si se ubica un componente en un paquete o carpeta distinto al del componente padre, parece no verlo, aunque se especifique la ruta completa de forma implícita y se vea el componente y aparentemente funciona (recoge datos y los visualiza, e incluso funciona el filtro). Pero los eventos no funcionaban. Al final, he ubicado todos los componentes, tanto padres e hijos en el mismo paquete, y así iba bien. Estoy de acuerdo que esta explicación no puede ser del todo convincente, pero el hecho es que así me funcionó a mi.

Ahora, en el componente padre, cuando se incrusta el componente hijo, al dar el espacio y al pulsar las teclas Ctrl+Espacio, se verán los eventos declarados y dispuestos para ser utilizados:

<components:ListaAgenda
  selectBatch="doSelectAgenda(event);"
  addBatch="doAddAgenda(event);"
/>

Al enviar el parámetro "event", éste contendrá la información contenida:

private function doSelectAgenda(e:AgendaEvent):void {
  Alert.show("Evento selectAgenda: " + e.agenda.toString());
}

private function doAddAgenda(e:AgendaEvent):void {
  Alert.show("Evento addAgenda: " + e.agenda.toString());
}

Espero que este tutorial básico sobre eventos personalizados os sea de utilidad.

Flex/AIR: filtros de datos

2009-09-30T15:58:00.014+02:00

Es muy habitual tener una colección de datos en nuestras interfaces de usuario. Cuando ésta es muy numerosa, es conveniente facilitar al usuario de medios para poder acceder más rápida y directa a una información concreta, y para ello se aplican filtros.

En el ejemplo que voy a exponer utilizaré un DataGrid, que es uno de los elementos de interfaz más utilizados para presentar colecciones de datos. Lo mismo puede aplicarse a otros elementos de interfaz, como las listas o AdvancedDataGrids.

Antes de iniciar el cómo vamos realizar un planteamiento. La mayor parte de las veces, los datos provendrán de fuentes externas o remotas, como un fichero, un HTTPService o un WebService. La invocación a un servicio de datos remoto, normalmente se obtiene en formato e4x, para poder trabajar cómodamente en XML. Pero este sistema carece de la cualidad de filtrar o realizar búsquedas concretas. Se puede realizar filtros manualmente e invocar a los servicios de datos con los parámetros del filtro, pero esto implicaría desperdiciar muchos recursos, ya que cada filtrado es una invocación remota (una llamada a un servicio remoto), con el tiempo que esto conlleva, ejecutar el código de invocación, carga y visualización de datos.

Así pues, nos queda otra opción: obtener la información y almacenarlo en un ArrayCollection, que posee métodos para filtrado y que puede ser enlazado a elementos de interfaz de usuario. En este caso, los datos son los mismos que en la primera carga, e internamente, en memoria, se realiza el filtrado, por lo que es mucho más óptimo en recursos (tiempo, ejecuciones, memoria, etc.)

Para ello, se define un ArrayCollection en la región dedicado al ActionScript (<mx:Script>...</mx:Script>):

[Bindable]
private var miAC:ArrayCollection;

En este post se pondrá un ejemplo con un HTTPService, que es el método más habitual de obtener la información. Recordemos que HTTPService invoca a una URL donde se retornará una fichero XML formado con un nodo padre y con varios hijos en forma de lista (cada uno como un registro o fila del DataGrid). Esta invocación puede realizarse a una página ASP, JSP, PHP, Servlet, etc, que en lugar de retornar una página web retorne un XML. También puede ser una URL con un fichero XML.

<mx:HTTPService
  result="handleResultMetodo(event);"
  fault="handleFaultMetodo(event);"
  id="nombreServicio" resultFormat="object"
  url="URLHTTPService"
  useProxy="false">
  <mx:request xmlns="">
    <nombreParametro>valorParametro</nombreParametro>
    ...
  </mx:request>
</mx:HTTPService>

Los parámetros a utilizar son:
- result -> Nombre del método que gestionará el resultado de la invocación
- fault -> Nombre del método que se ejecutará en caso de haber un error en la invocación
- id -> Nombre que se da al servicio
- url -> URL donde se encuentra el XML (ASP, JSP, PHP, Servlet, fichero XML...)
- resultFormat -> Formato del resultado. En este caso se ha usado un tipo "object" para que sea recogido por el ArrayCollection. En casos normales se utiliza el formato "e4x" que permite gestionar cómodamente cualquier XML.

El bloque mx:request es opcional, y se utiliza en el caso de que el recurso XML requiera de parámetros de entrada para formar el XML resultante.

En algún momento determinado del ciclo de vida de la aplicación, se invocará al HTTPService para recoger el XML con los datos. Habitualmente se realiza en el método creationComplete de la aplicación, o del componente Flex. En algunas ocasiones se realiza en respuesta a algún evento (como un clic sobre un botón). El código que realiza la invocación sería el siguiente:

nombreServicio.send();

Una vez invocado el servicio HTTPService generará un resultado (en caso de ir bien) o bien un error (en caso de ir mal). En ambos casos se invocará a los métodos respectivos declarados:

private function handleResultMetodo(event:ResultEvent):void
{
  miAC = event.result.elementoPadre.elementoHijo;
}

private function handleFaultMetodo(event:FaultEvent):void
{
  Alert.show(event.fault.faultString, "ERROR");
}

Cuando la invocación ha sido exitosa se ejecutará el primer método, pasando en el parámetro "event" el resultado del XML. Para agregar este XML en el ArrayCollection, hay que acceder a la propiedad "result" del mismo, e indicar cuál es el elemento padre y cuál el elemento hijo (registro o fila). Por ejemplo, un XML con esta estructura:

<?xml version="1.0" encoding="ISO-8859-1" ?>

<producto>
  <item>
    <codigo>1</codigo>
    <nombre>Boligrafo negro</nombre>
    <precio>1.25</nombre>
  </item>
  <item>
    <codigo>2</codigo>
    <nombre>Boligrafo azul</nombre>
    <precio>1.50</nombre>
  </item>
  <item>
    <codigo>3</codigo>
    <nombre>Boligrafo rojo</nombre>
    <precio>1.75</nombre>
  </item>
<producto/>

El elemento padre sería "producto", y el elemento hijo sería "item". El ArrayCollection contendría 3 registros (uno por cada elemento hijo), y cada uno de estos registros sería una fila en el DataGrid.

El ArrayCollection está cargado en este momento con la información. El ArrayCollection definido es enlazable (tiene la propiedad Bindable), lo que permite o un control visual, como un DataGrid o un List, enlazarse a los datos de este ArrayCollection, y cada cambio en áquel actualiza automáticamente los datos del control.

El DataGrid se define así:

<mx:DataGrid
  id="miDataGrid">
  DataProvider="{miAC}">
    <mx:DataGridColumn dataField="codigo" headerText="CODIGO" />
    <mx:DataGridColumn dataField="nombre" headerText="NOMBRE" />
    <mx:DataGridColumn dataField="precio" headerText="PRECIO" />
</mx:DataGrid>

El control DataGrid es un control de datos en forma de tabla. El atributo "id" define el nombre para el DataGrid. El elemento "DataProvider" indica al DataGrid de dónde debe obtener los datos. En este caso, se indica entre llaves el nombre del ArrayCollection para que se lleve a cabo el enlace automático.

El DataGrid tiene tres columnas, que se definen con "DataGridColumn". El atributo "dataField" especifica el campo de donde va a obtener el valor ("codigo", "nombre" o "precio", definidos en el XML). El atributo "headerText" define el título que aparecerá en la cabecera superior de cada columna.

Ahora viene la parte interesante, y es el filtro. Para ello, se definen controles de usuario, como una caja de texto, una lista desplegable o un calendario para obtener una fecha. En cualquiera de los casos utilizados, se ha de invocar a una método cuando el valor de estos controles cambia (el que aplique según el caso). En este caso, vamos a poner que haya sido un campo de texto y un botón de anulación:

<mx:TextInput id="txtBuscar" change="buscarMetodo()" />
<mx:Button label="Reiniciar" click="reiniciarMetodo()" />

En el caso de que se introduzca un carácter en la caja de texto se producirá un cambio, que recogerá el evento "change", y aquí le indicamos que ejecute el método
buscarMetodo(), el cual contiene el siguiente código:

private function buscarMetodo():void {
  miAC.filterFunction = filtroMetodo;
  miAC.refresh();
}

El ArrayCollection tiene una propiedad que se encarga de la gestión de filtrado de los datos que contiene. Para ello, delega en un método que especifica cómo llevar a cabo este filtrado, y el cual, su nombre se especifica a esta propiedad, en este caso, "filtroMetodo". Este método contendrá el siguiente código:

private function filtroMetodo(item:Object):Boolean{
  var encontrado:Boolean = false;
  if(item.nombre.toLowerCase().search(txtBuscar.text.toLowerCase()) != -1){
    encontrado = true;
  }
  return encontrado;
}

El ArrayCollection ejecutará este método por cada fila que contiene, enviando en el objeto "item" la fila que se está procesando. Aquí se compara la fila ("item") y el campo a comparar (en este caso "nombre"), anmbos igualados en minúsculas. En caso de que case esta comparación se retorna un valor true (se muestra) o en caso contrario retorna un valor false (no se muestra).

Otra forma de comparación sería así:

private function filtroMetodo(item:Object):Boolean{
  var encontrado:Boolean = true;
  var filter:String = item["nombre"]; // valor del campo "nombre"
  if(filter.toLowerCase().indexOf(txtBuscar.text.toLowerCase())<0){
    encontrado = false;
  }
  return encontrado;
}

Una vez se ha procesado todas las filas e identificadas cuáles cumplen los requisitos del filtro, la siguiente sentencia:

  miAC.refresh();

Para anular los filtros y que el ArrayCollection (y por ende, el DataGrid) contenga toda la información, hay que anular la propiedad "filterFunction" y refrescar el Arraycollection:

private function reiniciarMetodo():void {
  miAC.filterFunction = null;
  miAC.refresh();
}

Refresca o actualiza el contenido del ArrayCollection, propagándose automáticamente hacia el DataGrid que actualizará la información a mostrar.

Un ejemplo muy sencillo es el siguiente:

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical" creationComplete="initData()">
<mx:Script>
<![CDATA[
import mx.collections.ArrayCollection;
[Bindable]
private var dataList:ArrayCollection ;

private function initData():void{
dataList= new ArrayCollection([
{name:"Atlantic City Medical Center-City Division", city:"Atlantic City"},
{name:"Atlantic City Medical Center-Mainland Division", city:"Pomona "},
{name:"Barnert Hospital", city:"Paterson"},
{name:"Bayonne Medical Center", city:"Bayonne"},
{name:"Bayshore Community Hospital", city:"Holmdel"},
{name:"Bergen Regional Medical Center. L.P.", city:"Paramus"},
{name:"Burdette Tomlin Memorial Hospital", city:"Cape May"},
{name:"Capital Health System - Fuld Campus", city:"Trenton"},
{name:"Capital Health System - Mercer Campus", city:"Trenton"},
{name:"CentraState Healthcare System", city:"Freehold"},
{name:"Chilton Memorial Hospital", city:"Pompton Plains"},
{name:"Christ Hospital", city:"Jersey City"},
{name:"Clara Maass Medical Center", city:"Belleville"},
{name:"Columbus Hospital", city:"Newark"},
{name:"Community Medical Center", city:"Toms River"},
{name:"East Orange General Hospital", city:"East Orange"},
{name:"Englewood Hospital and Medical Center", city:"Englewood"},
{name:"Hackensack University Medical Center", city:"Hackensack"},
{name:"Hackettstown Community Hospital", city:"Hackettstown"},
{name:"Holy Name Hospital", city:"Teaneck"},
{name:"Hospital Center at Orange", city:"Orange"},
{name:"Hunterdon Medical Center", city:"Flemington"},
{name:"Irvington General Hospital", city:"Irvington"},
{name:"Jersey Shore University Medical Center", city:"Neptune"},
{name:"JFK Medical Center", city:"Edison"},
{name:"Kennedy Memorial Hospitals/UMC Cherry Hill", city:"Cherry Hill"},
{name:"Kennedy Memorial Hospitals/UMC Stratford", city:"Stratford"},
{name:"Kennedy Memorial Hospitals/UMC Washington Twp", city:"Turnersville"},
{name:"Kessler Memorial Hospital", city:"Hammonton"},
{name:"Kimball Medical Center", city:"Lakewood"},
{name:"LibertyHealth-Greenville Hospital Campus", city:"Jersey City"},
{name:"LibertyHealth-Jersey City Medical Center Campus", city:"Jersey City"},
{name:"LibertyHealth-Meadowlands Hospital Campus", city:"Secaucus"},
{name:"Lourdes Medical Center of Burlington County", city:"Willingboro"},
{name:"Monmouth Medical Center", city:"Long Branch"},
{name:"MONOC", city:"Eatontown"},
{name:"Morristown Memorial Hospital", city:"Morristown"},
{name:"Muhlenberg Regional Medical Center", city:"Plainfield"},
{name:"Newark Beth Israel Medical Center", city:"Newark"},
{name:"Newton Memorial Hospital", city:"Newton"},
{name:"Ocean Medical Center", city:"Brick"},
{name:"Our Lady of Lourdes Medical Center", city:"Camden"},
{name:"Overlook Hospital", city:"Summit"},
{name:"Palisades Medical Center-New York Presbyterian ", city:"North Bergen"},
{name:"Pascack Valley Hospital ", city:"Westwood"},
{name:"PBI Regional Medical Center", city:"Passaic"},
{name:"Raritan Bay Medical Center - Old Bridge", city:"Old Bridge"},
{name:"Raritan Bay Medical Center - Perth Amboy", city:"Perth Amboy"},
{name:"Riverview Medical Center", city:"Red Bank"},
{name:"Robert Wood Johnson Univ Hospital", city:"New Brunswick"},
{name:"Robert Wood Johnson Univ Hospital at Hamilton", city:"Hamilton"},
{name:"Robert Wood Johnson Univ Hospital at Rahway", city:"Rahway"},
{name:"Saint Barnabas Medical Center", city:"Livingston"},
{name:"Saint Clares Hospital/Boonton Township", city:"Boonton"},
{name:"Saint Clares Hospital/Denville", city:"Denville"},
{name:"Saint Clares Hospital/Sussex", city:"Sussex"},
{name:"Saint James Hospital", city:"Newark"},
{name:"Saint Michaels Medical Center", city:"Newark"},
{name:"Saint Peters University Hospital", city:"New Brunswick"},
{name:"Shore Memorial Hospital", city:"Somers Point"},
{name:"Somerset Medical Center", city:"Somerville"},
{name:"South Jersey Healthcare-Bridgeton Hospital", city:"Bridgeton"},
{name:"South Jersey Healthcare-Elmer Hospital", city:"Elmer"},
{name:"South Jersey Healthcare-Newcomb Hospital", city:"Vineland"},
{name:"Southern Ocean County Hospital", city:"Manahawkin"},
{name:"St. Francis Medical Center", city:"Trenton"},
{name:"St. Josephs Regional Medical Center", city:"Paterson"},
{name:"St. Josephs Wayne Hospital", city:"Wayne"},
{name:"St. Mary Hospital", city:"Hoboken"},
{name:"St. Marys Hospital Passaic", city:"Passaic"},
{name:"Summit Hospital", city:"Summit"},
{name:"The Cooper Health System", city:"Camden"},
{name:"The Memorial Hospital of Salem County", city:"Salem"},
{name:"The Mountainside Hospital", city:"Montclair"},
{name:"The Valley Hospital", city:"Ridgewood"},
{name:"Trinitas Hospital", city:"Elizabeth"},
{name:"Underwood-Memorial Hospital", city:"Woodbury "},
{name:"Union Hospital", city:"Union"},
{name:"University Medical Center at Princeton", city:"Princeton"},
{name:"University of Medicine & Dentistry of NJ-Univ Hosp", city:"Newark"},
{name:"Virtua Memorial Hospital Burlington County", city:"Mount Holly"},
{name:"Virtua West Jersey Hospital-Berlin", city:"Berlin"},
{name:"Virtua West Jersey Hospital-Marlton", city:"Marlton"},
{name:"Virtua West Jersey Hospital-Voorhees", city:"Voorhees"},
{name:"Warren Hospital", city:"Phillipsburg"}
])
}

private function filterDemo():void{
dataList.filterFunction = searchDemo;
dataList.refresh();
}

private function searchDemo(item:Object):Boolean{
var isMatch:Boolean = false
if(item.name.toLowerCase().search(search.text.toLowerCase()) != -1){
isMatch = true
}
return isMatch;
}

private function clearSearch():void{
dataList.filterFunction = null;
dataList.refresh();
search.text = '';
}
]]>
</mx:Script>
<mx:Form>
<mx:FormItem label="Search" direction="horizontal">
<mx:TextInput id="search" change="filterDemo()" />
<mx:Button label="Clear Search" click="clearSearch()" />
</mx:FormItem>
</mx:Form>
<mx:DataGrid dataProvider="{dataList}" width="400" height="400">
<mx:columns>
<mx:DataGridColumn headerText="Name" dataField="name" />
<mx:DataGridColumn headerText="City" dataField="city" />
</mx:columns>
</mx:DataGrid>

</mx:Application>

En este caso, la información está en el propio código (por eso es tan extenso), y se carga directamente en el ArrayCollection sin usar un HTTPService. Pero el objetivo principal era demostrar el uso de los filtros.

Este ejemplo (el último) está en el siguiente enlace: http://www.boyzoid.com/blog/index.cfm/2006/10/19/Filtering-Data-in-Flex

Para terminar, indicar que los dos ejemplos expuestos anteriormente se han basado en un único campo, pero lo más normal es que un filtro pueda tener varios campos y se combinen entre sí.

A continuación voy a poner un ejemplo (no completo, si no únicamente en lo que concierne a este punto), con dos campos: uno en una combo y otro en un calendario.

El primero filtra un tipo de lotes. Sus valores pueden ser: * (todos), "I" (entrada o true) y "O" (salida o false).

Los dos campos de filtro, invocan a sus respectivos métodos cuando cambian su valor:

// User click on combo type of batch
private function changeType():void {
  if (cboTipoLote.value!="*" || datLote.text!=null)
    this.batchesList.filterFunction=filterBatches;
  else
    this.batchesList.filterFunction=null;

  this.batchesList.refresh();
}

// User change date on date field
private function changeDate():void {
  if (cboTipoLote.value!="*" || datLote.text!=null)
    this.batchesList.filterFunction=filterBatches;
  else
    this.batchesList.filterFunction=null;

  this.batchesList.refresh();
}

El ArrayCollection está definido en "batchesList".

El método delegado para el filtrado es el siguiente:

// Filter of batches
private function filterBatches(item:Object):Boolean
{
  var match:Boolean = true;
  var sDate:String="";
  var sType:String="";

  if (cboTipoLote.value=="I")
    sType="true";
  else if (cboTipoLote.value=="O")
    sType="false";
  else
    sType="";

  if (datLote.text !="") {
    sDate =""+datLote.selectedDate.fullYear +"-";
    var vValue:String=""+(datLote.selectedDate.month+1);
    if (vValue.length==1)
      vValue = "0" + vValue;

      sDate+= vValue + "-";

      vValue = ""+(datLote.selectedDate.date);
    if (vValue.length==1)
      vValue = "0" + vValue;

      sDate += vValue;
    }
    else
      sDate = "";

    var filter1:String = item["input_batch"];
    var filter2:String = item["date"];

    if (sDate!="" && sType=="") {
      if (!filter2 || filter2.indexOf(sDate)<0)
      match=false;
    }
    else if (sDate=="" && sType!="") {
      if (!filter1 ||
        filter1.toLowerCase().indexOf(sType.toLowerCase())<0)
        match=false;
    }
    else {
      if (!filter1 ||
        filter1.toLowerCase().indexOf(sType.toLowerCase())<0 ||
        !filter2 || filter2.indexOf(sDate)<0)
        match=false;
    }

  return match;
}

En este caso se contemplan 3 casos:
1) Se ha facilitado tipo pero no fecha
2) Se ha facilitado fecha pero no tipo
3) Se han facilitado tipo y fecha

Espero que estos ejemplos sean claros y útiles para desarrollar aplicaciones AIR y Flex más interactivas y optimizadas.

Configurar NetBeans, Tomcat y un pool de conexiones a PostgreSQL

2009-09-25T19:24:00.004+02:00

Este post va dedicado a crear un entorno de desarrollo para aplicaciones web, utilizando el lenguaje Java, la base de datos PostgreSQL y el IDE NetBeans. No me voy a detener en la instalación y configuración de Java ni de PostgreSQL, si no en el entorno en concreto.

PREPARATIVOS
El ejemplo que se ilustra aquí utiliza PostgreSQL 8.3 (http://www.postgresql.org, Java v6u14 (http://java.sun.com), Tomcat 6.0.20 (http://tomcat.apache.org) y NetBeans 6.7.1 (http://www.netbeans.org.

En primer lugar ha de estar instalado el SDK de Java y la base de datos PostgreSQL.

TOMCAT
Ahora, para instalar Tomcat, es preferible descomprimir la versión no instalable, ya que incorpora los archivos catalina.bat y catalina.sh, los cuales son gestionados por NetBeans para lanzar y depurar las aplicaciones. Yo recomiendo, para los usuarios de Windows, instalarlo en el directorio raíz del disco duro, pues en Windows Vista, Windows 7 y Windows Server 2008 utiliza el perfil de usuario para gestiones propias del entorno de sesión, y podría no funcionar.

Una vez instalado Tomcat, acceder al archivo conf/tomcat-users.xml y añadir el usuario administrador y el usuario manager:

<user username="admin" password="admin" roles="tomcat"/>
<user username="manager" password="manager" roles="manager"/>

El siguiente paso es descargarse el driver jdbc de PostgreSQL, el cual puede ser descargado de http://jdbc.postgresql.org. Descargar el driver correspondiente a jdbc3. Una vez descargado el archivo .jar, copiar éste en el directorio lib de Tomcat.

NETBEANS

Configuración del servidor

Una vez instalado NetBeans, hay que agregar el servidor Tomcat. Para ello:
- Menú "Tools" + Opción "Servers"
- Botón "Add Server..." (parte inferior izquierda)
- Seleccionar de la lista "Tomcat 6.0" y botón "Next"
- En el campo "Server Location", hacer clic en el botón "Browse..." y seleccionar la carpeta donde se aloja Tomcat.
- En el campo "Username" ingresar el nombre del usuario "manager"
- En el campo "Password" ingresar la contraseña del usuario "manager"
- Botón "Finish"

El servidor se habrá agregado a la lista de servidores configurados. Al seleccionar este servidor, aparecerán sus propiedades a la derecha. Clic en el botón "Close".

Crear proyecto web

Vamos a crear un proyecto web para configurar el pool de conexiones y mostrar un ejemplo de conexión:
- Menú "File" + opción "New Project..."
- En la lista "Categories" seleccionar "Java Web", y en la lista "Projects" seleccionar "Web Application"
- Botón "Next"
- En el campo "Project Name" dar el nombre del proyecto, por ejemplo "Prueba".
- Botón "Next"
- En el campo "Server" seleccionar "Tomcat 6.0"
- Botón "Finish"

Referencia a la librería de PostgreSQL

Creado el proyecto, lo primero que vamos a hacer es añadir una referencia a la librería de PostgreSQL. Para ello, en el panel "Project" (parte izquierda), aparecerá el proyecto con los diversos elementos del mismo. Hacer clic con el botón derecho sobre "Libraries" y seleccionar "Add JAR/Folder". Navegar hasta el directorio lib de Tomcat y seleccionar el archivo .jar de PostgreSQL. La librería aparecerá en el árbol subyacente.

Configurar pool de conexiones

A continuación vamos a configurar el pool de conexiones. Antes de empezar, comentar que en la versiones recientes de Tomcat, por motivos de seguridad y eficiencia, la configuración de contextos y recursos se realiza por aplicación, y en no en el contexto general de Tomcat. Aclarado ésto vamos a proceder a la configuración.

Desplegar, en el panel de proyecto, el elemento "Web pages" del proyecto. Desplegar ahora el elemento "WEB-INF" y hacer doble clic sobre el archivo "web.xml". Seleccionar ahora el botón "XML" (parte superior de la zona de trabajo), con lo que aparecerá el contenido del archivo. Aquí aparecerá un bloque principal encerrado entre los tags <web-app> y </web-app>. Situarse justo antes del cierre de este bloque y añadir las siguientes líneas:

<resource-ref>
<description>Referencia al pool de conexiones</description>
<res-ref-name>jdbc/[nombreJNDI]</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>

El campo <res-ref-name> contiene el nombre JNDI que se utilizará como contexto para el pool de conexiones.

El siguiente paso es acceder al elemento "Web pages" del proyecto. Desplegar ahora el elemento "META-INF" y hacer doble clic sobre el archivo "context.xml". Se mostrará el contenido:

<Context antiJARLocking="true" path="/TrazalogicOperator"/>

Modificar esta línea para definir dos líneas (apertura y cierre) en lugar de una:

<Context antiJARLocking="true" path="/[NombreProyecto]">
</Context>

[NombreProyecto] es asignado automáticamente por NetBeans, y no es necesario cambiarlo.

Entre estas dos líneas añadir lo siguiente para crear el contexto del pool:

<Resource name="jdbc/[nombreJNDI]"
auth="Container"
type="javax.sql.DataSource"
username="[usuarioPostgreSQL]"
password="[passwordPostgreSQL]"
driverClassName="org.postgresql.Driver"
url="jdbc:postgresql://[servidor]:[puerto]/[nombrebasedatos]"
maxActive="8"
maxIdle="4"/>

Un ejemplo de url sería:

url="jdbc:postgresql://localhost:5432/miBaseDatos"

Si la base de datos va a residir en la misma máquina que Tomcat y la aplicación web, se utilizaría "localhost". Si estuviera en otra máquina, especificar el nombre de la misma (si está configurado en un servidor DNS) o bien la dirección IP de la misma.

El puerto 5432 es el puerto por defecto de la base de datos PostgreSQL. Si se ha configurado otro puerto, modificar este parámetro.

Probar todo

Para probar tanto el servidor de aplicaciones como el pool de conexiones, vamos a crear un Servlet. Para ello:
- Menú "File" + opción "New File..."
- En la lista "Categories" seleccionar "Web", y en la lista "File Type" seleccionar "Servlet".
- Botón "Next"
- En el campo "Class Name" escribir el nombre del servlet, por ejemplo "ServletPrueba".
- En el campo "Package" escribir el nombre del paquete donde se ubicará el servlet, por ejemplo "com.prueba.servlet"
- Botón "Next"
- Botón "Finish"

Se creará el servlet con un código mínimo.

En la sección "import" añadir las siguientes importaciones:

import java.sql.*;
import javax.sql.*;
import javax.naming.*;

Buscar el método processRequest y escribir el siguiente código:

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
  response.setContentType("text/html;charset=UTF-8");
  PrintWriter out = response.getWriter();
  try {
    out.println("<html>");
    out.println("<head>");
    out.println("<title>Servlet ServletPrueba</title>");
    out.println("</head>");
    out.println("<body>");
    out.println("INICIO...<br>");
    Context initCtx = new InitialContext();
    Context envCtx = (Context) initCtx.lookup("java:comp/env");
    DataSource ds = (DataSource)
      envCtx.lookup("jdbc/[nombreJNDI]");
    Connection conn = ds.getConnection();
    //... Insertar aquí las consultas y actualizaciones a base de datos
    conn.close();
    out.println("...FIN<br>");
    out.println("</html>");
  } catch (Exception ex) {
    out.println("Error: " + ex.toString();
  } finally {
   out.close();
  }
}

A través del nombre JNDI se extrae el contexto para el pool de base de datos, retornando un objeto de tipo DataSource. Una vez obtenido el DataSource, es posible obtener la conexión (método getConnection()). A partir de ahí, con la conexión, procederemos a realizar las consultas a base de datos, o las actualizaciones pertinentes.

El código, tal y como está, servirá para verificar que se obtiene la conexión. Si todo va bien, devolverá una página Web, con el único texto "INICIO... / ...FIN". Si hubiera algún error, retornaría también el error producido.

Para ejecutar este servlet, en el panel de proyecto (parte izquierda), abrir la carpeta "Source Packages" + "com.prueba.servlet", y con el botón derecho hacer clic sobre el elemento "ServletPrueba.java" y seleccionar "Run File" (para ejecutar el servlet) o "Debug File" (para depurar el servlet, previo marcado un punto de interrupción).

Antes de finalizar, comentar qué me ha llevado a escribir este post, tras tres días devanándome la cabeza con Eclipse y con GlassFish, con los que he tenido multitud de problemas y una complejidad bastante elevada en cuanto a una configuración para trabajar. Soy de los que piensan que tenemos ya mucho trabajo por delante como para perder el tiempo descifrando o poniéndote delante de una bola de cristal para intentar explicar cómo configurar algo que debería ser automático y simple, y que en apenas unos segundos y de manera intuitiva debería dejarte empezar a trabajar. Ahí radica el éxito de Visual Studio de Microsoft, que facilita el trabajo multiplicando la productividad.

Con Eclipse, de forma inexplicable, los cambios en mi servlet no se actualizaba ni desplegaba en el servidor. Por más que he intentado saber por qué, aún no me lo explico.

Con GlassFish, que parece un servidor potente y muy bien diseñado, veía muchos pasos para configurar el pool de conexiones (primero una conexión, luego el pool y luego el resource, y luego configurar el context.xml y el web.xml). Pero aún así, mirando la documentaciónd e GlassFish, PostgreSQL no venía homologado en las especificaciones, aunque en realidad sí que permitía su configuración, y la conexión, de hecho me permitía mirar la estructura de la base de datos y ejecutar consultas desde el IDE. Pero a la hora de desarrollar, el DataSource era imposible de capturar, y desde el propio GlassFish, probar el DataSource me daba un error FATAL por que database devolvía null. El problema es que el driver de conexión es peculiar en PostgreSQL, y se obtiene mediante un DataSource "especial" llamado org.postgreSQL.ds.PGSimpleDataSource, el cual es incompatible o no se puede convertir a un DataSource normal. Asimismo, incluso intentando obtener un PGSimpleDataSource en lugar de un DataSource, también daba error porque internamente trabaja con DataSource. Vamos un galimatías que me hizo desistir.

Al final, me empapé la documentación de Tomcat (concretamente http://localhost:8080/docs/jndi-resources-howto.html) y trasteando con Tomcat, conseguí definir este procedimiento de configuración, simplificándolo al máximo y que funciona.

Espero que os sea de utilidad.

Visita al SIMO 2009

2009-09-22T15:24:00.010+02:00

Día inaugural de SIMO 2009. El retorno de la consagrada feria de las tecnologías de la información, tras dos años en dique seco debido a la crisis mundial. Expectación, pues en la última edición me negué a ir porque ya era un circo, y acudía hasta el apuntador, desprestigiando a los profesionales. Este año (en teoría) era sólo para profesionales (aunque he visto alguna que otra familia con los nenes).

Empieza las 10:00. Personas fuera esperando. En el interior hay escáners para bolsas, paquetes y equipajes, como en el aeropuerto. También hay arcos detectores, y bandejas para dejar los objetos metálicos. Todo lleno de policias nacionales y algún que otro trajeado con "pinganillo", al estilo de la CIA o del FBI. Esto parece de película. ¿Será por seguridad o sólo porque el principito Felipe va a venir, seguramente con la corte de pelotas como Gallardón (alcalde de Madrid) y la Espe (presidenta de la Comunidad de Madrid?. No lo sé, pues no me quedé a esperarles.

Para entrar y salir en todos los pabellones y accesos, hay que pasar la tarjeta de identificación (código de barras en 2D y 3D) por un lector para el torniquete.

Primera sorpresa, vas andando desde el pabellón 1, y andas y andas, y andas, y todos los pabellones, a izquierda y derecha CERRADOS!!!! Llegamos al final, y el número 7 está abierto.

¡¡¡ Sorpresa !!! El pabellón 7 es muy diáfano, con pocos stands, muy separados y... adividinad: ¿quién ocupa más de la mitad del pabellón?. Nada más y nada menos que Microsoft, presentando su Ventanucos 7, su Exchange 2008, el Office y el Dynamics (por cierto, una pasada viendo cómo funciona en una mesa de pantalla táctil).

Pruebo algún que otro equipo funcionando con Ventanucos 7. Nada mal, acostumbrado a mi Vista. Parece (a primer a vista) más estable, robusto y funcional. Mi feeling es bueno.

Junto a Microsoft hay alguna que otra consultora de las que andan, como las rémoras, junto al gran tiburón blanco. Curiosamente, está Sun Microsystems con un stand muy pequeño, promocionando únicamente hardware, como sistemas de almacenamiento, y algún servidor modular. Una cosa extrañamente curiosa, y al final os contaré mi reflexión.

Bueno, vamos al pabellón 9, hay bastantes stands pequeñitos, como los de las ferias de pueblo. Los más pudientes tiene algún stand un poco más grande, como Acer o Airis. Pero los más grande pertenecen a SAP, HP, DELL (en un camión tráiler de color negro) y a la editorial que edita MacWorld. Alguno que otro ha contratado a un maestro cortador de jamón, que sabe rancio en esta feria (no por el jamón, es una ironía). Sorprendentemente, cerca de un cuarto del espacio de este pabellón está vallado y desaprovechado.

Salimos fuera y nos encontramos que el resto de pabellones al otro lado están cerrados. ¡No puede ser! ¿Cómo va a haber sólo dos pabellones para el SIMO?. Volvemos a entrar y preguntamos. ¡SOLO HAY DOS PABELLONES! Algo que ves en apenas una hora y media.

En Telefonía está Vodafone y Telefónica. Pero no hay fabricantes de teléfonos móviles, como Nokia, Panasonic, Samsung o Motorla, como en otras ediciones. Sólo hay compañías de telefonía, y sólo las más grandes (echo en falta a Symio, Yoigo u Orange).

En software están los de SAP y los más conocidos en ERP y en CRM. Pero empiezo a echar en falta a los grandes fabricantes de software y de bases de datos (como Oracle). No han acudido Adobe, ni Java, ni empresas de software libre (sólo encontré Opentrad, con un software de traducción libre, y Cenatic, de forma muy discreta), ni Hispalinux, ni la comunidad de Extremadura (con su Linex), ni la Junta de Andalucia... ¿DONDE ESTAN?

Pregunto a unos amigos que tenían un stand en la feria (hace años trabajé con ellos), y me chistan para que baje la voz y no pronuncie la palabra maldita: software libre. Este gesto me mosquea. ¿No hay pasta para estos fabricantes debido a la crisis? ¿La organización del SIMO ha hecho algo por lo que estos fabricantes no estén de acuerdo y no hayan asistido? ¿O acaso hay una política discriminatoria con respecto al software libre? Lo ignoro, pero el retorno del SIMO es agridulce ante esta perspectiva desoladora.

Me quedan todas las dudas del mundo acerca de lo que Oracle va a hacer con los productos de Sun Microsystems, como Java, MySQL o StarOffice. Me quedan dudas sobre qué hace ahora Borland que ha sido otra vez adquirida. Se hablaba de un Delphi 2010, pero me quedo con las ganas. Me quedo con las ganas también de conocer alternativas a estos tiburones, sean o no libres. Opentrad (que por cierto, el comercial que me atendió fue amabilísimo, me explicó todo muy bien e incluso me invitó a un zumo de naranja recién exprimido), era el único fabricante de software libre, pero no competía con nadie de la feria en su terreno. Lo mismo ocurría con algunos fabricantes de hardware humildes. Se pone de manifiesto el abismo entre ricos y pobres, las apariencias y la publicidad que ponen ante la diferencia de imagen, los que tienen un poder abusivo y que no permiten la competencia.

Mi opinión es que el SIMO ha vuelto, y es un buena noticia, pues se vuelve a reactivar el mercado y hay esperanzas de volver a la fertilidad tecnológica. Por otro lado, el sabor amargo ante la poca oferta que imponen, la diferencia abismal entre tiburones, rémoras y gorriones que pican las migajas, y que el software libre haya sido eliminado del directorio de la feria, siendo hoy en día uno de los principales candidatos a un nuevo mercado rico en ideas y en competitividad. Está visto que el SIMO pertenece a cuatro gigantes que no deja crecer la hierba bajo su sombra.

Me fui de la feria dos horas y cuarto después de haber llegado, desazonado y triste. No tuve ni ganas de ver al principito y su corte de pelotas con afán de cámara y publicidad falsa. Para colmo, las dos horas y cuarto de parking me salió por 4,15 euros. TODO UN ROBO!!!!

TI Facturas listo para su descarga

2009-09-21T22:13:00.003+02:00

Se ha liberado la versión definitiva de TI Facturas, el software imprescindible para que cualquier PYME o cualquier trabajador autónomo pueda gestionar de forma sencilla y económica sus presupuestos y facturas. Se ha optimizado al máximo la sencillez del programa, para que empezar con él no sea un reto, y que el día a día sea algo natural y no consuma mucho tiempo que se requeriría para actividades más importantes.

Descarga y documentación:

http://www.tecnillusions.com

Base de datos bloqueada en SQLite y .NET

2009-09-19T19:19:00.006+02:00

En post anteriores se ha hablado sobre las bondades de SQLite trabajando en conjunción con .NET, un gran equipo que es eficiente y rápido (amén de optimizado por lo recursos que consume), pero puede dar alguno que otro quebradero de cabeza, especialmente con el bloqueo de base de datos (database locked).

La principal razón de que esto ocurra es que SQLite trabaja en una única sesión, por lo que la concurrencia queda descartada para grandes pretensiones. Incluso con esto en mente, trabajando en una aplicación de escritorio (no en servidor), esto puede suponer también un problema cuando queremos trabajar con varias consultas anidadas y actualizaciones.

En este post voy a contar mi experiencia y cómo he capeado este problema.

Ante todo, hay que reutilizar el código, por lo que el acceso a base de datos la realizo desde una clase con métodos públicos. En esta clase defino los objetos clave para el uso de la base de datos:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SQLite; // No olvidar esta referencia

// Clase específica para acceso y carga de datos desde la base de datos
namespace TI_Facturas
{
  class DatosManager
  {
    private SQLiteConnection con = null;
    private SQLiteCommand cmd = null;
    private SQLiteDataReader dtr = null;
}
}

Los objetos deben tener un uso exclusivo cada vez, por lo que se definen dos métodos: uno para iniciarlos y otro para despacharlos.

  // Inicializa los objetos de base de datos
  private void initSQL()
  {
    con = null;
    cmd = null;
    dtr = null;

    con = new SQLiteConnection("Data Source=ti_facturas.db;Version=3;New=False;Compress=True;");
    con.Open();
  }

  // Prepara la clase para ser despachada
  public void dispose()
  {
    if (cmd != null)
      cmd.Dispose();
    if (dtr != null)
    {
      dtr.Close();
      dtr.Dispose();
    }
    if (con != null)
    {
      con.Close();
      con.Dispose();
    }

    con = null;
    cmd = null;
    dtr = null;

    GC.Collect();
  }

El método initSQL() ha de invocarse antes de empezar cualquier operación con la base de datos. A continuación se realizan las operaciones con la base de datos (accesos y actualizaciones). Y por último se invoca al método dispose() para finiquitar los objetos.

La sentencia GC.Collect() permite vaciar el Garbage Collector, un repositorio que .NET utiliza para depositar los objetos que dejan de ser utilizados. Es posible que en algunas ocasiones, aunque cerremos convenientemente los objetos para despacharlos al Garbage Collector, éste aún pueda tener la referencia a SQLite y no haya procesado su limpieza automática, por lo que nos dará, inevitablemente, el conocido error de "database locked", a pesar de ser meticulosos y despachar a medida que dejamos de utilizar.

Recomiendo utilizar en esta clase los métodos de acceso a la base de datos, e ir invocándolo desde nuestras propias clase. Por ejemplo, ahí van las más utilizadas de forma genérica:

// Ejecuta una sentencia de actualizacion (NO SELECT)
public String executeNonQuery(string sql)
{
  String result = "" ;

  try
  {
    initSQL();

    cmd = new SQLiteCommand(sql, con);
    int rows = cmd.ExecuteNonQuery();

    if (rows == 0)
      result = "No se ha realizado ningun cambio [" + sql + "]";
  }
  catch (Exception argEx)
  {
    result = "Error al ejecutar SQL ["+sql+"]: " + argEx.Message;
  }

  dispose();

  return result;
}

// Obtiene el valor de un unico campo para una consulta de un solo registro
public String getUniqueValue(string sql)
{
  String result = "";

  try
  {
    initSQL();
    cmd = new SQLiteCommand(sql, con);
    dtr = cmd.ExecuteReader();
    dtr.Read();
    result = (String)dtr[0].ToString();
  }
  catch (Exception argEx)
  {
    result = "";
  }

  dispose();

  return result;
}

// Obtiene el conjunto de registros de una consulta SQL Select
public SQLiteDataReader executeReader(string sql)
{
  try
  {
    initSQL();
    cmd = new SQLiteCommand(sql, con);
  dtr = cmd.ExecuteReader();
  }
  catch (Exception argEx)
  {
  dtr = null;
  }

  return dtr;
}

EJEMPLOS DE USO:

Ejemplo 1: Actualización

string sql="insert into paises (id_pais, pais) values (1, 'Spain')";
DatosManager dm = new DatosManager();
dm.executeNonQuery(sql);
dm.dispose();

Ejemplo 2: Consulta campo especifico en registro unico

string sql="select nombre from clientes where id_cliente=32";
DatosManager dm = new DatosManager();
string nombre=dm.getUniqueValue(sql);
dm.dispose();

Ejemplo 3: Consulta con conjunto de varios registros

string sql="select id_provincia, provincia from provincias order by provincia";
DatosManager dm = new DatosManager();
SQLiteDataReader dr=dm.executeReader(sql);
while (dr.Read())
{
  // Tratamiento de cada registro
}
dr.Close(); // Despachar primero el DataReader
dr.Dispose();
dm.dispose();

TI_Facturas v2009 Beta

2009-09-17T15:41:00.015+02:00

Acaba de liberarse la versión Beta de TI_Facturas v2009, de la empresa Tecnillusions (http.//www.tecnillusions.com), un sencillo y potente gestor de presupuestos y facturas, orientado a la pequeña y mediana empresa.

Entre sus características cabe destacar las siguientes:

  * Sencillo e intuitivo, lo que tiene un período muy breve de aprendizaje.
  * Rápido, eficaz y ligero en recursos.
  * Gestión de múltiples empresas.
  * Numeración automática de presupuestos y de facturas, independientemente de la empresa.
  * Gestión de empresas.
  * Gestión de clientes.
  * Internacionalidad en empresas y clientes.
  * Configuración de unidades métricas a ser utilizadas en los conceptos.
  * Configuración de las formas de pago de las facturas.
  * Generación de facturas a partir de los presupuestos aceptados.
  * Configuración de los impuestos y descuentos a aplicar de forma genérica (por empresa), o individual (por factura).
  * Registro de plazos de pago
  * Libertad en la redacción de los conceptos:
     o Varias líneas por concepto.
     o Texto extenso, que automáticamente es distribuido en varias líneas.
     o Cantidad, Unidad, Precio y Total, libres y opcionales de mostrar.
     o Cálculo automático del Total si Cantidad y Precio son introducidos.
  * Autopaginación. Los totales se visualizan en la última página, y cada página es enumerada.
  * Posibilidad de agrupar facturas en una factura, formando parte del concepto de la misma.
  * Potente filtro con combinatoria de criterios de búsqueda:
     o Por empresa
     o Por cliente
     o Por una fecha determinada
     o Por un rango de fechas (desde...hasta)
     o Aceptado (presupuesto) o pagada (factura)
  * Configuración de logotipo para su publicación en presupuestos y facturas.
  * Alarmas de plazos vencidos.
  * Sistema operativo Windows XP, 7 o Vista.
  * Sin licencias por máquina: se puede instalar en cuantas máquinas se desee, teniendo en cuenta que los datos de cada una es independiente de la otra.
  * Modalidades:
     o Gratuito: Completamente funcional, con algunas limitaciones.
     o Premium:
         + Sin limitaciones
         + Soporte y garantía de 1 año contra defectos.
         + Servicio de actualización gratuito.
     + Por sólo 150 euros
  * Soporte adicional y opcional (previo presupuesto)
  * Personalización a medida (previo presupuesto):
     o Funcionalidades a medida
     o Traducción al idioma requerido
     o Personalización del presupuesto
         + Modelo
         + Tipografía
         + Distribución
     o Personalización de la factura
         + Modelo
         + Tipografía
         + Distribución

Para solicitar la versión gratuita para probar TI_Facturas sin compromiso enviar un correo a info@tecnillusions.com

Capturas de pantalla:

Consultas SQLite desde .NET

2009-09-17T00:43:00.006+02:00

SQLite se integra muy bien con .NET, siendo muy fácil desarrollar un proyecto con esta base de datos, con unos costes muy reducidos al no tener que pagar licencias propietarias, como en el caso de Oracle o de SQL Server.

El primer paso a dar es instalarse el conector System.Data.SQLite.dll (se puede descargar de http://sqlite.phxsoftware.com). Una vez instalado, hay que hacer referencia a dicho conector mediante Project > Add Reference... (Proyecto > Añadir referencia...), buscar el conector y OK (Aceptar).

El siguiente paso es añadir al inicio del código el uso de las clases de esta librería:

using System.Data.SQLite;

Los ejemplos que aquí se muestran están escritos en C#, pero la adaptación a VB.NET no debería suponer gran transcendencia.

En primer lugar hay que encerrar todo el proceso de acceso a la base de datos en un bloque try...catch. Dentro de este bloque comenzaremos abriendo la conexión, mediante:

SQLiteConnection sql_con = new SQLiteConnection ("DataSource=ARCHIVOBBDD;

Version=3;New=False;Compress=True;");
sql_con.Open();

donde, ARCHIVOBBDD es el nombre del archivo de la base de datos. Si este archivo se encuentra en una ruta fija, hay que indicar toda la ruta. Si se escribe únicamente el nombre del archivo, éste debería estar ubicado en el directorio debug y release del proyecto.

A continuación se crea el comando de la sentencia a ejecutar (en este caso una consulta o SELECT):

string CommandText = "select id_empresa, nombre from EMPRESAS order by nombre";
SQLiteCommand sql_cmd = new SQLiteCommand(CommandText, sql_con);

El siguiente paso será ejecutar el comando para obtener el resultado de la consulta, el cual estará en un DataReader:

SQLiteDataReader sql_dtr = sql_cmd.ExecuteReader();

En este momento, el puntero del cursor se encuentra justo antes del primer registro. Con el método Read(), se obtenerá el siguiente registro o fila, retornando true si se leyó correctamente, o false si no se leyó, en cuyo caso se habrá alcanzado el final del resultado. La lectura de todos los registros se puede realizar dentro de un bucle como éste:

while (sql_dtr.Read())

{

... // Bloque para tratar los campos de la fila obtenida

}

El acceso a cada campo se realiza a modo de array con el DataReader, comenzando desde 0, que sería el primer campo, hasta n-1. También se podría acceder indicando dentro del elemento del array el nombre del campo entre comillas, en lugar del índice. Las dos siguientes líneas realizan lo mismo:

string nombreEmpresa = (string)sql_dtr[1];

string nombreEmpresa = (string)sql_dtr["nombre"];

En todos los casos hay que hacer un casting del tipo de dato (anteponiendo y encerrando entre paréntesis el tipo de dato), por lo que hay que tener especial cuidado con los datos que son numéricos o de fecha. Las siguientes líneas son una muestra de ello, aunque no tengan que ver con el ejemplo que estamos planteando:

long lData = (Int64)sql_dtr[0]; // Tipo entero largo

Single sData = (Single)sql_dtr[1]; // Tipo decimal

Double dData = (Double)sql_dtr[0]; // Tipo decimal de doble precisión

Para hacer una captura correcta de datos, lo mejor es comprobar si el dato no es nulo y un parseo en consecuencia, como en el siguiente ejemplo:

Single sCant=0;
string sData = dtr[0].ToString();
if (sData != null && sData != "")
sCant = Single.Parse(sData);

Si el dato no admite nulos, se puede realizar el parseo directamente:

long plazo = (long)long.Parse(sql_dtr[6].ToString()) ;

Double dData = Double.Parse(sql_dtr[0].ToString());

DateTime dtFecha = DateTime.Parse(sql_dtr["fecha"].ToString());

Una vez se han leído los registros y no se vaya a utilizar más el DataReader, hay que cerrarlo para optimizar recursos:

sql_dtr.Close();

Si la conexión ya no es necesaria por el momento, cerrarla también:

sql_con.Close();

El código completo del ejemplo, es el siguiente, y su objetivo es cargar una lista de empresas en una combo (lista desplegable):

// Carga la combo de empresas
private void loadEmpresas()
{
try
{
SQLiteConnection sql_con = new SQLiteConnection

("Data Source=ti_facturas.db;Version=3;

New=False;Compress=True;");
sql_con.Open();

string CommandText =

"select id_empresa, nombre from EMPRESAS order by nombre";
SQLiteCommand sql_cmd = new SQLiteCommand(CommandText, sql_con);
SQLiteDataReader sql_dtr = sql_cmd.ExecuteReader();

DataTable dt;
dt = new DataTable("Datos");

dt.Columns.Add("id_empresa");
dt.Columns.Add("empresa");

DataRow dr;

while (sql_dtr.Read())
{
dr = dt.NewRow();
dr["id_empresa"] = ((Int64)sql_dtr[0]);
dr["empresa"] = (string)sql_dtr[1];
dt.Rows.Add(dr);

}

cboEmpresa.DataSource = dt;
cboEmpresa.ValueMember = "id_empresa";
cboEmpresa.DisplayMember = "empresa";

sql_dtr.Close();
sql_con.Close();
}
catch (Exception argEx)
{
Console.WriteLine("Exception message: " + argEx.Message);
}
}

Primeros pasos en SQLite

2009-09-14T16:04:00.009+02:00

INTRODUCCION

SQLite es una base de datos que sorprende por lo increíblemente ligera que es (apenas ocupa 250KB), pero no por ello deja de ser potente, rápida y eficiente, basándose en SQL estándar para su gestión.

Las características más importantes de SQLite son las siguientes:
- Transacciones atómicas, aisladas y consistentes.
- No requiere instalación ni administración.
- Implementa la mayor parte del estándar SQL92
- Una base de datos completa se almacena en un único archivo en el disco duro.
- Soporta bases de datos que ocupan terabytes, y cadenas y BLOBs que ocupan gigabytes.
- Ejecución muy rápida y consume muy pocos recursos de la máquina.
- No requiere de dependencias de terceros ni externas.
- Es de dominio público.
- Disponible para Linux, Windows y MacOS X.
- Incluye una consola para la gestión y administración de bases de datos.
- Se puede utilizar en proyectos escritos en:
   - Basic y dialectos (Visual Basic, PowerBasic, PureBasic...)
   - C y C++
   - C# y VB .NET
   - Clipper
   - Lisp
   - Curl
   - D
   - Delphi
   - Macromedia Director
   - Flash Actionscript 2
   - Fortran
   - Java
   - Javascript
   - Matlab
   - .NET
   - Perl
   - PHP
   - PL/SQL
   - Python
   - Ruby
   - Smalltalk
   - Tcl/tk
   - Y otros...

INSTALACION

Para instalar SQLite hemos de acceder a su página principal

http://sqlite.org

Y descargar (Download) la última versión ejecutable (Binaries) de la plataforma (Windows, Linux, MacOS X) en la que vayamos a utilizarla. También aquí se puede descargar la documentación de la misma.

El archivo está comprimido, y simplemente hay que descomprimirlo en la carpeta de nuestro disco de nuestra preferencia.

CONSOLA SQLITE

Una vez descomprimido hemos de abrir una consola de comandos (en caso de Windows, también se llama consola DOS, y se accede mediante "tecla Windows" + "R", y ejecutar "cmd") para utilizar SQLite. Una vez tengamos abierta la consola de comandos, hay que acceder al directorio donde se descomprimió SQLite, y ejecutar el comando:

sqlite3

donde es un path a un archivo donde contendrá una base de datos. Si no existe, creará la base de datos. Si existe, utilizará ésta. Como recomendación, poner una extensión fácil de reconocer, como ".db" o ".sqlite".

La ejecución de este comando nos introducirá en la consola de SQLite, donde podremos ejecutar cualquier comando SQL para gestionar la base de datos. Asimismo, también hay otros comandos específicos de esta consola:

.help ó .h > Muestra una ayuda de los comandos disponibles

.quit ó .q > Termina la sesión de consola SQLite, retornando a la de comandos

.exit ó .e > Termina la sesión de consola SQLite, retornando a la de comandos

.databases > Lista las bases de datos en uso

.tables > Lista las tablas de la base de datos

.tables 'P%' > Lista las tablas que empiecen por 'P' (patrón LIKE)

.backup ARCHIVO > Realiza una copia de seguridad de la base de datos principal a ARCHIVO

.backup 'BBDD' ARCHIVO > Realiza una copia de seguridad de la base de datos 'BBDD' a ARCHIVO

.schema TABLA > Muestra la estructura de la tabla especificada (en formato SQL), incluyendo los índices

.indices TABLA > muestra los índices de la tabla especificada

.output stdout > Establece la salida a pantalla (por defecto)

.output ARCHIVO > Establece la salida al archivo indicado en archivo

.mode MODO > Establece el modo de salida, donde MODO puede ser uno de estos valores:

csv > valores separados por comas

column > columnas alineadas a la izquierda (ver .width)

html > código TABLE en HTML

insert > código INSERT en SQL

line > un valor por línea

list > valores delimitados por .separator (por defecto)

tabs > valores separados por tabuladores

tcl > lista de elementos tcl

.width num > Establece el ancho para las columnas (salida)

.separator string > Establece string como cadena delimitadora (salida)

.dump > Vuelca en la salida la estructura y datos de la base de datos, es decir, muestra las sentencias SQL (creación de tablas, índices, inserción de datos actuales, etc.), de todas las tablas de la base de datos.

.dump TABLA > Vuelca en la salida la estructura y datos de la tabla especificada, es decir, que muestra las sentencias SQL para la TABLA especificada

.restore ARCHIVO > Restaura la copia de seguridad realizada con .backup almacenada en ARCHIVO, en la base de datos en curso

.restore 'BBDD' ARCHIVO > Restaura la copia de seguridad almacenada en ARCHIVO, en la base de datos especificada con 'BBDD'

.read ARCHIVO > Ejecuta las sentencias SQL que están almacenadas en ARCHIVO

EJEMPLOS

.mode csv

select * from paises;

Muestra los datos de la tabla paises separados por comas.

.mode html

select * from paises;

Muestra los datos de la tabla paises en una tabla HTML

.mode insert

select * from paises;

Muestra las sentencias INSERT para cada uno de los registros de la tabla paises.

.output paises.sql

.mode insert

select * from paises;

Vuelca en el archivo paises.sql las sentencias INSERT para los datos de la tabla paises.

.output paises.sql

.dump paises

Vuelca en el archivo paises.sql las sentencias de creación de tabla e índice, así como la inserción de datos, para la tabla paises.

.output stdout

.dump paises

Restaura la salida a la pantalla, y vuelca la tabla paises en dicha salida.

IDE's PARA SQLITE

Afortunadamente, existen IDE o interfaces de usuario, que permitirán gestionar nuestras bases de datos SQLite, sin necesidad de la consola. Algunas de las más populares son:

- SQLite Administrator > http://sqliteadmin.orbmu2k.de/

- SQLite Database Browser > http://sqlitebrowser.sourceforge.net/

- SQLite Manager > http://sqlitemanager.findmysoft.com

- SQLite Spy > http://www.yunqa.de/delphi/doku.php/products/sqlitespy/index

- SQLite Studio > http://sqlitestudio.one.pl/index.rvt

- SQLite Browser > http://sourceforge.net/projects/sqlitebrowser/

- Liteman > http://igorkh.freeshell.org/en/software/liteman.html

Uso de fechas en SQLite

2009-09-14T12:41:00.003+02:00

Este es mi primer post sobre SQLite, una base de datos muy ligera, pero potente y rápida, y que no necesita apenas administración. Es software libre, por lo que no necesitarás pagar licencias por su uso, y tendrás un importante ahorro de costes. Por otro lado, hay versiones para varias plataformas, incluyendo a Microsoft Windows, Linux, BSD, etc.

En un reciente proyecto personal en el que estoy embarcado, utilizo C#, en donde sólo es necesario una referencia a la librería System.Data.SQLite.dll (se puede descargar de http://sqlite.phxsoftware.com/). En el ordenador final, a la hora de instalarse, no es necesario tener el motor de la base de datos, pues la propia librería actúa como tal, y de una manera muy rápida y eficiente.

Pero SQLite puede utilizarse de muchas maneras, como embebido en C, o desde Java, o desde PHP (sólo por citar las más populares). Además, existen multitud de IDE's para diseñar y gestionar la base de datos, y no sólo una consola de comandos, por lo que no hay excusa para no probar esta base de datos.

Querría haber empezado una serie de posts sobre SQLite desde el principio (cosa que haré más adelante), pero por tiempo empezaré directamente con algo que puede despistarnos con respecto a otras bases de datos, y son el uso de fechas.

Un campo fecha se define como:

CREATE TABLE (nombre_campo DATE ...);

Aunque permite insertar o modificar los datos en el formato 'dd/mm/yyyy' es recomendable almacenar las fechas en el formato ordenable, del estilo '2004-06-26T20:11:04' (en .NET se realiza mediante String.Format("{0:s}", valor_datetime). Aunque este formato es válido, a la hora de comparar fechas tendrá en cuenta también la hora, por lo que si la precisión que se desea es sobre el día, y no sobre día y hora, el formato recomendado sería 'yyyy-mm-dd', que en .NET se obtendría mediante String.Format("{0:yyyy'-'MM'-'dd}", valor_datetime).

La razón de de este formato es que SQLite, internamente, la fecha se almacena como una cadena de texto.

Pero a la hora de hacer una búsqueda por fechas, del estilo:

SELECT ...

FROM ...

WHERE fecha1>fecha2

nos llevaremos una sorpresa al comprobar que no nos hace mucho caso.

A la hora de comparar fechas, hay que utilizar el formato juliano, y ello se consigue mediante una función especial de SQLite.

SELECT ...

FROM ...

WHERE julianday(fecha1)>julianday(fecha2)

De esta manera la comparación de fechas funcionará sin problemas.