Web.AR

Cómo invocar un archivo CSS incrustado en ASP.NET

2009-10-27T22:48:00.010-03:00

Recientemente me vi en la necesidad de crear un componente a medida (control web). Se trataba de un TextBox que pudiese controlar distintos tipos de datos (números, fechas, textos con limitaciones, etc). Ninguno de los freeware me convencía, por lo que puse manos a la obra y lo comencé a escribir desde mi poco conocimiento actual sobre el tema.

El objeto en cuestión se encuentra en una .dll, junto con tres archivos Javascript y un archivo CSS. Hasta ahí todo fenómeno. Los archivos .js se deben incluir en la página dependiendo del tipo de validación que se necesite y el .css cuando el control necesite mostrar un calendario para que el usuario ingrese una fecha de forma más cómoda.

La idea es que los archivos incrustado en la biblioteca de controles se invoquen mediante el etiquetado normal (<script> y <link>) y no volcar el código directamente en la página, puesto que en los sucesivos postback el servidor se vería obligado a transmitir todo ese código.

Como dijera, mi escaso conocimiento de la construcción de controles me llevó a leer toda la documentación posible y buscar en la web los ejemplos más claros. La mayoría de los ejemplos para invocar los .js decían más o menos así:

protected override void OnPreRender(EventArgs e) {
Page.ClientScript.RegisterClientScriptInclude("FunkyJavaScript",
Page.ClientScript.GetWebResourceUrl(this.GetType(),
  "FunkyTextBox.Funky.js"));

base.OnPreRender(e);
}

Esto funciona correctamente para los .js, especialmente cuando se colocan varios controles del mismo tipo. Para el caso de los .css el código aconsejado en varios ejemplos es este:

string includeTemplate =
"<link rel='stylesheet' text='text/css' href='{0}' />";
string includeLocation =
Page.ClientScript.GetWebResourceUrl(this.GetType(), "myStylesheet _Links.css");
LiteralControl include =
new LiteralControl(String.Format(includeTemplate, includeLocation));
((HtmlControls.HtmlHead) Page.Header).Controls.Add(include);

Si leemos el código, lo que hace es agregar una etiqueta LINK al encabezado de la página enlazando el archivo incrustado. Lo problemático de esto es que si agregas tres controles, este código agregará tres etiquetas LINK. Y eso no es lo que queremos!!

Bueno... toda esta cháchara para explicarles con que bobada lo resolví y tal vez le sirva. También puede pasar que haya una mejor forma y que yo quede como un idiota ignorante. :-)

If Page.Header.FindControl("mcTextBoxCalendarCSS") Is Nothing Then
Dim lnkCss As New HtmlControls.HtmlLink
With lnkCss
.Attributes("rel") = "stylesheet"
.Attributes("text") = "text/css"
.ID = "mcTextBoxCalendarCSS"
.Href = Page.ClientScript.GetWebResourceUrl(Me.GetType(), "mcTextBoxCalendar.css")
 End With
Page.Header.Controls.Add(lnkCss)
End If

Lo que hace este código es simple, crea el mismo enlace, pero le pone un ID y si ya existe de un objeto anterior, no lo agrega. Simple, pero efectivo.

RadiusIM

2009-01-24T13:32:00.002-02:00

He encontrado un navegador alternativo muy interesante que tiene funcionalidaes parecidas al desaparecido Odigo que mucho internaultas extrañan: radiusIM.

Tal vez ustedes ya lo conozcan y yo llegue tarde con la noticia, pero la finalidad de esta entrada en mi blog es para que mucha más gente se registre en él. Hay que hacerlo crecer porque, a diferencia de los otros mensajeros, con este puedes encontrar montones de amigos.

La característica más interesante es que situa a tus probables amigos en el mapa de Google. Puedes señalar tu ubicación en el mundo y radiusIM buscará personas afines a ti que se encuentren cerca de tu ubicación. O puesdes desplazarte por el Globo y radiusIM te mostrará quienes se encuentran registrados cerca de esa posición.

Tambiém puedes comunicarte con los navegadores más populares, como no podía ser de otra manera. Puedes invitar a tus amigos de esos mismos mensajeros a que se una.

Si tu intención es que las personas que te contacten tengan tu permiso para hacerlo, pues solo tienes que establecerlo en tu configuración y listo.

Su buscador no tiene tantas opciones como el querido Odigo, pero sería cuestión de que lo sugiriesemos y ver si lo pueden implementar.

A mi me agrada y se los recomiendo.

Objeto Javascript para controlar objetos INPUT

2008-08-28T00:02:00.004-03:00

Trabajamos a diario, los que diseñamos páginas web, con formularios de entrada de datos, mayormente conformados por objetos INPUT. Estos requieren, muchas veces, de validaciones estándares que, si bien podemos hacerlas en el servidor, se ahorra mucho tiempo el hacerlas en el servidor.

Este objeto que les comparto, hace una serie de validaciones para distintos tipos de entradas de datos, algunas de ellas teniendo en cuenta a algunos caracteres "indigestos" para las bases de datos enalgunas circunstancias. Valida:

NUMBER: que la entrada sea un valor numérico, entero o decimal, positivo o negativo, con determinada cantidad de decimales, etc.
DATE: que la entrada sea una fecha válida. Solo acepta fechas en formato dd/mm/aaaa.
TEXTONLY: solo caracteres de la A-Z (sin los hispánicos, salvo que se establezca lo contrario).
TEXTNUMBER: caracteres de la A-Z, números de 0-9 y el espacio en blanco. (sin los hispánicos, salvo que se establezca lo contrario).
ALPHA: caracteres de la A-Z y algunos símbolos. (sin los hispánicos, salvo que se establezca lo contrario).
ALPHANUMERIC: caracteres de la A-Z, números de 0-9 y algunos símbolos. (sin los hispánicos, salvo que se establezca lo contrario).

El código:

var __jgWC = {
   Version: '0.2.0 RC',
   //objetos controlados
   ControledObjects: [],
   //determinador del browser
   Browser: {
       IE:     !!(window.attachEvent && !window.opera),
       Opera:  !!window.opera,
       WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
       Gecko:  navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1,
       MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)
   },
   //controla los atributos del objeto input
   DefaultAttributes:function(obj) {
       if(!obj.getAttribute('inputtype')) obj.setAttribute('inputtype', 'all');
       if(!obj.getAttribute('texttransform')) obj.setAttribute('texttransform', 'none');
       if(!obj.getAttribute('positiveonly')) obj.setAttribute('positiveonly', 'false');
       if(!obj.getAttribute('decimalpoint')) obj.setAttribute('decimalpoint', '.');
       if(!obj.getAttribute('decimalplaces')) obj.setAttribute('decimalplaces', '2')
       if(!obj.getAttribute('excludechar')) obj.setAttribute('excludechar', '');
       if(!obj.getAttribute('includecharonly')) obj.setAttribute('includecharonly', '');
       if(!obj.getAttribute('spanishchars')) obj.setAttribute('spanishchars', 'false');
       if(!obj.getAttribute('valMin')) obj.setAttribute('valMin', '');
       if(!obj.getAttribute('valMax')) obj.setAttribute('valMax', '');
       if(!obj.getAttribute('blurErrorAlert')) obj.setAttribute('blurErrorAlert', 'true');
       if(!obj.getAttribute('blurErrorMessage')) obj.setAttribute('blurErrorMessage', 'DATOS INCORRECTOS');
   },
   //registrador de los eventos de los inputs controlados
   RegisterObject:function(ob, enableEvents) {
       if(typeof ob == 'string') { ob=document.getElementById(ob); }
       if(arguments.length == 1) {enableEvents=true;}
       if(!ob) { return false;}
       this.ControledObjects.push(ob);
       this.DefaultAttributes(ob);
       if(enableEvents) {
           this.AttachEvent(ob, 'keypress', __jgWC_DoKeyPress, false);
           this.AttachEvent(ob, 'blur', __jgWC_DoBlur, false);
       }
       return true;
   },

   //agregador de los eventos
   AttachEvent:function(elemento, nombre_evento, funcion, captura) {
     if (elemento.attachEvent){
       elemento.attachEvent('on' + nombre_evento, funcion);
       return true;
     }else
       if (elemento.addEventListener){
         elemento.addEventListener(nombre_evento, funcion, captura);
         return true;
       }else {
         return false;
       }
   },

   //cancela la ultima entrada
   CancelInput:function(ev) {
       if(this.Browser.IE)
       {
           ev.keyCode = 0;
           ev.returnValue = 0;
       }else{
           ev.preventDefault();
           ev.stopPropagation();
       }
   },

   //detiene el burbujeo del evento
   StopBubble:function(ev) {
       if (__jgWC.Browser.IE) {
           ev.cancelBubble = true;
       }else{
           ev.stopPropagation();
       }
   },

   //evaluador de los dígitos ingresados
   EvaluateValue:function(obj, kcASCII, eventType)
   {
       kcASCII = (arguments.length==1) ?'':kcASCII;
       var value = obj.value + kcASCII;
       // excludechar
       var exChar = obj.getAttribute('excludechar');
       if(exChar.length > 0) {
           return ( RegExp('^[^' + exChar + ']*$', 'i').test(value));
       }
       // includeonly
       var inOnly = obj.getAttribute('includecharonly');
       if(inOnly.length > 0) {
           return (RegExp('^[' + inOnly + ']*$', 'i').test(value));
       }
       // todo tipo de caracteres
       if(obj.getAttribute('INPUTTYPE').toUpperCase() == 'ALL') { return true; }

       switch(obj.getAttribute('INPUTTYPE').toUpperCase()) {
           // tipo numerico
           case 'NUMBER':
               return this.NumericValue(obj, value);
               break;
           //tipo fecha
           case 'DATE':
               if(eventType == 'keypress') { return true; }
               return this.DateValue(obj, value);
               break;
           //solo texto
           case 'TEXTONLY':
               return this.TextOnlyValue(obj, value);
               break;
           //solo texto y numeros
           case 'TEXTNUMBER':
               return this.TextNumberValue(obj, value);
               break;
           //texto y algunos caracteres de puntuacion
           case 'ALPHA':
               return this.AlphaValue(obj, value);
               break;
           //texto, numeros y algunos caracteres de puntuacion
           case 'ALPHANUMERIC':
               return this.AlphaNumericValue(obj, value);
               break;
       }
       return true;
   },

   //muestra el mensaje de error establecido si se seteo el permiso para mostrarlo
   ErrorMessage:function(obj) {
       if(obj.getAttribute('blurErrorAlert') == 'true') {
           alert(obj.getAttribute('blurErrorMessage'));
           obj.select();
           obj.focus();
       }
   }
};

//agrega caracteres hispanicos a la expresion regular
__jgWC.addSpanishChars=function(obj, alpha) {
       return (obj.getAttribute('SPANISHCHARS').toLowerCase()=='true')?'áéíóúüñ' + ((alpha)?'¿¡':'') :'';
   }

//agrega simbolos a la expresion regular    
__jgWC.addSimbols=function(obj) {
       return ':\\?\\!\\$%=/*#<>\\+->,;\\(\\)\\.@_';
   }

//testea el valor ALPHANUMERIC
__jgWC.AlphaNumericValue=function(obj, valToTest) {
       var Exp = '^[a-z0-9\s' + this.addSpanishChars(obj, true) + this.addSimbols(obj) + ']*$';
       return RegExp(Exp).test(valToTest.toLowerCase());
   }

//testea el valor ALPHA
__jgWC.AlphaValue=function(obj, valToTest) {
       var Exp = '^[a-z\s' + this.addSpanishChars(obj, true) + this.addSimbols(obj) + ']*$';
       return RegExp(Exp).test(valToTest.toLowerCase());
   }

//testea el valor TEXTNUMBER
__jgWC.TextNumberValue=function(obj, valToTest) {
       var Exp = '^[a-z0-9\s' + this.addSpanishChars(obj, false) + ']*$';
       return RegExp(Exp).test(valToTest.toLowerCase());
   }

//testea el valor TEXTONLY
__jgWC.TextOnlyValue=function(obj, valToTest) {
       var Exp = '^[a-z\s' + this.addSpanishChars(obj) + ']*$';
       return RegExp(Exp).test(valToTest.toLowerCase());
   }

//testea el valor NUMERIC
__jgWC.NumericValue=function(obj, valToTest) {
       var Exp = '^';
       if(obj.getAttribute('positiveonly').toLowerCase()=='false') {
           Exp += '[-]?';
       }
       Exp += '\\d{1,1}\\d*';
       if(Number(obj.getAttribute('decimalplaces')) > 0) {
           Exp += '\\' + obj.getAttribute('decimalpoint') + '?\\d{0,' + obj.getAttribute('decimalplaces') + '}';
       }
       Exp += '$'; 
       return RegExp(Exp).test(valToTest);
   }

//transforma el texto segun el atributo TEXTTRANSFORM
__jgWC.TextTransform=function(obj) {
       switch(obj.getAttribute('TEXTTRANSFORM').toUpperCase()) {
           case "UPPER":
               obj.value = obj.value.toUpperCase();
               break;
           case "LOWER":
               obj.value = obj.value.toLowerCase();
               break;
       }
   }
 

//controla el valor DATE
__jgWC.DateValue=function(obj, valToTest) {
       var expr='^(([0-2]?\\d{1})|([3][0,1]{1}))\/[0,1]?\\d{1}[0-2]\/[1-9]{1}\\d{3}$';
       if( ! RegExp(expr).test(valToTest) ) { return false;};
       var aD = valToTest.split('/');
       var tmp = new Date(aD[2], aD[1]-1, aD[0]);
       if(Number(tmp.getDate()) != Number(aD[0]) || Number(tmp.getMonth()+1) != Number(aD[1]) ||
               Number(tmp.getFullYear()) != Number(aD[2]) ) {
           return false;
       }
       return true;
   }


//controla los objetos indicados en ControledObjects uno por uno
function __jgWC_ControlObjects() {
   var objs = __jgWC.ControledObjects;
   var len = objs.length;
   for(var i=0; i < len; i++) {
       var obj = objs[i];
       if( !__jgWC.EvaluateValue(obj) ) {
           __jgWC.ErrorMessage(obj);
           return false;
       }
   }
   return true;
}


//controla el evento KeyPress
function __jgWC_DoKeyPress(ev) {
   var obj = ev.target||ev.srcElement;
   var KC = ev.which||ev.keyCode;
   var kcASCII = String.fromCharCode(KC);
   var noChar = ev.keyCode;
   __jgWC.StopBubble(ev);
   if(__jgWC.Browser.IE) {
       if (document.selection.type == 'Text')    {
           var tr = document.selection.createRange();
           tr.text = '';
       }
   }else {
       if(obj.selectionStart < obj.selectionEnd) {
           if(String(noChar).search('37|39') == -1) {
               try {
                   window.getSelection().collapseToStart()
               }catch(ex){ }
           }
       }
   }
   if( ev.ctrlKey || ev.altKey ) {
       if(kcASCII.search('V|v|C|c|X|x') > -1) {
           return true;
       }
       __jgWC.CancelInput(ev);
       return false;
   }

   // backspace|tab|enter|Alt-flecha izq|Alt fecha der.
   if(String(noChar).search('8|9|13|37|39') > -1) {return true;}
   //evaluate
   if( !__jgWC.EvaluateValue(obj, kcASCII, ev.type) ) {
       __jgWC.CancelInput(ev);
       return false;
   }
}


//controla el evento blur
function __jgWC_DoBlur(ev) {
   var obj = ev.target||ev.srcElement;
   //evaluate
   if( !__jgWC.EvaluateValue(obj) ) {
       __jgWC.ErrorMessage(obj);
       return false;
   }
   __jgWC.TextTransform(obj);
   return true;
}

Las propiedades que acepta cada INPUT son:

INPUTTYPE: indica que tipo de dato hay que controlar: NUMERIC, DATE, TEXTONLY, TEXTNUMBER, ALPHA, ALPHANUMERIC, ALL.
TEXTTRANSFORM: acepta los valores UPPER, LOWER o NONE, para indicar si se debe transformar el texto a mayúsculas, minúsculas o sin cambios, respectivamente.
POSITIVEONLY: funciona en combinación con NUMERIC y acepta el valor TRUE o FALSE. Indica si el valor númerico será solo positivo o no.
DECIMALPOINT: funciona en combinación con NUMERIC, para establecer el punto decimal que se ha de aceptar. Por omisión se acepta el punto.
DECIMALPLACES: funciona en combinación con NUMERIC y determina el número de decimales que se haceptarán. Por omisión se aceptan 2.
EXCLUDECHAR: acepta una lista de caracteres que no serán aceptados en la entrada de datos.
INCLUDECHARONLY: acepta una lista de caracteres que serán los únicos aceptados.
SPANISHCHARS: acepta el valor TRUE o FALSE e indica si se han de aceptar los caracters españoles áéíóúñ en la entrada de datos.
VALMIN: funciona en combinación con NUMERIC y establece el valor mínimo que se ha de aceptar.

Objeto Javascript para manipular ComboBox

2008-08-27T22:29:00.006-03:00

Hoy les acerco un objeto Javascript que permite manipular ComboBox de manera un tanto más sencilla y práctica

Entre sus propiedades, éste permite:

Crear el combo a través de un par de métodos y con algunas propiedades, de manera dinámica.
Obtener el valor de la opción seleccionada, sus atributos y/o el texto de la opción.
Eliminar todas o algunas de las opciones.
Ordenar las opcines por su valor o por su texto identificatorio.
Seleccionar la opción del combo, basándose en el valor o el texto de la misma.

El código:


/** Documento Javascript
Funciones para tratar objetos SELECT

Autor: Julio Gonzalez
Fecha: 22/08/2008
*/

$CB = {
/* metodo interno */
__ctrlOBJ:function(ob) {
 if( typeof ob != 'object' ) { return false; }
 if( ! ob ) { return false; }
 return true;
},

/* metodo interno */
__isArray:function(ob) {
 return (ob != null && typeof ob == "object" && 'splice' in ob && 'join' in ob);
},

/* metodo interno */
__isObject:function(ob) {
return (ob != null && typeof ob == "object");
},

/* metodo interno */
__getIndexByValue:function(ob, val, sensitive) {
 if(!this.__ctrlOBJ(ob)) { return null; }
 if(arguments.length < 3) { sensitive = false; }
 var ve;
 val = (sensitive)?val:val.toLowerCase();
 for(var i=0, len=ob.length; i < len; i++)
 {
     ve = (sensitive)?ob.options[i].value:ob.options[i].value.toLowerCase();
     if( ve == val ) {    return i; }
 }
 return null;
},

/* metodo interno */
/* seleccionar una opcion por el texto de la opcion */
__getIndexByText:function(ob, txt, sensitive) {
 if(!this.__ctrlOBJ(ob)) { return null; }
 if(arguments.length < 3) { sensitive = false; }
 var ve;
 txt = (sensitive)?txt:txt.toLowerCase();
 for(var i=0, len=ob.length; i < len; i++)
 {
     ve = (sensitive)?ob.options[i].text:ob.options[i].text.toLowerCase();
     if( ve == txt ) {    return i; }
 }
 return null;
},

/* elimina todos los elementos de un combo */
Clear:function(ob) {
 if(!this.__ctrlOBJ(ob))  { return false; }
 for(var i = ob.length - 1; i >= 0; i--)
 { ob.remove(i);  }
 return true;
},

/* borra una opcion buscandola por su value 
        sensitive (valor booleano) indica si la busqueda sera sensible a mayusculas/minusculas */
DeleteOptionByValue:function(ob, val, sensitive) {
 var i = this.__getIndexByValue(ob, val, sensitive);
 if(i==null) { return false; }
 ob.remove(i);
 return true;
},


/* borra una opcion buscandola por su value 
        sensitive (valor booleano) indica si la busqueda sera sensible a mayusculas/minusculas  */
 DeleteOptionByText:function(ob, txt, sensitive) {
 var i = this.__getIndexByText(ob, txt, sensitive);
 if(i==null) { return false; }
 ob.remove(i);
 return true;
},

/* retorna el texto de la opcion seleccionada */
TextSelectedOption:function(ob) {
 if(!this.__ctrlOBJ(ob) || !this.IsSelected(ob)) { return null; }
 return ob.options[ob.selectedIndex].text;
},

/* retorna el valor de la opcion seleccionada */
ValueSelectedOption:function(ob)   {
 if(!this.__ctrlOBJ(ob) || !this.IsSelected(ob)) { return null; }
 return ob.options[ob.selectedIndex].value;
},


/* retorna el objeto de la opcion seleccionada */
ObjectSelectedOption:function(ob) {
 if(!this.__ctrlOBJ(ob) || !this.IsSelected(ob)) { return null; }
 return ob.options[ob.selectedIndex];
},

/* retorna verdadero si el selectedIndex es > -1 */
IsSelected:function(ob)    {
 if(!this.__ctrlOBJ(ob)) { return false; }
 return (ob.selectedIndex > -1);
},


/* seleccionar una opcion por la propiedad value de la opcion 
        sensitive (valor booleano) indica si la busqueda sera sensible a mayusculas/minusculas  */
SelectByValue:function(ob, val, sensitive)
{
 var i = this.__getIndexByValue(ob, val, sensitive);
 if(i==null) { return false; }
 ob.selectedIndex = i;
 return true;
},


/* seleccionar una opcion por el texto de la opcion 
        sensitive (valor booleano) indica si la busqueda sera sensible a mayusculas/minusculas  */
SelectByText:function(ob, txt, sensitive)
{
 var i = this.__getIndexByText(ob, txt, sensitive);
 if(i==null) { return false; }
 ob.selectedIndex = i;
 return true;
},


/* objeto para crear el objeto necesario en CreateHTMLCombo */
ComboObject:{
 __cb:{id:'', name:'', attr:[], options:[]},
 setID:function(v) { this.__cb.id=v; },
 setName:function(v) { this.__cb.name=v; },
 addSelectAttribute:function(v) { this.__cb.attr.push(v); },
 addOption:function(txt, aAtt) {
     var ob={};
     ob.text=txt;
     ob.attr=aAtt;
     this.__cb.options.push(ob);
 },
 getComboObject:function() { return this.__cb; }
},


/* Crea el codigo html de un combo a partir de un obejto con la definicion de la etiqueta,
        y un array de objeto con el contenido de las etiquetas option.
        Datos del select
        - attr  array de pares (attr=value) con atributos del objeto (incluyendo los del usuario)
        - id        id del objeto select (obligatorio)
        - name  name dentro del <form>
   

        Datos de los options (Array)
        - text    texto de cada option
        - attr  array de pares (attr=value) con atributos del objeto (incluyendo los del usuario)
    */
CreateHTMLCombo:function(oSelDef) {
 if( !this.__isObject(oSelDef) ) { return null; }
 var aOp = oSelDef.options;
 if( !this.__isArray(aOp) ) {  return null; }
 /* define el select */
 if(typeof oSelDef.id != 'string') { return null; }
 var id = oSelDef.id.replace(/^\s+|\s+$/g,"");
 if(typeof oSelDef.name != 'string' || oSelDef.name.length==0) { oSelDef.name = id; }
 var htm = ['<select id="' + id + '" name="' + oSelDef.name + '"'];
 var aAttr = oSelDef.attr;
 if( this.__isArray(aAttr) ) {
     for(var i=0, len = aAttr.length; i < len; i++)
     {
         var tmp = aAttr[i].split('=');
         if(tmp.length > 1) {
             htm.push(' ' + tmp[0] + '="' + tmp[1] + '"');
         }
     }
 }
 htm.push('>');
     /* agrega los options */
 for(var i=0, len = aOp.length; i < len; i++)
 {
     var op = aOp[i];
     htm.push('<option');
     var aAttr = op.attr;
     if( this.__isArray(aAttr) ) {
         for(var e=0, len2 = aAttr.length; e < len2; e++)
         {
             var tmp = aAttr[e].split('=');
             if(tmp.length > 1) {
                 htm.push(' ' + tmp[0] + '="' + tmp[1] + '"');
             }
         }
         htm.push('>' + ((op.text)?op.text:'') + '</option>');
     }
 }
 htm.push('</select>');
 return htm.join('');
},

/* funcion interna */
/* acomoda un combo de acuerdo con el texto o el valor de sus options 
        sensitive (valor booleano) indica si la busqueda sera sensible a mayusculas/minusculas  */
__SortBy:function(ob, by, sensitive) {
 if(!this.__ctrlOBJ(ob) || !this.IsSelected(ob)) { return false; }
 if(!sensitive) { sensitive=false; }
 var b = new Array();
 var c = ob.getElementsByTagName('option');
 for ( var i in c )
 {
     try {
         b.push( { text:((by=='T')?c[i].text:c[i].value),
                      node:ob[i].cloneNode(true),
                      selected:ob[i].selected} );
     } catch(e) { continue; }
 }
 if(sensitive)
 {
     b.sort(function(opt1, opt2) {
         return opt1.text < opt2.text ? -1 : opt1.text > opt2.text ? 1 : 0;
     });
 }else{
     b.sort(function(opt1, opt2) {
         return opt1.text.toLowerCase() < opt2.text.toLowerCase() ? -1 :
                         opt1.text.toLowerCase() > opt2.text.toLowerCase() ? 1 : 0;
     });
 }
 this.Clear(ob);
 for ( var i in c )
 {
     try {
         var d = b.shift();
         ob.appendChild(d.node);
         if(d.selected) { ob.options[ob.options.length-1].selected=true;}
     } catch(e) { continue; }
 }
 return true;
},


/* acomoda un combo de acuerdo con el texto de sus options 
        sensitive (valor booleano) indica si la busqueda sera sensible a mayusculas/minusculas  */
SortByText:function(ob, sensitive) {
 return this.__SortBy(ob, 'T', sensitive);
},

/* acomoda un combo de acuerdo con el valor de sus options 
        sensitive (valor booleano) indica si la busqueda sera sensible a mayusculas/minusculas  */
SortByValue:function(ob, sensitive) {
 return this.__SortBy(ob, 'V', sensitive);
}
}

Su uso es bien sencillo:


<div id='j'></div>


<div><button type="button" onClick="GenCombo()">Generar Combo</button></div>
<div><button type="button" onClick="sortCB('T')">Sort por text</button></div>
<div><button type="button" onClick="sortCB('V')">Sort por value</button></div>

<script language="javascript">
/* creacion del combo mediante javascript */
cb = $CB.ComboObject;
//id del select
cb.setID('myCbo');
//atributos de la etiqueta <select>
cb.addSelectAttribute('class=prueba nodes')
cb.addSelectAttribute('size=5')
//definicion de los options
cb.addOption('W 1', ['value=33','selected=true', 'style=background-color:red;'])
cb.addOption('a 1', ['value=11'])
cb.addOption('e 2', ['value=123'])

//ejemplo de creacion del combo
function GenCombo() {
    var j = $CB.CreateHTMLCombo(cb.getComboObject())
    cbo = document.getElementById('j')
    cbo.innerHTML = j
    document.getElementById('myCbo').onchange=mostrar;
}

//ejemplo de ordenacion de combo
function sortCB(val) {
    alert(cbo.innerHTML)
    switch(val) {
        case 'T':
            $CB.SortByText(document.getElementById('myCbo'), true);
            break;
        case 'V':
            $CB.SortByValue(document.getElementById('myCbo'), true);
            break;
    }
    alert(cbo.innerHTML)
}

function mostrar()
{
    var ob = $CB.ObjectSelectedOption(this)
    alert(ob.innerHTML)
}

</script>

Pueden crear el combo mediante el uso de este objeto o pueden manipular uno existente en la página.

Personalmente, cuando se trata de combos dinámicos, cargo la página sin el combo y luego, mediante AJAX, busco el contenido del mismo y genero el combo dentro de un contenedor existente en la página, generalmente un SPAN.

Serializar un DataSet a JSON

2008-08-18T19:40:00.002-03:00

Recientemente me encontre con la necesidad en ASP.NET de serializar un DataSet para enviarlo, via AJAX, a un browser, para luego allí procesarlo convenientemente.

Un buen compañero de trabajo, Leonardo Villalva, es el autor de un código en el viejo ASP, para serializar ADO Recordset a formato JSON. Basándome en ese código arme esta clase que permite hacer la misma tarea en .NET, y aquí la publico para compartirla con ustedes.




' ------------------------------------------------------------------
' Clase   : JSONSerializer
' Autor   : Julio González
' Fecha   : 14/07/2008
' ------------------------------------------------------------------
Imports Microsoft.VisualBasic
Imports System.Data


Namespace JG
   Public Class JSONSerializer
      Public Function DataTableSerializer(ByVal dt As DataTable) As String
         Dim JsonString As New StringBuilder()
         Dim tmpR, tmpA As StringBuilder

         'el objeto no existe o no tiene filas
         If dt Is Nothing Or dt.Rows.Count = 0 Then
            Return String.Empty
         End If

         'serializo
         JsonString.Append("{")
         JsonString.Append("filas:[")
         tmpA = New StringBuilder
         For Each f As DataRow In dt.Rows
            tmpA.Append("{")
            tmpR = New StringBuilder
            For Each c As DataColumn In dt.Columns
               tmpR.Append(c.ColumnName & ":""" & f(c.ColumnName).ToString & """,")
            Next
            tmpA.Append((tmpR.ToString.Remove((tmpR.ToString.Length - 1), 1)))
            tmpA.Append("},")
         Next
         JsonString.Append(tmpA.ToString.Remove((tmpA.ToString.Length - 1), 1))
         JsonString.Append("]}")

         Return JsonString.ToString
      End Function
   End Class

End Namespace

Espero que les sea útil.

Clase para acceder a la base de datos Oracle desde .NET

2008-08-14T14:27:00.009-03:00

Esta es una clase para ASP.NET, que trata de encapsular la conexión y las solicitudes a la base de datos Oracle, que es la que utilizo en mi trabajo.

Tiene todos los métodos necesarios para solicitar QUERYS comunes, o ejecutar complejos Procedimientos Almacenados, incluso con la posibilidad de recibir uno o más sys_refcursor como retorno.

El código:


' ------------------------------------------------------------------
' Clase   : DBConnector
' Autor   : Julio González
' Fecha   : 07/08/2007
' ------------------------------------------------------------------
Imports Microsoft.VisualBasic
Imports System.Data
Imports System.Data.OracleClient

Namespace JG

  ''' DBConnector
 '''
 ''' Conecta con una base de datos oracle utilizando
 ''' 
Public Class OraDBConnector
  '-----------------------
  ''' ParameterDef
    '''
  ''' Estructura para pasar los datos de los parámetros de los procedimientos.
  ''' Los miembros de esta estructura llevan los nombre y tipos que debe
  ''' recibir la clase Parameters de Oracle
  ''' </summary>
  ''' <remarks>#</remarks>
  Public Structure ParameterDef
     Public ParamName As String
     Public ParamType As OracleType
     Public ParamSize As Integer
     Public ParamDirection As ParameterDirection
     Public ParamValue As Object
  End Structure

  '-----------------------
  ''' <summary>
  ''' String de conección a la base de datos
  ''' </summary>
  ''' <remarks></remarks>
  Private _strConn As String
  ''' <summary>
  ''' Objeto Connection de Oracle
  ''' </summary>
  ''' <remarks></remarks>
  Private _conn As New OracleConnection
  ''' <summary>
  ''' Objeto Commander de Oracle que se utilirá para ejecutar procedimientos
  ''' y consultas
  ''' </summary>
  ''' <remarks></remarks>
  Private _Comm As New OracleCommand
  ''' <summary>
  ''' Objeto DataAdapter de Oracle para convertir las consultas en DataSet
  ''' </summary>
  ''' <remarks></remarks>
  Private _DataAdapder As New OracleDataAdapter

  '-----------------------
  ''' <summary>
  ''' Constructor de la clase
  ''' </summary>
  ''' <remarks></remarks>
  Public Sub New()
     Me._strConn = Nothing
  End Sub 'New

  '-----------------------
  ''' <summary>
  ''' Establece o retorna la cadena de conexión utilizada
  ''' </summary>
  ''' <strConn>Cadena de conexión</strConn>
  ''' <returns>Cadena de conexión</returns>
  ''' <remarks></remarks>
  Public Property dbConnectionString() As String
     Get
        Return _strConn
     End Get
     Set(ByVal strConn As String)
        _strConn = strConn
     End Set
  End Property  'dbConnectionString

  '-----------------------
  ''' <summary>
  ''' Método para abrir la conexión con la base de datos
  ''' </summary>
  ''' <remarks></remarks>
  Public Sub Open()
     If Me._strConn.Length = 0 Then
        Throw New System.Exception("DBConnector.dbConnect: No se estableció el conector")
        Exit Sub
     End If
     'trata de conectar
     Try
        Me._conn.ConnectionString = _strConn
        If Me._conn.State = ConnectionState.Open Then
           Me._conn.Close()
        End If
        Me._conn.Open()
     Catch ex As Exception
        Throw New System.Exception("DBConnector.dbConnect: " & ex.Message)
     End Try
  End Sub 'Open
  '-----------------------
  ''' <summary>
  ''' Método para obtener el objeto Connection establecido.
  ''' </summary>
  ''' <returns>Objeto conexión</returns>
  ''' <remarks></remarks>
  Public ReadOnly Property getConnection() As OracleConnection
     Get
        Return Me._conn
     End Get
  End Property 'getConnection

  '-----------------------
  ''' <summary>
  ''' Método para cerrar la conexión a la base de datos
  ''' </summary>
  ''' <remarks></remarks>
  Public Sub Close()
     Try
        If _conn.State = ConnectionState.Open Then
           _conn.Close()
           _conn = Nothing
        End If
     Catch ex As Exception
        'nada
     End Try
  End Sub 'Close
  'rellena un array list del usuario con parametros numericos
  Public Function AddParameter(ByVal Name As String, ByVal Value As Object, _
                                Optional ByVal Direction As ParameterDirection = _
                                ParameterDirection.Input) As ParameterDef
     Dim p As New ParameterDef
     With p
        .ParamName = Name
        .ParamType = OracleType.Number
        .ParamDirection = Direction
        .ParamValue = IIf(Value Is Nothing, DBNull.Value, Value)
     End With
     Return p
  End Function
  'rellena un array list del usuario con parametros string
  Public Function AddParameter(ByVal Name As String, ByVal Value As String, _
                                ByVal Size As Integer, _
                                Optional ByVal Direction As ParameterDirection = _
                                ParameterDirection.Input) As ParameterDef
     Dim p As New ParameterDef
     With p
        .ParamName = Name
        .ParamType = OracleType.VarChar
        .ParamDirection = Direction
        .ParamSize = Size
        .ParamValue = IIf(String.IsNullOrEmpty(Value), DBNull.Value, Value)
     End With
     Return p
  End Function
  'rellena un parametro para datos output por default
  Public Function AddParameter(ByVal Name As String, ByVal Type As OracleType) As ParameterDef
     Dim p As New ParameterDef
     With p
        .ParamName = Name
        .ParamType = Type
        .ParamDirection = ParameterDirection.Output
     End With
     Return p
  End Function
  Public Function AddParameter(ByVal Name As String, ByVal Type As OracleType, ByVal Size As Integer) _
  As ParameterDef
     Dim p As New ParameterDef
     With p
        .ParamName = Name
        .ParamType = Type
        .ParamSize = Size
        .ParamDirection = ParameterDirection.Output
     End With
     Return p
  End Function


  '-----------------------
  ''' <summary>
  ''' Ejecuta una sentencia SQL del tipo SELECT y retorna un objeto DataReader
  ''' </summary>
  ''' <param name="selectQuery">Sentencia SQL del tipo SELECT</param>
  ''' <returns>Objeto DataReader. En caso de error retorna NOTHING</returns>
  ''' <remarks></remarks>
  Public Function QueryToReaderData(ByVal selectQuery As String) As OracleDataReader
     Dim _Reader As OracleDataReader

     Try
        'valida el texto SQL
        Me.CheckSQLString(selectQuery)

        'valida el estado de la conexión
        Me.ValidateConnecton()

        Me._Comm = New OracleCommand(selectQuery, Me._conn)
        Me._Comm.CommandTimeout = 90
        _Reader = _Comm.ExecuteReader()
        Return _Reader
     Catch ex As Exception
        Throw New System.Exception("DBConnector.ReaderData: " _
                & ex.Message & " (" & selectQuery & ")")
        Return Nothing
     Finally
        Me._Comm = Nothing
     End Try
  End Function 'QueryToReaderData
  '-----------------------
  ''' <summary>
  ''' Ejecuta una sentencia SQL del tipo DELETE y retorna la cantidad de filas afectadas
  ''' </summary>
  ''' <param name="deleteQuery">Sentencia del tipo DELELE</param>
  ''' <returns>Un entero que representa la cantidad de filas afectadas.
  ''' En caso de error retorna NOTHING
  ''' </returns>
  ''' <remarks></remarks>
  Public Function Delete(ByVal deleteQuery As String) As Integer
     Try
        'controlo la sentencia
        Me.CheckSQLString(deleteQuery, "DELETE")

        'valida el estado de la conexión
        Me.ValidateConnecton()

        'ejecuto la consulta
        Dim recAfec As Integer
        recAfec = Me.ProcessExecuteNoQuery(deleteQuery)
        Return recAfec
     Catch ex As Exception
        Throw New System.Exception("DBConnector.Delete: " & ex.Message _
              & " (" & deleteQuery & ")")
        Return Nothing
     End Try
  End Function 'Delete
  '-----------------------
  ''' <summary>
  ''' Ejecuta una sentencia SQL del tipo DELETE y retorna la cantidad de filas afectadas
  ''' </summary>
  ''' <param name="insertQuery">Sentencia del tipo INSERT</param>
  ''' <returns>Un entero que representa la cantidad de filas afectadas.
  ''' En caso de error retorna NOTHING
  ''' </returns>
  ''' <remarks></remarks>
  Public Function Insert(ByVal insertQuery As String) As Integer
     Try
        'valido el texto SQL
        Me.CheckSQLString(insertQuery, "INSERT")

        'valido la conexión
        Me.ValidateConnecton()

        Dim recAfec As Integer
        recAfec = Me.ProcessExecuteNoQuery(insertQuery)
        Return recAfec
     Catch ex As Exception
        Throw New System.Exception("DBConnector.Insert: " & ex.Message)
        Return Nothing
     End Try
  End Function 'Insert
  '-----------------------
  ''' <summary>
  ''' Procedimiento privado para atender a los procedimientos públicos
  ''' DELETE e INSERT
  ''' </summary>
  ''' <param name="strSQL">Sentencia SQL a ejecutar</param>
  ''' <returns>Cantidad de filas afectadas</returns>
  ''' <remarks></remarks>
  Private Function ProcessExecuteNoQuery(ByVal strSQL As String) As Integer
     Try
        'valida el estado de la conexión
        ValidateConnecton()

        Dim recAfec As Integer
        Me._Comm = New OracleCommand(strSQL, _conn)
        Me._Comm.CommandTimeout = 90
        recAfec = Me._Comm.ExecuteNonQuery()
        Return recAfec
     Catch ex As Exception
        Throw New System.Exception(ex.Message & " (" & strSQL & ")")
        Return Nothing
     Finally
        Me._Comm = Nothing
     End Try
  End Function
  '-----------------------
  ''' <summary>
  ''' Ejecuta un query y retorna la primera columna de la primera fila
  ''' </summary>
  ''' <param name="selectQuery">Sentencia SQL a ejecutar</param>
  ''' <returns>Valor de la primera columna de la primera fila</returns>
  ''' <remarks></remarks>
  Public Function ExecScalar(ByVal selectQuery As String) As String
     Try
        'controlo la sentencia
        Me.CheckSQLString(selectQuery)

        'valida el estado de la conexión
        Me.ValidateConnecton()

        Me._Comm = New OracleCommand(selectQuery, _conn)
        Me._Comm.CommandTimeout = 90
        Dim strResult As String
        strResult = Me._Comm.ExecuteScalar().ToString()
        Return strResult

     Catch ex As Exception
        Throw New System.Exception("DBConnector.ExecScalar: " _
                  & ex.Message & " (" & selectQuery & ")")
        Return Nothing
     Finally
        _Comm = Nothing
     End Try
  End Function  'ExecScalar
  '-----------------------
  ''' <summary>
  ''' Ejecuta una sentencia del tipo SELECT y retorna un objeto DataTable
  ''' </summary>
  ''' <param name="selectQuery">Sentencia SQL a ejecutar</param>
  ''' <returns>Objeto DataTable con el resultado de la consulta</returns>
  ''' <remarks></remarks>
  Public Function QueryToDataTable(ByVal selectQuery As String) As DataTable
     Try
        'valida el texto SQL
        Me.CheckSQLString(selectQuery)

        'valida el estado de la conexión
        ValidateConnecton()

        Me._Comm = New OracleCommand(selectQuery, Me._conn)
        Dim myDataTable As New DataTable
        Me._DataAdapder = New OracleDataAdapter(Me._Comm)
        Me._Comm.CommandTimeout = 300
        Me._Comm.CommandType = CommandType.Text
        Me._DataAdapder.Fill(myDataTable)

        Return myDataTable
     Catch ex As Exception
        Throw New System.Exception("DBConnector.FillDataTable: " _
                        & ex.Message & " (" & selectQuery & ")")
        Return Nothing
     Finally
        Me._Comm = Nothing
     End Try
  End Function  'QueryToDataTable
  '-----------------------
  ''' <summary>
  ''' Ejecuta una sentencia del tipo SELECT y retorna un objeto DataSet
  ''' </summary>
  ''' <param name="selectQuery">Sentencia SQL a ejecutar</param>
  ''' <returns>Objeto DataSet con el resultado de la consulta</returns>
  ''' <remarks></remarks>
  Public Function QueryToDataSet(ByVal selectQuery As String, _
               Optional ByVal srcTable As String = "myTable") As DataSet
     Try
        'valida el texto SQL
        Me.CheckSQLString(selectQuery)

        'valida el estado de la conexión
        Me.ValidateConnecton()

        Me._Comm = New OracleCommand(selectQuery, Me._conn)
        Dim MyDataSet As New DataSet
        Me._DataAdapder = New OracleDataAdapter(Me._Comm)
        Me._Comm.CommandTimeout = 300
        Me._Comm.CommandType = CommandType.Text
        Me._DataAdapder.Fill(MyDataSet, srcTable)
        Return MyDataSet
     Catch ex As Exception
        Throw New System.Exception("DBConnector.FillDataSet: " _
                    & ex.Message & " (" & selectQuery & ")")
        Return Nothing
     Finally
        Me._Comm = Nothing
     End Try
  End Function  'QueryToDataSet
  '-----------------------
  ''' <summary>
  ''' Genera acumulacion de tablas en un mismo DataSet que el usuario debe pasar
  ''' como parámetro
  ''' </summary>
  ''' <param name="selectQuery">Sentencia SQL a ejecutar</param>
  ''' <param name="srcTable">Nombre de la tabla</param>
  ''' <param name="myDataSet">Objeto DataSet del usuario</param>
  ''' <returns>Objeto DataSet con el resultado de la consulta</returns>
  ''' <remarks></remarks>
  Public Function QueryToDataSet(ByVal selectQuery As String, _
                        ByVal srcTable As String, _
                        ByVal myDataSet As DataSet) As DataSet
     Try
        'valida el texto SQL
        Me.CheckSQLString(selectQuery)

        'valida el estado de la conexión
        Me.ValidateConnecton()

        Me._Comm = New OracleCommand(selectQuery, _conn)
        Me._DataAdapder = New OracleDataAdapter(_Comm)
        Me._Comm.CommandTimeout = 300
        Me._Comm.CommandType = CommandType.Text
        Me._DataAdapder.Fill(myDataSet, srcTable)
     Catch ex As Exception
        Throw New System.Exception("DBConnector.FillDataSet (vs): " _
                    & ex.Message & " (" & selectQuery & ")")
     Finally
        Me._Comm = Nothing
     End Try

     Return myDataSet
  End Function  'QueryToDataSet
  '-----------------------
  ''' <summary>
  ''' Ejecuta un procedimiento almacenado
  ''' </summary>
  ''' <param name="CommandText">Texto de invocación al procedimiento almacenado</param>
  ''' <param name="Parameters">
  ''' Objeto ArrayList conteniendo un objeto JG.OraDbConnector.ParameterDef
  ''' por cada parámetro que debe recibir el procedimiento almacenado.
  ''' </param>
  ''' <param name="keyReader">
  ''' Opcional: Clave de acceso al objeto DataReader
  ''' </param>
  ''' <returns>
  ''' Retorna un ojeto HashTable con el resultado de la ejecución.
  ''' Si el procedimiento almacenado tiene uno o más parámetros OUTPUT del tipo 
  ''' REF CURSOR, el objeto HashTable retornado contiene un elemento cuya clave es
  ''' _DR conteniendo un objeto OracleDataReader con todos los cursores.
  ''' El resto de los elementos del objeto retornado son los parámetros de tipo
  ''' IN OUT o OUT (excepto los ref cursor). La clave de acceso a cada uno
  ''' de los elementos del HashTable es el nombre definido en ParamName.
  ''' </returns>
  ''' <remarks>
  ''' El objeto OracleDataReader contiene los REF CURSOR en el mismo orden en que se
  ''' pasaron los parametros de tipo OracleType.Cursor
  ''' </remarks>
  Public Function ExecuteStoredProcedure(ByVal CommandText As String, _
                      Optional ByVal Parameters As ArrayList = Nothing, _
                      Optional ByVal keyReader As String = "_DR") As Hashtable
     Dim _parameters As ArrayList = Parameters
     Dim _retVal As New Hashtable
     Dim _Reader As OracleDataReader

     Me._Comm = New OracleCommand()
     With Me._Comm
        .CommandText = CommandText
        .CommandType = CommandType.StoredProcedure
        .Connection = Me._conn
     End With
     Dim j As New StringBuilder
     Dim i As Integer
     'ejecuto el procedimiento
     Try
        'agrego los parámetros
        Me.AddParameters(_parameters)
        With Me._Comm.Parameters
           For i = 0 To .Count - 1
              j.Append(.Item(i).ParameterName & ": " & .Item(i).Value & " (" & .Item(i).Direction & ")" & " // ")

           Next i
        End With

        _Reader = Me._Comm.ExecuteReader
        _retVal.Add(keyReader, _Reader)  'agrego los refcursor a la tabla
     Catch ex As Exception
        Throw New System.Exception("DBConnector.ExecuteStoredProcedure: " _
                & ex.Message & " (" & CommandText & ") " & j.ToString)
        Me._Comm = Nothing
        Return Nothing
     End Try
     'asigno los parámetros

     Try
        If _parameters.Count > 0 Then
           For Each param As ParameterDef In _parameters
              With param
                 If .ParamDirection = ParameterDirection.InputOutput Or _
                    .ParamDirection = ParameterDirection.Output Then
                    If .ParamType <> OracleType.Cursor Then
                       _retVal.Add(.ParamName, Me._Comm.Parameters.Item(.ParamName).Value)
                    End If
                 End If
              End With
           Next

        End If
     Catch ex As Exception
        Throw New System.Exception("DBConnector.ExecuteStoredProcedure: " & ex.Message)
     End Try

     Return _retVal
  End Function  'ExecuteStoredProcedure
  '-----------------------
  ''' <summary>
  ''' Ejecuta una función almacenado
  ''' </summary>
  ''' <param name="CommandText">Texto de invocación al procedimiento almacenado</param>
  ''' <param name="Parameters">
  ''' Objeto ArrayList conteniendo un objeto JG.OraDbConnector.ParameterDef
  ''' por cada parámetro que debe recibir el procedimiento almacenado.
  ''' </param>
  ''' <returns>
  ''' Retorna un ojeto HashTable con el resultado de la ejecución.
  ''' Si el procedimiento almacenado tiene uno o más parámetros OUTPUT del tipo 
  ''' REF CURSOR, el objeto HashTable retornado contiene un elemento cuya clave es
  ''' _DR conteniendo un objeto OracleDataReader con todos los cursores.
  ''' El resto de los elementos del objeto retornado son los parámetros de tipo
  ''' IN OUT o OUT (excepto los ref cursor). La clave de acceso a cada uno
  ''' de los elementos del HashTable es el nombre definido en ParamName.
  ''' </returns>
  ''' <remarks>
  ''' El objeto OracleDataReader contiene los REF CURSOR en el mismo orden en que se
  ''' pasaron los parametros de tipo OracleType.Cursor
  ''' </remarks>
  Public Function ExecuteStoredFunction(ByVal CommandText As String, _
                  ByVal Parameters As ArrayList) As Hashtable
     Dim __nomObj As String = "DBConnector.ExecuteStoredFunction: "
     Dim _parameters As ArrayList = Parameters
     Dim _retVal As New Hashtable
     Dim _Reader As OracleDataReader
     Dim outParams As Integer = 0

     'verifico cuantos parámetros return_value hay
     For Each param As ParameterDef In _parameters
        With param
           If .ParamDirection = ParameterDirection.ReturnValue Then
              outParams = outParams + 1
           End If
        End With
     Next
     'controlo que sólo se pase un parámetro return_value
     If outParams = 0 Then
        Throw New System.Exception(__nomObj & "No se incluyó el parámetro RETURN_VALUE.")
        Return Nothing
     End If
     If outParams > 1 Then
        Throw New System.Exception(__nomObj & "Se incluyó más de un parámetro RETURN_VALUE.")
        Return Nothing
     End If

     'ejecuto el procedimiento
     Try
        'parámetros del comando
        _Comm = New OracleCommand()
        With _Comm
           .CommandText = CommandText
           .CommandType = CommandType.StoredProcedure
           .Connection = _conn
        End With

        'agrego los parámetros de la función
        AddParameters(_parameters)
        _Reader = _Comm.ExecuteReader()
        _retVal.Add("_DR", _Reader)  'agrego los refcursor a la tabla
     Catch ex As Exception
        Throw New System.Exception(__nomObj & ex.Message & " (" & CommandText & ")")
        _Comm = Nothing
        Return Nothing
     End Try
     'asigno el valor de retorno
     For Each param As ParameterDef In _parameters
        With param
           If .ParamDirection = ParameterDirection.Input Or _
              .ParamDirection = ParameterDirection.Output Or _
              .ParamDirection = ParameterDirection.ReturnValue Then
              If .ParamType <> OracleType.Cursor Then
                 _retVal.Add(.ParamName, _Comm.Parameters.Item(.ParamName).Value)
              End If
           End If
        End With
     Next
     Return _retVal
  End Function  'ExecuteStoredFunction
  '-----------------------
  ''' <summary>
  ''' Asigna los parametros a un objeto OracleCommander
  ''' </summary>
  ''' <param name="Parameters">
  ''' Objeto ArrayList que contiene los parámetros a asignar al
  ''' objeto OracleCommand
  ''' </param>
  ''' <remarks></remarks>
  Private Sub AddParameters(ByVal Parameters As ArrayList)
     If Parameters Is Nothing Then Exit Sub
     If Parameters.Count = 0 Then Exit Sub

     For Each param As ParameterDef In Parameters
        With param
           If .ParamType = OracleType.Cursor And .ParamDirection <> ParameterDirection.Output Then
              Throw New System.Exception("(AddParameters): Se ha definido un tipo de parámetro " _
                  & "CURSOR cuya dirección no es OUT (" & .ParamName & ")")
              Exit Sub
           End If
           Me._Comm.Parameters.Add(.ParamName, .ParamType)
           If .ParamSize <> Nothing Then
              Me._Comm.Parameters.Item(.ParamName).Size = .ParamSize
           End If
           If .ParamValue IsNot Nothing Then
              Me._Comm.Parameters.Item(.ParamName).Value = .ParamValue
           End If
           If .ParamDirection <> Nothing Then
              Me._Comm.Parameters.Item(.ParamName).Direction = .ParamDirection
           End If
        End With
     Next
  End Sub
  '-----------------------
  ''' <summary>
  ''' Controla si la conexión esta activa
  ''' </summary>
  ''' <remarks>
  ''' Esta función previene de cortes de conexión.
  ''' </remarks>
  Private Sub ValidateConnecton()
     If Me._conn Is Nothing Then
        Throw New System.Exception("No se estableció la conexión con la base de datos.")
        Exit Sub
     End If
     If Me._conn.State = ConnectionState.Broken Then
        Throw New System.Exception("Se ha perdido la conexión con la base de datos.")
        Exit Sub
     End If
     If Me._conn.State = ConnectionState.Closed Then
        Throw New System.Exception("La conexión con la base de datos está cerrada.")
        Exit Sub
     End If
     If Me._conn.State = ConnectionState.Connecting Or _
        Me._conn.State = ConnectionState.Executing Or _
        Me._conn.State = ConnectionState.Fetching Then
        Throw New System.Exception("La conexión a la base de datos está ocupada.")
        Exit Sub
     End If
  End Sub
  '-----------------------
  ''' <summary>
  ''' Corrobora si la sentencia SQL es del tipo esperado.
  ''' </summary>
  ''' <param name="sqlString">Sentencia SQL a controlar</param>
  ''' <param name="typeSQL">
  ''' Opcional. Tipo de sentencia esperado. Por omisión: SELECT.
  ''' </param>
  ''' <returns>La sentencia SQL enviada sin espacios en blanco irrelevantes</returns>
  ''' <remarks></remarks>
  Private Function CheckSQLString(ByVal sqlString As String, _
                   Optional ByVal typeSQL As String = "SELECT") As String
     'verifico que venga el dato y que sea un SQL DELETE
     sqlString = Trim(sqlString)
     If sqlString.Length = 0 Then
        Throw New System.Exception("La sentencia SQL está vacía.")
        Return sqlString
     End If
     If Not UCase(sqlString).StartsWith(typeSQL) Then
        Throw New System.Exception("La sentencia SQL no es del tipo esperado.")
        Return sqlString
     End If
     Return sqlString
  End Function
  '-----------------------
  ''' <summary>
  ''' Previene el no cierre de la base de datos al morir el objeto conxión
  ''' </summary>
  ''' <remarks></remarks>
  Protected Overrides Sub Finalize()
     Me.Close()
     MyBase.Finalize()
  End Sub 'Finalize

  '-----------------------
  ''' <summary>
  ''' Convierte un DataReader en un DataSet
  ''' </summary>
  ''' <remarks></remarks>
  Public Function ConvertDataReaderToDataSet(ByVal reader As OracleDataReader) As DataSet
     Dim dataSet As DataSet = New DataSet()
     Dim schemaTable As DataTable = reader.GetSchemaTable()
     Dim dataTable As DataTable = New DataTable()
     Dim intCounter As Integer

     For intCounter = 0 To schemaTable.Rows.Count - 1
        Dim dataRow As DataRow = schemaTable.Rows(intCounter)
        Dim columnName As String = CType(dataRow("ColumnName"), String)
        Dim column As DataColumn = New DataColumn(columnName, _
                                CType(dataRow("DataType"), Type))
        dataTable.Columns.Add(column)
     Next

     dataSet.Tables.Add(dataTable)
     While reader.Read()
        Dim dataRow As DataRow = dataTable.NewRow()
        For intCounter = 0 To reader.FieldCount - 1
           dataRow(intCounter) = reader.GetValue(intCounter)
        Next
        dataTable.Rows.Add(dataRow)
     End While

     Return dataSet
  End Function
End Class  'DBConnector
End Namespace

Ejemplos:

Este ejemplo muestra como ejecutar una consulta simple. Se trata de una página que tiene un TEXTAREA, donde el usuario escribe o pega una consulta, la que es ejecutada por la clase que conecta con la base.


Imports JG
Imports System.Data
Imports System.Threading
Imports System.Globalization

Partial Class _Default
Inherits System.Web.UI.Page

    'ejecuta una sentencia sql capturade del input SQLScript de la pagina.
Protected Sub EjecutaCodigo()
  Dim Sql As String = SQLScript.Value
  Dim conn As New OraDBConnector()
  Dim table As DataTable
  'ServidorDestino es un combo que tiene como Value, la clave de cadena de conexion
  Dim destConn As String = Me.ServidorDestino.SelectedItem.Value

  Try
     'rescata la cadena de conexion desde el archivo web.config
     conn.dbConnectionString = ConfigurationManager.AppSettings.Item(destConn).ToString()
     conn.Open()
  Catch ex As Exception
     Me.lblError.Text = ex.Message.ToString()
     Exit Sub
  End Try
  Try
     'ejecuta la sentencia sql, que es devuelta en un DataTable
     table = conn.QueryToDataTable(Sql)
  Catch ex As Exception
     Me.lblError.Text = ex.Message.ToString()
     Exit Sub
  Finally
     conn.Close()
  End Try
  If table.Rows.Count = 0 Then
     Me.lblError.Text = "No hay filas para la consulta dada."
     Exit Sub
  End If
  'agrega el data table a un GridView
  With Me.gvDatos
     .DataSource = table
     .DataBind()
  End With
  btCSV.Visible = True
End Sub

End Class

Este ejemplo muestra como ejecutar un procedimiento almacena en la base que, en este caso, retorna un sys_refcursor.

>
'----------------------------------------
'rellena un combo con usuarios
Private Sub RellenarComboUsuarios()
  Dim conn As OraDBConnector

  'apertura de la conexion
  Try
     conn = AbrirConexionBD()
  Catch ex As Exception
     Throw New System.Exception(ex.Message)
     Exit Sub
  End Try

  'parametros del paquete
  Dim arr As New ArrayList
  arr.Add(conn.AddParameter("pv_mca_habilitados", "S", 1))
  arr.Add(conn.AddParameter("rv_cursor", OracleType.Cursor))

  'ejecuta el procedimiento
  Dim htProc As Hashtable
  htProc = conn.ExecuteStoredProcedure( _
           "pk_net_art_traslados_admin.User_Enum_Usuarios", arr)

  Dim ODR As OracleDataReader
  ODR = htProc("_DR") 'obtengo el OracleDataReader con el cursor
  If Not ODR.HasRows Then
     conn.Close()
     Exit Sub
  End If

  'asigno las filas al combo
  Dim ds As DataSet
  ds = conn.ConvertDataReaderToDataSet(ODR)
  conn.Close()
  With ddlUsuarios
     .DataSource = ds
     .DataTextField = "nombre"
     .DataValueField = "cod_user"
     .DataBind()
     .Items.Insert(0, New ListItem("Seleccione", 0))
  End With
  ddlUsuarios.SelectedIndex = 5
End Sub 'RellenarComboUsuarios

Este ejemplo es similar al anterior, pero muestra otra forma de informar los parámetros del procedimiento almacenado.


'lee los menues por perfil
Private Sub BuscarMenuesPorPerfil(ByVal perfil As Integer)
  Dim conn As New OraDBConnector()
  Dim sContext As New SiteContext(Request.Url.Host)
  Dim connStr As String
  Dim usr As String = User.Identity.Name

  'apertura de la conexion
  Try
     connStr = sContext.GetDBConnectionString()
     conn.dbConnectionString = connStr
     conn.Open()
  Catch ex As Exception
     Throw New System.Exception("BuscarMenuesPorPerfil: " & ex.Message)
     Exit Sub
  End Try

  'busco los datos del usuario
  Dim param As New OraDBConnector.ParameterDef
  Dim arr As New ArrayList

  'codigo del perfil
  With param
     .ParamName = "pv_cod_perfil"
     .ParamSize = 10
     .ParamType = OracleType.Number
     .ParamValue = perfil
  End With
  arr.Add(param)
  'cursor que retorna el paquete
  With param
     .ParamName = "rv_cursor"
     .ParamType = OracleType.Cursor
     .ParamDirection = Data.ParameterDirection.Output
     .ParamValue = Nothing
  End With
  arr.Add(param)

  'ejecuta el procedimiento
  Dim htProc As Hashtable
  htProc = conn.ExecuteStoredProcedure("pk_net_art_traslados_menu.Menues_Por_Perfil_Admin", arr)

  Dim ODR As OracleDataReader
  ODR = htProc("_DR") 'obtengo el OracleDataReader con el cursor

  'relleno el campo oculto ds_hide
  Dim ds As DataSet
  ds = conn.ConvertDataReaderToDataSet(ODR)
  conn.Close()
  'muestro el treeview
  RellenaTreeView1(ds)
End Sub

El archivo con el código puede ser bajado desde aquí.

Redireccionador de FORMS con imagen de espera

2008-08-14T13:49:00.007-03:00

Esta es una humilde contribución. Un código que se le puede ocurrir a cualquier principiante, pero que para mi es de mucha utilidad.

Se trata de una pequeña página hecha en ASP que puede ser llamada desde cualquier formulario, o enlace, que tomará el contenido de los objetos FORM o QUERYSTRING del objeto REQUEST de la presente solicitud, mostrará un mensaje de espera y redireccionará la petición a la página deseada.

Para lograr esto, debemos incluir un parámetro adicional en la solicitud: _dest, que es donde se informará cual es el verdadero destino de la solicitud.

El código:

<%
metodo = "get"
If Len(Request.Form) > 0 Then
   metodo = "post"
End If
%>
<html>
<head>
</head>
<body>
<center>
<div style="padding-top:100px">
   <span>Aguarde un instante, por favor...</span>
   &nbsp;&nbsp;<img src="../../img/wait30.gif">
</div>
</center>
<%
If metodo = "get" Then
%>
<script language="javascript" type="text/javascript">
    self.location.replace('<%= Request.QueryString("_dest") %>?<%= Request.QueryString %>')
</script>
<%
Else
%>
   <form method='post' action='<%= Request.Form("_dest") %>'>
<%
   aParams = Split(Request.Form, "&")
   For x = 0 To Ubound(aParams)
       aParam = Split(aParams(x), "=")
%>
       <input name="<%=aParam(0) %>" type="hidden" value="<%=Server.URLEncode(aParam(1))%>" />
<%
   Next
%>
   </form>
   <script language='javascript'>
        document.forms[0].submit();
    </script>
<%
End If
%>
</body>
</html>

Firefox y los rangos de texto (textRange)

2008-07-29T16:29:00.013-03:00

Estoy preparando un objeto para poder controlar las entradas de texto en los InputBox (de hecho ya lo tenía en una antigua librería javascript) mediante Expresiones Regulares, de modo de achicar un tanto el tamaño de la anterior, pero, además, para que me sirva de base para un futuro control de usuario web para ASP.NET, con el que estoy comenzando a trabajar.

El objeto en cuestión debe controlar distintos tipos de entradas: texto, caracteres especiales, fechas, números, etc. Todo esto para no tener que validar esto en el servidor y evitar los molestos retornos por errores del usuario a la hora de llenar un formulario.

Cuando lo tenga listo, lo subiré a este blog, para que ustedes lo "destrocen" a gusto. Pero no tengan muchas esperanzas, porque como dijera más arriba, este objeto se basa en una librería anterior que tengo, que tiene unos cuantos años de uso, lo que siempre garantiza que se le han pulido bien los errores. Pero siempre los hay.

El tema en cuestión de este artículo es que se me presentó un inconveniente en el momento de que mi evento keypress retornaba falso porque se había detectado que, por ejemplo, el caracter que estaba ingresando estaba fuera de lo permitido. Entonces "pinte" el texto e intenté reemplazar de un plumazo todo lo seleccionado.

Grande fue mi sorpresa al ver que el caracter que intentaba reemplazar lo seleccionado no era tomado, puesto que el evento keypress seguía rechazándolo.

Investigando un poco, pues di con la solución IE: antes de controlar el nuevo caracter ingresado, debía averiguar si el texto anterior estaba seleccionado total o parcialmente y borrar el rango que el usurio había pintado. Como se hace esto en IE:

if(Browser.IE) {
if (document.selection.type == "Text") {
var tr = document.selection.createRange();
tr.text = "";
}
}

Browser.IE es un objeto que me devuelve true si el navegador en Internet Explorer. document.selection es el objeto que contiene la selección que hemos hecho, cuya propiedad type tiene como valor None si no se ha seleccionado nada, o Text si se ha seleccionado texto, que es lo que nos ocupa.

Pues bien, creamos un objeto textRange mediante el método createRange del objeto selection (en el ejemplo caso tr) y podemos manipularlo a gusto.

Pero mis penas empezaron al tratar de emular este comportamiento en Firefox, no porque fuera difícil, sino por la carencia de documentación al respecto. Y, tal como vengo haciendo en este blog, acá les dejo el "cómo se hace", por si alguno de ustedes tiene este inconveniente:


if(obj.selectionStart < obj.selectionEnd) {
   if(String(noChar).search('37|39') == -1) {
     window.getSelection().collapseToStart()
   }
}

obj es el objeto que estoy validando (input). selectionStart contiene la posición inicial del "pintado" que, cuando no se está pintando el texto, tiene el mismo valor que selectionEnd. Por último, para borrar el texto seleccionada, basta con ejecutar el método collapseToStart.

Servidor web ASP.NET sin IIS (VS 2008)

2008-05-27T12:26:00.002-03:00

Esta nota es complemento de la anterior, Servidor web ASP.NET sin IIS, pero en relación con la nueva versión de Visual Studio 2008. Lo que expresa ese artículo sigue siendo posible, sólo que el programa webdev.webserver.exe fue cambiado de ubicación.

En VS2008 el servidor se encuentra en Program Files\Common Files\Microsoft Shared\DevServer\9.0\.

Objeto String de Javascript - Extensiones útiles

2008-04-14T12:47:00.002-03:00

Recopilando un poco de funciones que tenía por aquí y por allá, más algunas otras encotradas en la web, de personas que se las han ingeniado para extender el magro objeto String de Javascript, les dejo aquí el código fuente de algunas utilidades añadidas al objeto origial. Espero les sean útiles. Y si tienen sugerencias, por favor acerquen el código para compartir con todos.

String.prototype.left = function(n){
  // Devuelve los n primeros caracteres de la cadena
  var s = this.toString()
  if(n>s.length) {
      n=t.length
  }

  return s.substring(0, n)
}

String.prototype.right = function(n){
  // Devuelve los n últimos caracteres de la cadena
  var s = this.toString()
  var t=s.length

  if(n>t) {
      n=t
  }

  return s.substring(t-n, t)
}

String.prototype.mid = function(n, c){
  // Devuelve una cadena desde la posición n, con c caracteres
  // Si c = 0 devolver toda la cadena desde la posición 
  var s = this.toString()

  // Si sólo se pasan los dos primeros argumentos
  if(arguments.length<2) {
      c=s.length-n+1
  }
  if(c<1) {
      c=s.length-n+1
  }
  if(n+c >s.length) {
     c=s.length-n+1
  }
  if(n>s.length) {
      return ""
  }

  return s.substring(n-1,n+c-1)
}

String.prototype.lTrim = function(){
  // Devuelve una cadena sin los espacios del principio
  var s = this.toString()
  if( s.length == 0 ) { return s }
  if( s == ' ' ) { return '' }

  // Busca el primer caracter <> de un espacio
  for(var i=0; i<=s.length-1; i++)
  {
      if(s.substring(i,i+1) != ' ')
      {
          var j=i
          break
      }
  }
  return s.substring(j, s.length)
}

String.prototype.rTrim = function(){
  // Quita los espacios en blanco del final de la cadena
  var s = this.toString()
  var j=0

  if( s.length == 0 ) { return s }
  if( s == ' ' ) { return '' }

  // Busca el último caracter <> de un espacio
  for(var i=s.length-1; i>-1; i--) {
      if(s.substring(i,i+1) != ' ')
      {
          j=i
          break
      }
  }

  return s.substring(0, j+1)
}

String.prototype.trim = function(){
  // Quita los espacios del principio y del final
  var s = this.toString()

  return s.replace(/^\s+|\s+$/g,"")
}

String.prototype.strReverse = function(){
  // Invierte la cadena
  var s = this.toString()
  var i=s.length
  var t=""

  while(i>-1){
      t=t+ s.substring(i,i+1)
      i--
  }

  return t
}

String.prototype.contains = function(t) {
  //verdadero si el string contiete el contenido de t
  return (this.indexOf(t) >= 0)
}

String.prototype.countOf = function(char) {
  // cuanta las ocurrencias de un string dentro de este
  var count = 0
  var len = this.toString.length

  if(char.length > len) { return 0 }
  for (i = 0; i < len; i++) {
      (this.charAt(i)==char) ? count++ : ''
  }

  return count
}


String.prototype.numberPart = function() {
  //retorna la parte numerica de un string alfanumerico
  return this.replace(/[^0-9|.|-]/g, '')
}

Copiar fechas con Javascript

2008-04-14T11:33:00.005-03:00

Un error común al trabajar con fechas en Javascript es copiar un objeto Date creado en una variable a otra.


var aa = new Date(2007,0,31) //31/01/2007
var bb = aa
bb.setFullYear(2009)  //esto modifica aa
document.write(aa) // Sat Jan 31 2009 00:00:00

Si, como se ve en el ejemplo, se instancia el objeto Date en la variable aa al copiar ésta a la variable bb, no se estará creando una nueva instanacia del objeto Date, sino que se estará creando una referencia al objeto instanciado en aa.

Para evitar esto y hacer lo que realmente se quería hacer, tener una nueva instancia del objeto Date en la variable bb con la fecha almacenada en la variable aa, se debe efectivamente utilizar el objeto Date.


var bb = new Date(aa.getFullYear(), aa.getMonth(), aa.getDate())

Pero también, de manera más sencilla, podemos utilizar el método del objeto Date getTime, que nos devuelve la cantidad de milisegundos que hubieron desde el 01/01/1970 hasta la fecha almacenada en la variable aa.

var bb = new Date(aa.getTime())

De esta manera, mantenemos también la información de hora, minutos y segundos que hubiera almacenado en la instancia del objeto en aa.

Adicionalmente, les dejo aquí el código necesario para extender el objeto Date para crear el método copy, que lleve adelante la tarea explicada.

Date.prototype.copy = function () {return new Date(this.getTime())}
//ejemplo
var a1 = new Date()
var a2 = a1.copy()

PHP, mySQL, UTF-8 y la madre que los...

2008-03-16T21:21:00.004-03:00

Ustedes sabrán disculpar el exabrupto del título, pero recien acabo de terminar de solucionar un problema que, por lo que he visto en Internte mientras buscaba informanción para lograrlo, afecta a mucha gente y hay cientos, miles de soluciones, pero ninguna me funcionaba... Y la solución era bien simple.

El problema

Estoy creando un sitio basado en PHP, el servidor Apache 2.2 y como soporte de base de datos mySQL. También utilizo la tecnología AJAX, y es aquí donde comienzan mis problemas. Como ustedes quizás sepan los objetos que se utilizan para comunicarse con el servidor mediante AJAX, utilizan distintos grupos de caracteres dependiendo si la comunicación se realiza vía POST o vía GET. Y, para complicarlo aún más, si utilizas el método GET, Firefox utiliza un conjunto distinto a IE. Pero ambos coinciden en utilizar UTF-8 cuando usas el método POST. Entonces: ¡A utilizar POST! me dije.

Claro, para eso tienes que setear todo como UTF-8, inclusive tus archivos .js deben grabarse en format UTF-8 o tus alerts no se verán bien si utilizas acentos o ñ's.

Hay que tener en cuenta que el conjunto de caracteres por omisión de mySQL es LATIN1, entonces tienes que setear el archivo de inicialización (my.ini o my.cnf) para que la base trabaje con UTF-8. En el apartado [client] debes colocar:

default-character-set=utf8

y en el apartado [mysqld] debes colocar:

default-character-set=utf8
character-set-server=utf8
default-collation=utf8_unicode_ci
collation-server=utf8_unicode_ci

Además debes crear las tablas con charset UTF-8 y collation UTF8_UNICODE_CI.

Hasta aquí anda todo perfecto, según la documentación de mySQL. Pero cuando te conectas a la base de datos desde una ventana DOS y le hechas una mirada a las variables (SHOW VARIABLES), aparecen unas variables de las cuales no he encontrado documentación que indique como cambiarlas desde el archivo de inicialización y que son el meollo del asunto: character_set_client y character_set_results. La primera tiene el conjunto de caracteres que debe usar el servidor de la base de datos para traducir lo que el cliente le envía; y la otra contiene el conjunto de caracteres que debe utilizar el servidor para traducir lo que le envía al cliente.

Despues de decenas de cambios, ambas variables siempre decían LATIN1. Esto provocaba que, al enviar información a la base de datos esta se grababa reemplazando los caracteres hispánicos dos o más combinaciones de caracteres "raros".

Cuando intentaba recuperar la información desde mis páginas, esta se veía correctamente. Entonces ¿cuál era el problema? Pues bien, el problema surgiria cuando yo intentara crear una sentencia SQL válida que intentara comparar cadenas de caracteres, pues no habría forma en que coincidieran.

La solución

Pues después de mucho leer y probar, además de los parámetros de configuración que he enunciado anteriormente, luego de conectarte a la base de datos, debes ejecutar la sentencia:

SET NAMES utf8

y la felicidad volverá a tu vida.

Espero les sirva.

Prototype 1.6.0.2 - Plantilla de métodos

2008-02-28T09:26:00.004-02:00

Si sos de los miles de desarrolladores del mundo que han adoptado, casi adictivamente, el fantástico framawork prototype, habras notado que es casi imposible recordar todo lo que tienes a tu disposición con esta herramienta.

Pues bien, la gente de Perfection Kills ha aportado su granito de arena con una plantilla donde se resumen y agrupan todos los métodos más utilizados de prototype. Puedes bajarte el PDF con la información de este enlace: http://thinkweb2.com/projects/prototype/downloads/Prototype Cheat Sheet 1.6.0.2.

Un excelente trabajo de estos muchachos.

Como abrir ventanas evitando las solapas

2008-02-14T13:31:00.003-02:00

Resulta que tienes una aplicación que abre una nueva ventana del navegador cuando ejecutas en Javascript window.open, pero con los navegadores que tienen solapas esto no es el efecto que quieres.

¿Cómo hacerlo? Pues lo único que tienes que hacer es utilizar el tercer parámetro de la instrucción, aquel donde le indicas las propiedades que debe tener la nueva ventana.

window.open("myURL.htm", "_blnak", "scrollbars=yes")

Si no quieres alterar las propiedades normales de la ventana (tamaño, menus, etc.) la propiedad mas benigna es justamente la que ves en el ejemplo.

E-Mail con ASP y CDOSYS

2008-01-30T15:33:00.000-02:00

CDOSYS es el remplazo del viejo CDONT que hasta Windows 2000 venía con el IIS, dejó de soportarse en la versión 5.1. A partir de Windows XP y Windows 2003, o mejor dicho de la versión IIS 5.x, está disponible el CDO (Collaboration Data Objects).

Ejemplos

Caso típico (con attach)

Para enviar un correo electrónico hay que seguir los siguientes pasos

<%
'creación del objeto que enviará el mensaje
Set oMail = Server.CreateObject("CDO.Message")

urlms = "http://schemas.microsoft.com/cdo/configuration/"
with oMail
'CONFIGURACION SMTP *******************************************************
   'se puedo obviar la propiedad Item, pero en .NET es obligatoria
   .Configuration.Fields.Item(urlms  & "sendusing") = 2 'enviar usando port
   .Configuration.Fields.Item(urlms  & "smtpserver") = "10.223.240.104"
   .Configuration.Fields.Item(urlms  & "smtpserverport") = 25
   .Configuration.Fields.Item(urlms  & "smtpusessl") = False
   .Configuration.Fields.Item(urlms  & "smtpconnectiontimeout") = 60
   '.Configuration.Item(lcSchema + "smtpauthenticate") = true
   '.Configuration.Item(lcSchema + "sendusername") = "usuario" 'login
   '.Configuration.Item(lcSchema + "sendpassword") = "clave" 'password

   .Configuration.Fields.Update
'FIN DE CONFIGURACION SMTP ************************************************

   'quien envía
   .From = "yoyoyo@mapfre.com.ar"

   .To = "vosvos@gmail.com"
   'para múltiples recipientes, sepárelos con un punto y coma
   '.To = "vosvos@gmail.com; otrovosvos@server.com"

   'Copia carbón
   .CC = "otro_mail@mm.com"

   'copia oculta
   .BCC = "otro_mail.mas@mail.com.uk"

   'sujeto
   .Subject= "Prueba de e-mail via CDOSYS"

   'CUERPO
   'para correo html se usa .HTMLBody
   .TextBody = "Mi mensaje"

   'agregar un archivo
   .AddAttachment Server.MapPath("/") & "\myArch.zip"

   .Send
end with

Set oMail = Nothing
%>

Código de caracteres especiales

Si es necesario enviar alguna página de código en especial:

<%
...

with oMail
  ...

   .From = "yoyoyo@mapfre.com.ar"
   .To = "vosvos@gmail.com"

   .Subject= "Prueba de e-mail via CDOSYS"

   Set b = .bodypart
   b.charset = "unicode-1-1-utf-7"

   .TextBody = "El costo de la reparación será de quot;

   .Send
end with

...
%>

Nombres en lugar de direccines

Para que el receptor vea los nombres en lugar de la dirección electrónica:

<%
...

with oMail
  ...

   .From = "Mi Nombre <yoyoyo@mapfre.com.ar>"
   .To = "Tu Nombre <vosvos@gmail.com>"

   .Subject= "Prueba de e-mail via CDOSYS"

   .TextBody = "Texto"

   .Send
end with

...
%>

Imágenes embebidas

Para agregar imágenes embebidas en el mensaje:

<%
...

with oMail
  ...

   .From = "Mi Nombre <yoyoyo@mapfre.com.ar>"
   .To = "Tu Nombre <vosvos@gmail.com>"
   .Subject= "Prueba de e-mail via CDOSYS"

   'parametro 1= ubicacion y nombre, 2=CID, 3=tipo de referencia (CdoReferenceTypeName)
   .AddRelatedBodyPart Server.MapPath("/imagenes") & "\exit.gif", "exit", 1

   .HTMLBody = "<b style='color:red'>mi imagen</b> " _
             & "<img src='cid:exit' />"

   .Send
end with

...
%>

Mandar una página html

Si necesitamos mandar una página de un sitio o, en caso de ser un archivo de servidor, el resultado de la misma:

<%
...

with oMail
  ...

   .From = "Mi Nombre <yoyoyo@mapfre.com.ar>"
   .To = "Tu Nombre <vosvos@gmail.com>"
   .Subject= "Prueba de e-mail via CDOSYS"

   .CreateMHTMLBody "http://www.mapfre.com.ar/stats/stat.htm"
   .Send
end with

...
%>

En caso de querer mandar una página html que se encuentre en nuestra PC, simplemente debemos cambiar el protocolo y agregar el camino completo de la imagen en nuestro disco: file://c:\micarpeta\mipagina.htm

Reflejando imágenes On-Line

2008-01-22T12:49:00.000-02:00

Hola! Hace mucho no posteaba en el blog de mi amigo Julio.

Navegando por la net, me topé con esta herramienta gratuita, para generar interesantes reflexiones sobre imágenes:

http://www.reflectionmaker.com/

El único inconveniente es que solo admite imágenes con tamaño inferior a 200kb., sin embargo creo que es suficiente como para hacer un logo (o lo que se nos ocurra) bien al estilo web 2.0.
Tengamos en cuenta también, que la calidad de la imagen resultante no es tan buena como si la hicieramos en alguna herramienta profesional de diseño gráfico.
Entre las característas, se puede elegir el tamaño de la reflexión, y el fondo o "suelo" sobre el cual se reflejará la imagen.

Los métodos de entrada son, o bien subiendo la imagen que tengamos en nuestro disco, o indicando el link.

Saludos!

Prueba tu web en distintos navegadores

2008-01-21T14:19:00.000-02:00

¿Necesitas probar tu web en distintos navegadores y sistemas operativos? ¡¡Es un problema tener que hacer esto!!

Pues ahora no tanto. Estos genios han puesto a disposición del mundo una herramienta llamada Geekotic, que hace un análisis de tu web en pocos minutos, testeándola en todos los sistemas operativos y navegadores que selecciones.

Luego de unos instantes tendrás a la vista una serie de capturas de pantalla de tu sitio, con el informe correspondiente a cada una de ellas.

Si esto no facilita tu vida de desarrollador web... ¡Nada lo hará!

Bravo por los responsables de browsershots.org!!

10 Publicidades increibles

2008-01-17T10:34:00.000-02:00

Esto no tiene que ver con la temática de este blog, pero lo roza indirectamente. Además me ha parecido algo muy divertido para aquellos que estamos hace mucho rato ya en esto de la informática, y también para los recien llegados que verán con que nos las teniamos que ver cuando eramos jóvenes y recien comenzabamos en esto.

Respecto de aquellos tiempos, hoy la tienen fácil. Que programen hoy en una Latindata de 64K de memoria (SI!! Sólo 64 K) y dos discos flexibles de 160 k (SI!! Sólo 160 K) y sistema operativo CP/M. Sin archivos indexados ni super motores de base de datos, ni ventanitas, ni arrastrar y soltar...

No se pierdan esta página. Es buenísima.

Imagen de espera mientras se carga una imagen

2008-01-08T15:42:00.000-02:00

Muchas veces en nuestras páginas se cargan imágenes realmente pesadas y no tenemos forma de avisar al visitante. Aquí les dejo un truco que encontré por ahí que permite mostrar una imagen de fondo, que luego será tapada por aquella que se está leyendo:

img {
background:  transparent url(imagen-precarga.gif) no-repeat center center;
}

Se recomienda el uso de una pequeña imagen que indique la espera para lograr que el navegador la cargue rápidamente.

Si bien es un truco interesante, encontrarán una dificultad con las imágenes transparentes, pues puede que la imagen de fondo no sea totalmente tapada. Pero para la mayoría de las que usamos en la web, esta técnica es útil.

Otra opción sería restringir el uso de esta técnica a las imágenes que se muestran dentro de determinados elementos. En el siguiente ejemplo sólo se usará la imagen de fondo en los tags IMG que sean hijos de un elemento cuya clase CSS sea album:

.album img {
background:  transparent url(imagen-precarga.gif) no-repeat center center;
}

UNIX: comandos útilies

2008-01-04T11:37:00.000-02:00

Siguiendo con Unix (que me tiene ocupado por estas horas), acá les acerco algunos comandos útiles para quienes no conocen mucho esta herramienta:

Ustedes deben estar familiarizados con el uso del ls, un comando para ver el contenido de nuestra unidad de almacenamiento, que tiene gran cantidad de modificadores. Si quieren ver la lista de carpetas bastará con el siguientes comando:

ls  -d */.

Si, en cambio, necesitan una lista del contenido de una carpeta pero ordenada por fecha, el siguiente comando realiza la tarea

ls  -Fltr

Claro que retener estas líneas en algunos casos resulta tedioso, pero Unix nos da la posibilidad de generar alias para ellas, que sean más fáciles de recordar. Por ejemplo, en el caso anterior podríamos definir

alias ld='ls -Fltr'

y vastará con ejecutar el comando ld que acabamos de crear para que Unix sepa a que nos referimos. Claro que al terminar tu sesión esta definición se perderá, pero a no amargarse, hay una solución. Cada vez que inicias una sesión en Unix, el sistema operativo lee un archivo que se encuentra en el root de tu usuario y que esta oculto, que se llam .login. Bastará con que agregues tu alias en ese archivo para que lo tengas diponible cada vez que inicies una sesión.

Otra cosa que sucede muy frecuentemente es que realicemos tareas con archivos en nuestro ordenador de escritorio, que generalmente corre un Windows, y luego pasemos ese archivo a un servidor Unix mediante un cliente FTP gráfico. ¿Cuál es el problema? Pues que al abrir el archivo en el servidor Unix nos encontramos que tiene unos molestos carcateres CR de DOS. Estos caracteres no son digeribles por Unix, sobre todo si nuestro archivo es un script ejecutable.

La manera más rápida de quitar los CR es mediante la siguiente línea

tr  -d '\015' < file >file2

Lo mismo hacemos si quremos extraer el EOF:

tr  -d '\032' < file >file2

Y si queremos hacer ambas cosas a un tiempo, batará con utilizar un pipe:

tr  -d '\015' < file | tr  -d '\032' >file2

Espero les sea de utilidad.

Vectores en Korn Shell (Unix)

2007-12-18T08:52:00.000-03:00

Aquellos que utilizan Unix o Linux diariamente, programan muchos scripts para diversas tareas. Es que uno de sus kernels ksh es de los más cómodos para trabajar. Pero pocos dan utilidad a los vectores (arrays).

Su utilización es sencilla, simplemente se asigna a una variable con subíndice un valor y listo. Los subíndices pueden no ser consecutivos, lo que muchas veces puede complicar las cosas a la hora de querer iterarlos, no por el vector, sino por las tareas que hagas con los contenidos de los elementos vacios. Tal vez convenga utilizar una variable para ir llevando el contador de elementos.

myVar[0]="algo"
myVar[1]="algo mas"
myVar[3]="otra cosa"

#-- otra forma (pero asina subindices consecutivos)
set -A myVar "algo" "algo mas" "otra cosa"

Pero ¿cómo los recorremos? Uno de los datos principales que necesitamos para recorrerlos es el subíndice máximo del vector, y algo que pocos conoces es la sentencia para obtener ese valor: ${#myVar[@]}, que devuelve el subíndice máximo que se utilizó para asignar un elemento al vector, no la cantidad de elementos que componen el mismo. En el ejemplo anterior, la sentencia retornará 3 para la primera parte del ejemplo y 2 para la segunda parte (set -A...) ya que los subíndices comienzan por cero.

Así, la forma de recorrer el vector sería:

i=0
while [ i -le ${#myVar[@]} ]
do
        var=${myVar[i]}
        ...
done

Nótese en el ejemplo que las llaves ({}) rodean al elemento solicitado. Esta es la forma de acceder a un dato guardado en un elemento requerido del vector.

De esta forma nos aseguramos de recorrer el vector hasta su último elemento aunque alguno de sus subíndice no haya sido asignado. Pero ¿cómo sabemos cuantos elementos fueron asignados?. La respuesta está en esta simple instrucción:

#-- retorna el numer de elementos asignados
echo ${#myVar[*]}

Por otra parte, si quisieramos ver todos los elementos del vector en una lista vastará con:

echo ${myVar[*]}

# MUESTRA  algo algo mas otra cosa

lo que no es muy útil si tenemos en cuenta que el separador de campos por omisión que utiliza Unix es el espacio en blanco, con lo cual perderíamos la capacidad de saber donde comienza y donde termina cada elemento. Esto tiene una fácil solución cambiando el valor del separador de campo que se encuentra en la variable de entorno FS.

Confronte.com

Tablas: Insertar filas y celdas dinámicamente

2007-10-29T17:36:00.000-03:00

Recientemente, corrigiendo unas páginas muy IE, me tope con un problemilla que nunca tuve antes en este asunto de tener todo cross-browser, porque -sinceramente- con el mercado que tenían los otros navegadores, en mi empresa sólo escribíamos para IE.

El temas es que me encontré con un código que creaba dinámicamente filas y celdas en una tabla utilizando los métodos insertRow e insertCell. Cuando lo probé en Firefox falló y pensé, inicialmente, que no existían con esos nombre los métodos. Pero no fue así.

Para graficarlo mejor, el código IE es algo así:

var myTable = document.getElementById('myTable');
var oRow = myTable.insertRow();
var oCell = oRow.insertCell();
var oCell.innerHTML = 'contenid de la celda';

Para que este sea cross-browser se debe escribir así:

var myTable = document.getElementById('myTable');
var oRow = myTable.insertRow(-1);
var oCell = oRow.insertCell(-1);
var oCell.innerHTML = 'contenid de la celda';

Donde -1 indica al DOM que debe agregar la fila o la celda al final.

Libro gratis sobre AJAX.NET

2007-08-27T11:32:00.000-03:00

Desde ya hace un tiempo, en el sitio de Microsof, está disponible para bajar gratuitamente el buen libro sobre AJAX.NET de Dino Esposito. Para quienes le interese pueden bajarlo desde este enlace. El libro se llama Atlas for AJAX development.

Lamentablemente para los hispanoparlantes, el libro esta escrito en inglés, pero los que ya hace un tiempo largo que estamos en esto del desarrollo, esto no es un impedimento.

No se lo pierdan, es una buena opción y gratis.

Servidor web ASP.NET sin IIS

2007-07-24T23:22:00.000-03:00

Puede que te haya pasado lo que a mi. Tuve instalado un Windows XP Home y ahora un Windows Vista Basic y en ambos, como también en otras versiones Vista, no se ha incluido el Internet Information Server, necesario para correr aplicaciones ASP o ASP.NET a medida que las estamos desarrollando.

Si has andado por ahí, has leido que esxiste Cassini Web Server, un desarrollo que pretende sustituir al IIS, aunque muchas veces es imposible hacerlo arrancar pues tiene conflicto con todos los puertos que le indicas, incluido el 80. También puedes configurar Apache con mod_mono, pero es complicado y, además, la Fundación Apache desaconseja su uso.

Entonces instalas tu Visual Studio Net que te permite probar las apliaciones con un servidor propio en el puerto 49608. Pues bien, este servidor se encuentra en la carpeta de la versión 2 de Net y puede ser arrancado ya que es una aplicación ejecutable. Acá va como hacerlo:

Abre una ventana DOS con CMD
Navega hasta llegar a la carpeta Microsoft.NET\Framework\v2.0.50727, generalmente en la carpeta Windows de la undad C:
Ejecuta webdev.webserver /port:81 /path:"c:\www" /vpath:"/"

Esta aplicación tiene tres parámetros: port, path y vpath, de los cuales sólo path es obligatorio

port : puerto que estará "escuchando" el servidor
path : carpeta donde se encontrarán las aplicaciones web
vpath : nombre virtual de la carpeta de las aplicaciones web

Una vez iniciado el servidor, en nuestra barra de tareas verán un pequeño icono (medio feo para mi gusto) desde donde podrán obtener alguna infomación del servidor y apagarlo desde allí.

Espero que les sea útil esta información.

Servidor web ASP.NET sin IIS

2007-07-24T22:53:00.000-03:00

Abre una ventana DOS con CMD
Navega hasta llegar a la carpeta Microsoft.NET\Framework\v2.0.50727, generalmente en la carpeta Windows de la undad C:
Ejecuta webdev.webserver /port:81 /path:"c:\www" /vpath:"/"

Confronte.com

Expresiones Regulares IV – Caracteres especiales

2007-07-17T14:33:00.000-03:00

El asterisco (*)

Este símbolo es utilizado para indicar que pretendemos encontrar cero o más ocurrencias del dato previo a él:

var texto = 'abc1'
if( /^\w{3}\d*$/.test(texto) ) {
alert(IsFound)
}

El ejemplo anterior devolverá verdadero para cualquier ocurrencia de 3 cualesquiera caracteres seguidos de cero o más dígitos.

La barra invertida

Este carácter se utiliza para preceder a ciertos caracteres y darles un sentido especial. Por ejemplo, para buscar caracteres de tabulación utilizaremos la expresión \t. A continuación agrego una lista de carateres especiales y su reprepresntación dentro de las expresiones regulares:

\t = tabulación
\n = nueva línea
\f = salto de formulario
\r = retorno de carro
\w = cualquier carácter ASCII
\W = cualquier carácter no ASCII
\d = cualquier dígito ASCII
\D = cualquier dígito no ASCII
\s = cualquier espacio en blanco
\S = cualquier carácter que no sea un espacio en blanco

La barra invertida también se utiliza para que caracteres especiales de expresiones regulares, sean interpretados como caracteres comunes. Por ejemplo, si quisieramos encontrar en un texto el signo $ debemos utilizar \$

Los Corchetes

Los corchetes ( [ ] ) se utilizan para crear clases de caracteres. Estas clases están conformadas por grupos literales de caracteres. Por ejemplo /[baco]/ retornará verdadero si cualquier carácter b, a, c u o es encontrado en la cadena testeada.

/[baco]/.test("abcd");  // verdadero

/[baco]/.test("lmnj");  // falso

Adicionalmente, los integrantes de estas clases pueden estar precedidos por el signo ^ que establece la negación de lo buscado. Por ejemplo:

/[^baco]/.test("abcd");  // falso

/[^baco]/.test("lmnj");  // verdadero

Los paréntesis

Los paréntesis pueden utilizarse con dos finalidades: Agrupar clases ( [ ] ) o referirse a subexpresiones previas dentro de una expresión.

([09][a-z)

En este modelo se buscará un 0 o un 9 seguido de uno o más caracteres de a a z en minúsculas.

Al agregarse los paréntesis a una expresión, JavaScript toma nota de la posición del contenido teniendo en cuenta las aperturas de los paréntesis, comenzando por el número 1:

/^([ab](c)?)+$/

En la expresión anterior JavaScript sabe que [ab](c)? es el contenido de 1 y c es el contenido de 2. Para referirse a esas posiciones, preceda al dígito de posición con una barra invertida, por ejemplo \1. También puede utilizarse el signo $, por ejemplo $1

alert("javascript".replace(/java(.*)/,'action$1'));

En el ejemplo anterior, se reemplaza la palabra java por action y luego le adhiere cualquier otro texto que estuviera detrás de java, resultado en actionscript.

re = /(\w+)\s(\w+)/;
"Julio Gonzalez".replace(re, "$2, $1");  // resultado: Gonzalez, Julio

El signo OR ( | )

Este signo representa a OR

var texto = "abc"
/a|b/.test(texto) // verdadero

La expresión anterior devolverá verdadero si texto contiene una a o una b.

El signo más (+)

Este signo es utilizaado para encontrar una o más ocurrencias del item precedente.

var texto = "abc"
/^\d+$/."1234" // verdadero
/^\d+$/."abcde9" // verdadero
/^\d+$/."abcde" // falso

El signo de interrogación (?)

Este signo es utilizado para indicar que se deben encontrar cero o más ocurrencias del item previo.

/^\d{2}\d?$/.test("123")  // verdadero
/^\d{2}\d?$/.test("123789")  // falso

Este código retornará verdadero cuando encuentre exáctamente 2 dígitos y, opcionalmente, un tercer dígito.

ciberbanner.com intercambio de banners

Aplicaciones AJAX listas para usar

2007-07-17T12:53:00.000-03:00

¡ Y grátis !

Hemos encontrado dos estupendos sitios donde bajar aplicaciones AJAX realmente interesantes, de código abierto. Una de ellos es AJAX RAIN y el otro es Smashing Magazine. Hay cientos de aplicaciones. No están muy comentadas, pero las imágenes que sirven de enlace hacen bastante entendible de que se trata.

Para no perdérselos.

Expresiones regulares III

2007-06-07T11:16:00.000-03:00

Validación de un número telefónico

Supongamos que debes validar un número telefónico que tiene código de área, característica y resto del número. Utilizamos un sólo campo de entrada de datos y solicitamos al usuario que lo ingrese en el formato NNN-NNN-NNNN (donde N representa a cada dígito), sabiendo que el código de área nunca comienza con un 1 o un 0. La expresión que realizará el control sería:

(/^[2-9]\d{2}-\d{3}-\d{4}$/.test('222-333-4444');

^[2-9] controlará que el primer grupo de dígitos comience con los digitos 2 a 9.

\d{2} indica que el primer dígito del el primer grupo esté seguido por dos dígitos más.

- indica en que posición deben ir el guión.

\d{3} indica que al guión anterior deben seguirle 3 dígitos.

- indica en que posición deben ir el guión.

\d{4}$ indica que al guión deben anterior seguirle 4 dígitos, y que éste es el final del número ($)

Limitar el tamaño del dato a controlar

Con expresiones puedes regular el tamaño de los datos que debe entrar el usuario. La siguiente expresión retorna true si el número testeado consta de dos dígitos:

document.write(/^\d\d$/.test(22));

Simplemente decimos que debe comenzar con un dígito (^\d) y a éste sólo le puede seguir otro dígito (\d). Esta expresión también la podemos escribir utilizando las llaves ({}):

document.write(/^\d{2}$/.test(22));

El número encerrado entre las llaves especifica exáctamente la cantidad de dígitos que se deben ingresar. Sin embargo, puede tratarse de una cantidad variable de dígitos lo que se espera:

document.write(/^\d{2,4}$/.test(222));

En este caso, son dos los números encerrados entre las llaves, separados por una coma, lo que indica al testeador que se espera un número de dos dígitos como mínimo y cuatro dígitos como máximo.

Ver también

ciberbanner.com intercambio de banners

Nació COMET

2007-06-07T10:48:00.000-03:00

Si ya te habías aprendido y, tal vez, has puesto en práctica todo ese rollo del AJAX... Te tengo malas noticias (bah, son buenas, pero según como se mire): se está comenzando a utilizar una ¿nueva? técnica denominada COMET, la cual ya implementa el framework Dojo, que consiste en hacer algo similar a AJAX: mostrar información sin refrescar toda la página.

Con AJAX, el navegador hace solicitudes al servidor de páginas web para refrescar información en determinadas partes de la página que está utilizando esta tecnología. El navegador solicita la información, el servidor la envía y se corta la comunicación.

En el caso de Comet, se establece una comunicación con el servidor y esta continua "viva" durante todo el tiempo que sea necesario, y es el servidor quien envía información, aun sin habersela solicitado. Esta es una técnica ya conocida que se denominaba push.

Ya hay sitios que están utilizando esta técnica: GTalk en el GMail, y Meebo son dos buenos ejemplos.

Si pensaste que ya todo estaba inventado... Queda mucho más por inventar... por suerte.

ciberbanner.com intercambio de banners

Expresiones regulares II - Validación de números

2007-06-01T14:17:00.000-03:00

Siguiendo con esta entrega sobre el uso expresiones regulares en la validación de datos en Javascript, veremos ahora como validar números.

Validación de un entero

var myNum = 15;
var bFound = /^\d+$/.test(myNum);
document.write(bFound);

En el script que vemos arriba, el símbolo ^ que se testeará el valor desde el comienzo y el símbolo $ indica que se continuará hasta el final del valor. \d establece que buscaremos sólo dígitos numéricos y, finalmente, el símbolo + establece que es válido encontrar más de un dígito numérico. Si este último signo, el control de número fallaría puesto que le estaríamos diciendo que controle un valor que comienza y termina con el primer dígito.

Validación de números con decimales

En el ejemplo anterior, si el número tuviera decimales, la validación retornaría false puesto que la expresión regular no adminte otra cosa que dígitos numéricos.

document.write(/^\d+\.?\d*$/.test('15.22'));

En este ejemplo veremos como detectar el punto (o coma) decimal.

Observemos:

^\d+ como en el ejemplo anterior indica que se debe revisar desde el comienzo del valor y que deberá encontrar sólo dígitos numéricos, y uno o más.
\.? indica que se puede encontrar un punto decimal (para paises con como, reemplazarlo), y el signo ? indica que puede faltar, lo cual hace que los valores enteros también sean válidos.
\d*$ finalmente, indicamos que después del punto decimal se pueden encontar cero o más dígitos numéricos hasta el final del valor.

Expresiones regulares en Javascript (I)

ciberbanner.com intercambio de banners

netvibes.com

2007-06-01T11:22:00.000-03:00

Recientemente SEOmoz otorgó los premios a las mejores Web 2.0. Entre otras, netvibes recibió el premio a la mejor página de inicio y me parece que lo merece largamente. Es de diseño sencillo y muy clara. Realmente sorprendente con la velocidad que obtiene la información que necesito. Más que recomendable para aquellos que les gustan estas cosas

digilicious.cl

2007-06-01T11:06:00.000-03:00

10 diseñadores chilenos se juntaron para hacer www.digilicious.cl, un blog de diseño digital de actualización diaria con temas que van desde diseño web hasta el motion graphics, pasando por el 3d, la publicidad, lo audiovisual y la gráfica impresa.

En este sitio he encontrado una interesante guia de 43 errores que NO debes cometer al diseñar un sitio web. Claro que es el criterio de estos amigos chilenos, pero a mi me pareció bastante interesante y lo recomiendo fervientemente.

&amp;amp;lt;br&amp;gt; ciberbanner.com intercambio de banners

Version Beta de la Scriptaculous

2007-05-29T17:06:00.000-03:00

La última version de la librería scriptaculous (1.7.0) arroja un error de memoria al utilizarse con la versión final de la lib. prototype (1.5.1) Para solventar este error, se creo una versión beta (1.7.1) de esta libreria compatible con la mencionada anteriormente. También, posee optimizaciones de velocidad y estabilidad. La descarga esta disponible de esta página: http://mir.aculo.us/2007/5/25/script-aculo-us-1-7-1-beta-3

Expresiones regulares en Javascript

2007-05-16T10:50:00.000-03:00

En Javascript se pueden utilizar expresiones regulares para controlar el ingreso a datos, aunque por la complegidad de las mismas, muchos progamadores no las utilizan. Aquellos que estén familiarizados con el editor VI de Unix o el gVim, que es la versión para Windows, no tienen mayores problemas para utilizar las expresiones regulares. Estas expresiones, también, son conocidas por aquellos que manejan el editor en linea de Unix llamado sed.

Acá intentare dejarles algunas de las que más utilizo, aunque debo decirles que he visto algunas realmente complicadad pero bien efectivas.

Una de las formas de utilización de las expresiones regulares es con el método test. Una forma simple de su utilización la muestra el siguiente ejemplo. El navegador imprimirá true si la palabra web se encuentra en el texto web ar.

document.write(/web/.test('web ar'));

Pero comencemos a complicar las cosas. Las expresiones regulares tienen algunos caracteres reservados que hacen las veces de modificadores en su forma de actuar. Entre ellos tenemos el signo ^ y el signo $ que indican el rango de caracteres en que se buscará. El signo ^ indica "comenzar desde el principio" y $ significa "revisar hasta el final". En el siguiente ejemplo se buscará si un string comienza con una letra determinada:

//Retornara true
var bFound = /^j/.test('julio');
alert(bFound);

En el siguiente ejemplo, el signo $ hará que se revise si la cadena pasada como parámetro a test termina con el caracter indicado:

//retornará true
var bFound = /o$/.test('julio');
alert (bFound);

//retornará false
var bFound = /d$/.test('julio');
alert (bFound);

Espero que se vaya entendiendo. Seguiré en próximas entregas, pero para asustarlos les dejo aquí una función para controlar una dirección de correo electrónico (advierto que se puede mejorar).

function checkMail(txMail)
{
   var filter  = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9])+$/;
   if ( ! filter.test(txMail) )
   {
     alert('Dirección de e-mail incorrecta')
     return false
   }
   return true
}

ciberbanner.com intercambio de banners

Reemplazo de carcateres en Javascript

2007-05-16T10:37:00.000-03:00

En Javascript todo texto es un objeto de la clase String. Esta clase tiene un método poco utilizado pero por demás interesante a la hora de reemplazar unos caracteres por otros. Ese método es replace.

El método toma dos parámetros: una expresión regular o un objeto string, y un objeto string que contiene los caracteres de reemplazo.

//Reemplaza todas las j y o con d
var myStrg = 'Julio Gonzalez';
var myStrg2 = myStrg.replace(/[jo]/gi,'d');
alert(myStrg2);

En en ejemplo, la expresión regular tiene dos modificadores g, que indica que el cambio será global, e i, que indica que no se hará diferencia entre mayúsculas y minúsculas.

Creacion on-line de gif animados de tipo "Loading..."

2007-05-09T00:29:00.000-03:00

Les dejo un link bastante interesante, util para aquellos que no se deciden por cual animación poner en sus pantallas de espera comunmente llamadas "Loading". Podemos elegir entre bastantes tipos de indicadores, color de icono y color de fondo o fondo transparente. Ejemplos:

Link: AjaxLoad

El ComboBox de VB.NET (II)

2007-05-08T13:46:00.000-03:00

Siguiendo con la clase ComboBox y su falta de la propiedad TAG para almacenar objetos, tal como lo hacíamos en VB6, acá les muestro como almacenar gran cantidad de datos en cada opción.

Cuando rellenamos un ComboBox “manualmente”:

myCombo.ItemsAdd(“Texto a mostrar”)

Lo que en realidad estamos haciendo es agregando un objeto de tipo STRING, mediante el método Add. Este método acepta como parámetro un objeto de cualquier tipo y muestra como opción el resultado del método ToString del objeto.

Teniendo en cuenta esto, podemos crear nuestra propia clase para almacenar datos en el item, siempre teniendo cuidado de sobreescribir el método ToString para mostrar lo que queremos mostrar.

Primero creamos la clase

Public Class myClass
    Private myID As Integer
    Private myText As String

    /* constructor */
   Sub New(ByVal ID As Integer, ByVal tx As String)
      myID = ID
      myText = tx
   End Sub

   Public Property Text() As String
      Get
         Text = myText
      End Get
      Set(ByVal tx As String)
         myText = tx
      End Set
   End Property


   Public Property ID() As String
      Get
         ID = myID
      End Get
      Set(ByVal id As Integer)
         myID = id
      End Set
   End Property

   Public Overrides Function ToString() As String
      ToString = myText
   End Function
End Class

Cómo utilizamos esta clase, pues bien, para ingresar los datos en el combo

With Me.myCombo
   .Items.Add(New myClass( -1, “”))
   .Items.Add(New myClass( 2, “Dato con nro. 2”))
   .Items.Add(New myClass( 23, “Dato con nro. 23”))
End With

Para rescatar los datos del combo tenemos que transformar el valor obtenido al formato correcto:

myVar = Ctype(Me.myCombo.SelectedItem, myClass)

Y luego podemos acceder a los valores mediante las propiedades de la clase

myVar.Text
myVar.ID

Sencillo, ¿no?

ciberbanner.com intercambio de banners

El ComboBox de VB.NET

2007-05-05T21:49:00.000-03:00

Conocido es, por aquellos que desarrollamos en VB6, y migramos a VB.NET que la clase ComboBox ha cambiado respecto de su antecesor. Una de las cosas que ha perdido es la propidad TAG que nos permitía almecenar datos adicionales a los mostrados al usuario.

Generalmente el ComboBox es llenado desde la lectura de una tabla de una base de datos, dese la cual mostrábamos la descripción al usuario y en la propiead TAG almacenabamos el código de esa descripción, que es lo que realmente le interesa a nuestro sistema y para nuestra base de datos relacional.

En VB.NET la clase ComboBox tiene una propiedad, DataSource, que nos permite llenar los items del objeto directamente con un objeto DataTable o DataSet, previamente llenado con la lectura a una base de datos. Adicionalmente debemos indicar, en la propiedad DisplayMember, que columna de la tabla será vista por el usuario y, de forma opcional, podemos indicar otra columna de la tabla en la propiedad ValueMember, a fin de obtener su valor, al seleccionarse una opción, en la propiedad SelectedValue.

Pero ¿qué hacemos si necesitamos rescatar más datos? Pues hay un truco poco conocido. Supongamos que nuestro objeto DataTable, con el que llenáramos el ComboBox tenía las siguientes columnas: ID, DESCRIPCION, COD_INTERNO (en ese orden). Cuando rescatamos la propiedad Items podemos utilizar subíndices que indiquen la posición de la columna cuyo valor queremos rescatar, teniendo en cuenta que el subíndice cero apunta a la primera columna, en nuestro ejemplo ID.

Acá les dejo una pequeña rutina que mustra como hacer esto:

'****************************************************************************
'* BUSCA UN ELEMENTO EN UN COMBO QUE FUE LLENADO CON UN DATASOURCE
'* Parámetros
'*    cmb         objeto combobox
'*    txtToFind   texto a encontrar
'*    colPos      posicion de la columa a comparar en el datasource
'****************************************************************************
Function SearchInComboBox(ByVal cmb As ComboBox, _
                          ByVal txtToFind As String, _
                          Optional ByVal colPos As Integer = 0) _
                          As Integer
   Dim I As Integer
   With cmb
      For I = 0 To .Items.Count - 1
         If .Items(I)(colPos).ToString() = txtToFind Then
            Return I
         End If
      Next I
   End With
   Return -1
End Function

Con esta rutina podemos ubicar un elemento en el ComboBox basándonos en cualquier columna del origen de dato que lo llenó. La rutina retorna el índice del elemento o menos uno si no lo encontrase.

¿Cómo se utiliza?

Me.myComboBox.SelectedIndex = SearchInComboBox(Me.myComboBox, "53", 0)

En este ejemplo pedimos que se seleccione el elemento cuyo ID es 53, el tercer parámetro podríamos obviarlo puesto que la columna que deseamos comparar ocupa la primera posición (índice 0).

En este enlace podrán encontrar un ejemplo de cómo llenar un combobox a partir de un objeto DataSet, sin tener que leer una tabla de una base de datos.

Tips para el TreeView

2007-05-03T15:54:00.000-03:00

Estoy empezando a trabajar con una vieja aplicación hecha en Visual Basic 6, para convertirla en Visual Basic .Net y uno de los primeros problemas con los que me he topado es con el uso del control TreeView, que difiere un poco con el viejo VB6, en cuanto a su llenado y en cuanto a encontrar un nodo dentro del "arbol" con el sólo dato de su clave de acceso.

Voy a dejar aquí dos ejemplos, el primero de como llenar un TreeView a partir de un objeto DataTable, que contiene la lectura de una tabla de mi base de datos. Y el segundo ejemplo es como encontrar un nodo conociendo su clave (ahora NAME).

Para el primer ejemplo, suponemos que tienes una conexión establecida a una base de datos, que puede ser mySQL, y que en ella tenemos una tabla que contiene todas las opciones de menú y con ella llenaremos el TreeView. De esta tabla menuKey es el "nombre del menú" (su clave), menuDescription es el texo que aparecerá a la vista del usuario del TreeView, y menuKeyParent es el "nombre del menú" del cual "cuelga" el menú descripto en esta fila.

Para esta tarea, también, me valgo del objeto DataView que permite filtrar los datos del DataTable. Además, observese que la función InsertTVMenuItems es llamada recursivamente. Sobre esto sólo hay que tener en cuenta la cantidad de llamadas recursivas que se van a hacer sin haber retornado (return) de ellas, puesto que en cada llamada el programa creará nuevas variables locales, independientes de las ya creadas, con el consecuente consumo de memoria. Obviamente, cada retorno provoca la liberación de recursos.

'rellena el tree view
Private Sub RellenaTreeView1()
   Dim Itm As New TreeNode()
   Dim adapter As New MySqlDataAdapter()
   Dim data As New DataTable()
   Dim Sql As String

   System.Windows.Forms.Cursor.Current = Cursors.WaitCursor

   TreeView1.Nodes.Clear()
   TreeView1.Refresh()

   Sql = "SELECT menuKey,"
   Sql = Sql & "menuDescription,"
   Sql = Sql & "menuKeyParent"
   Sql = Sql & " FROM Menu"
   Sql = Sql & " ORDER BY menuDescription"
   adapter.SelectCommand = New MySqlCommand(Sql, dbConn)
   adapter.Fill(data)

   If data.Rows.Count = 0 Then
      data.Dispose()
      adapter.Dispose()
      System.Windows.Forms.Cursor.Current = Cursors.Default
      Exit Sub
   End If

   'comienzo con "0" que es el menuKeyParent que cuelga del root del treeview
   InsertTVMenuItems("0", Nothing, data)

   'libero recursos
   data.Dispose()
   adapter.Dispose()
   System.Windows.Forms.Cursor.Current = Cursors.Default
End Sub
Private Sub InsertTVMenuItems(ByVal keyParent As String, _
                              ByVal nodoPadre As TreeNode, _
                               ByVal data As DataTable)

   Dim dataFilter As DataView

   'Crear un DataView con los Nodos que dependen del Nodo padre pasado como parámetro.
   dataFilter = New DataView(data)

   dataFilter.RowFilter = String.Format("menuKeyParent ='{0}'", keyParent.ToString())

   'Agregar al TreeView los nodos Hijos que se han obtenido en el DataView.
   For Each dataRowCurrent As DataRowView In dataFilter

      Dim nuevoNodo As New TreeNode
      With nuevoNodo
         .Text = dataRowCurrent("menuDescription").ToString().Trim()
         .Name = dataRowCurrent("menuKey").ToString().Trim()
      End With

      'si el parámetro nodoPadre es nulo es porque es la primera llamada, son los Nodos
      'del primer nivel que no dependen de otro nodo.
      If nodoPadre Is Nothing Then
         TreeView1.Nodes.Add(nuevoNodo)
      Else
         'se añade el nuevo nodo al nodo padre.
         nodoPadre.Nodes.Add(nuevoNodo)
      End If

      'Llamada recurrente al mismo método para agregar los Hijos del Nodo recién agregado.
      InsertTVMenuItems(dataRowCurrent("menuKey").ToString(), nuevoNodo, data)
   Next dataRowCurrent
End Sub

Sencillo, ¿no?

Bueno, ahora que tenemos nuestro TreeView llenito de datos, se nos viene en ganas de encontrar uno cuya clave (Name) sea X. Para ello definimos una variable privada a nivel de formulario donde almacenaremos el nodo encontrado durante la búsqueda.

Public Class myForm
   Private myNode As TreeNode

Luego escribimos el procedimiento que hará la búsqueda, que también opera recursivamente

'busca un nodo en el treeview
   Private Sub SearchNodeRecursive(ByVal nodes As TreeNodeCollection, ByVal key As String)
      For Each n As TreeNode In nodes
         If n.Name.Trim() = key.Trim() Then
            myNode = n
            Exit Sub
         End If
         SearchNodeRecursive(n.Nodes, key)
      Next
   End Sub

Y por último hacemos la llamada al procedimiento SearchNodeRecursive

Private Sub myProc()
      myNode = Nothing
      SearchNodeRecursive(TreeView1.Nodes, "clave_a_buscar")
      If IsNothing(myNode) Then
         MsgBox("No encontrado")
      Else
         MsgBox(myNode.Text.Trim())
      End If
End Sub

De nuevo... tengan en cuenta la cantidad de llamadas recursivas, sobre todo si el programa se instalará en PC's con escasa memoria.

ShadedBorder - Esquinas redondeadas con sombra

2007-04-26T09:32:00.000-03:00

RUZEE.ShadedBorder es una libreria pequeña en tamaño, pero de gran utilidad que redondea esquinas y produce efectos de sombra al mejor estilo photoshop. Alguna de las características de esta libreria:

Solo Javascript, no utiliza imagenes externas.
Esquinas redondeadas.
Sombras.
Efectos Glow.
Bordes de diferentes tamaños.
Anti-Aliasing
Soporte de On-hover (salvo para IE6)
Deshabilitar alguna esquina.
Cambio de borders "on-the-fly"
Transparencia real.
Cross-Browser: Firefox, Internet Explorer (>=6.0), Safari, Opera (>=9.0)
Pequeño tamaño (7.7KB descomprimido)
No depende de librerías externas.

LINK: http://www.ruzee.com/blog/shadedborder

ciberbanner.com intercambio de banners

BullZip.com

2007-04-24T15:23:00.000-03:00

La compañía Bullzip.com que comercializa soft a través de Internet, tiene en su web una serie de productos gratuitos para hacernos la vida más fácil en nuestro ordenador personal. Entre ellos

PDF Printer que genera una impresora virtual de modo tal que cualquier aplicación que emita informes por impresora, puede hacerlo sobre PDF Printer y generar así un archivo PDF con distintas calidades: pantalla, impresora, ebook, etc. Adminte encriptacion de 128/40 bits, marcas de agua y otras particularidades bastante atractivas.
Access To MySQL una pequeña pero excelente aplicación para volcar tablas de bases de datos MS Access a mySQL.
Express Menu un complemento para el menú inicial de Windows, que nos permite tener un segundo menú, fácil de crear y de navegar.

Desde ya, la comunidad da las gracias a gente como esta que nos permite tener buenos productos por una mínima donación, la cual sugiero que hagan para que ellos sigan desarrollando aplicaciones graturitas.

ciberbanner.com intercambio de banners

Colaborador

2007-04-24T15:15:00.000-03:00

En esta ardua tarea (aunque no lo parezca) de crear y mantener actualizado un blog, he logrado que un excelente pensador y entusiasta buceador en estas cosas de la informática, haya accedido a colaborar escribiendo sus propias entradas en este blog. Su nombre es NESTOR Adrian Araneo, ciudadano de la república de Lanús, como yo.

Espero que los datos que aporte sean útiles para todos ustedes.

Bienvenido, NESTOR!!

Lectura dinámica de hojas de estilo

2007-04-23T16:45:00.000-03:00

Para aquellos que gustan de escribir hojas de estilo separadas para cada navegador, acá va un código Javascript que, manipulando el DOM nos perpite cargar una hoja de estilo e insertarla en la sección HEAD del documento.

var cssNode = document.createElement('link')
cssNode.type = 'text/css'
cssNode.rel = 'stylesheet'
cssNode.href = 'http://www.somedomain.com/styles/FireFox.css'
cssNode.media = 'screen'
cssNode.title = 'dynamicLoadedSheet'
document.getElementsByTagName("head")[0].appendChild(cssNode)

ciberbanner.com intercambio de banners

EJS TreeGrid

2007-04-14T10:53:00.000-03:00

EJS TreeGrid (Editable JavaScript TreeGrid) es un componente escrito en DHTML y Javascript diseñado para mostrar y/o manipular datos en grilla, tabla o árbol, sobre todo para gran cantidad de datos, de hecho, en la página del autor hay un ejemplo de 1 millón de filas.

Compatible con Internet Explorer 5.0+, Gecko (Mozilla 1.0+, Mozilla Firefox 1.0+, Netscape Navigator 6.0+, Camino 1.0+, K-Meleon 1.0+), Opera 7.60+, KHTML (Konqueror 3.0+, Safari 1.2+).

Entre las particularidades más importantes esta el procesamiento de datos en árbol (tree), fórmulas avanzadas en sus celdas y similares a MS Excel, varios tipos de paginación para mostrar miles de filas (millones, según su autor) utilizando AJAX, filtros especiales similares a Excel y filas de agrupamiento automático, desplazamiento de filas por arrastre (drag&drop), y muchas otras particularidades que lo hace un producto más que interesante y que facilita mucho las cosas a los diseñadores de páginas.

Desafortunadamente no es gratis y tampoco barato en su versión personal, pero no es para nada inalcanzable para una empresa y su costo lo vale en las horas de diseño que le ahorrará a sus desarrolladores.

ciberbanner.com intercambio de banners

jQuery Corner

2007-03-23T12:23:00.000-03:00

jQuery Corner o cómo ser original en materia de bordes para tus aplicaciones web.

Es que estos chicos se levantaron una mañana cansados de tanto borde redondeado y se pusiero a crear estos fantásticos scripts que nos hacercan la posibilidad de innovar en nuestras páginas.

Se tratra de un agregado para el framework de Javascript jQuery, escrito originalmente por Dave Methvin y que la gente de malsup ha extendido. Sencillamente asombroso.

En este mismo sitio, malsup.com, encontraran otras cositas igual de útiles e interesantes.

ciberbanner.com intercambio de banners

Liberty Javascript Basic Library

2007-03-23T11:47:00.000-03:00

Bueno... esto ya se está poniendo tedioso (denso... como se dice en mi país). Liberty Javascript Basic Library, otro framework, este -como dice su autor- basado en Prototype, con agreagados interesantes que bien podrían haber sido una extensión para la librería inspiradora. Pero bueno... tendremos que lidiar con otro entorno de trabajo.

Tal vez, en no mucho tiempo, alguien se encargará de juntar todas estas prestaciones en un sóla librería, que bien podría ser Prototype extendia.