Samplx, the ASP eXtensible Markup Language

Haciendo la web desde 1996, EnterpriseDreams

Comportamiento de objetos y variables en ASP

Ventajas y limitaciones

Como siempre, y para variar nada es perfecto (menos en informática), por ello cuando usamos Samplx deberemos variar un poco la típica forma de trabajo del clásico ASP.

A pesar de su potencia, Samplx también tiene algunas falencias que se pueden subsanar con pequeñas funciones (ya incluídas en el objeto), y deberemos variar un poco la clásica escritura de código fuente en nuestras aplicaciones.

La mejor parte de dichas "falencias", es que dicha variación ayudará al desarrollador a optimizar su código fuente, evitará respuestas innecesarias por parte del servidor, ahorrando por consiguiente bytes y salvando su ancho de banda, además de fornecer una capa transparente de protección del sitio Web (Anti-Leech y Anti-SpamBots).

Propiedades del objeto Samplx

Samplx.KEY = clave de uso, si la misma no es declarada entonces se usa "demo" (sólo aplicable para el uso de APIS)
Samplx.XML = archivo XML a utilizar como rewrite, si el mismo no es declarado entonces se usa "rewrite.xml"
Samplx.ROOT = valor del árbol de objetos del archivo xml, si el mismo no es declarada entonces se usa "object"
Samplx.MASK = valor de la máscara que se encarga de darle las directivas de rewrite al sitio web, si la misma no es declarada entonces se usa ".htm"
Samplx.MASK_SEP = valor del la separación de los strings pasados en la página, si el mismo no es declarado entonces se usa "-"

Samplx y el objeto Request.QueryString

Cuando necesitamos recoger el valor de determinados parámetros que se envían a nuestra página, utilizamos siempre la propiedad QueryString del objeto Request de ASP, cuando usemos Samplx debemos tener en cuenta que los Strings (todos aquellos parámetros que sean pasados a través del método "GET"), los podemos trabajar de diferentes formas.

En el siguiente ejemplo ("default.asp?id=1"), la práctica más común para obtener el valor del id que estamos recibiendo es escribir:

<%=Request.QueryString("id")%>

Utilizando Samplx deberemos escribir lo siguiente para obtener el mismo resultado:

<%=Samplx.QueryString("id")%>

En el caso de que la página sea llamada de la siguiente forma ("default.asp?id=1&id=2") observamos que el parámetro ID se repite, en ASP clásico la respuesta que tendríamos sería una cadena separada por comas con los valores de dicho ID, ¿Que sucede en Samplx?, simplemente obtendríamos el primer valor de la cadena "1", siempre y cuando la llamada sea idéntica a la anterior, pero para que tengas las las cosas más claras aquí te va un claro ejemplo:

En ASP clásico, sobre "default.asp?id=1&id=2" sería:

<%=Request.QueryString("id")%>

Que nos escribe en pantalla "1, 2" o lo que es lo mismo, los valores del parámetro ID separados por una coma y espacio en blanco (", ")

<%=Samplx.QueryString("id")%>

Utilizando Samplx obtenemos sólo "1", esto es porque con ésta función sólo obtendremos siempre el primer parámetro que se nos envíe, pero si en realidad lo que queremos es obtener todos los valores, entonces utilizamos la función Samplx.QueryStringKeyValues de la siguiente forma:

<%
 Dim a,b
 a=Samplx.QueryStringKeyValues("info")
 If IsArray(a) Then
 For b=0 To UBound(a)
 Response.Write a(b)&", "
 Next
 End If
 %>

Con lo cual volvemos a obtener "1, 2", o lo que es lo mismo los valores del parámetro ID separados por una coma y espacio en blanco (", "), cómo observarás Samplx.QueryStringKeyValues devuelve un Array con los datos, esto lo hace para ganar un mayor rendimiento y para que luego puedas manejar los mismos según tus necesidades.

Además de dichas funciones para capturar los datos enviados (siempre a través del método "GET"), también puedes utilizar las siguientes:

Samplx.QueryStrings()
Samplx.QueryStringCount()
Samplx.QueryStringKey()
Samplx.QueryStringKeyValue()
Samplx.QueryStringKeyCount()

La función Samplx.QueryStrings() nos devuelve un Array con los parámetros que se están enviando y sus valores asignados con el símbolo de igual "=", esto es cada Array contendrá el nombre del parámetro, seguido del símbolo de igual "=", seguido de su valor.

<%
 Dim a,b
 a=Samplx.QueryStrings()
 If IsArray(a) Then
 For b=0 To UBound(a)
 response.write a(b)&"<br>"
 Next
 End If
 %>

Que escribirá en pantalla "id=1 id=2 "

La función Samplx.QueryStringCount() simplemente nos devuelve el número de parámetros que se están enviando, sin importar sus nombres, ni si los mismos se reiteran en toda la petición.

<%=Samplx.QueryStringCount()%>

Escribiría "2" en la pantalla, que es el número de parámetros que se envían, siguiendo siempre con el mismo ejemplo ("default.asp?id=1&id=2"), aunque también podemos usarlo de la siguiente forma que además nos desglosará los nombres de los parámetros que hay en la colección además de sus valores correspondientes:

<%
 Dim a,b
 a=Samplx.QueryStringCount()
 If a>0 Then
 For b=0 To a
 Response.Write "Nombre del parámetro: <b>"&Samplx.QueryStringKey(b)&"</b>, "
 Response.Write "valor del mismo: <b>"&Samplx.QueryStringKeyValue(b)&"</b><br>"
 Next
 End If
 %>

Lo que nos escribirá en pantalla lo siguiente:

Nombre del parámetro: id, valor del mismo: 1
Nombre del parámetro: id, valor del mismo: 2

Si queremos trabajar sólo con un sólo parámetro y aislar el resto podemos utilizar la función Samplx.QueryStringKeyCount que nos devuelve el número de veces que el parámetro que estemos buscando se repita, en el siguiente ejemplo en pantalla se escribiría "2" ya que estamos buscando la cantidad de veces que el parámetro se repite en toda la cadena:

<%=Samplx.QueryStringKeyCount("id")%>

Nuevamente podremos volver a utilizar la función Samplx.QueryStringKeyValues de la siguiente forma:

<%
 Dim a,b
 a=Samplx.QueryStringKeyValues("info")
 If IsArray(a) Then
 For b=0 To UBound(a)
 Response.Write "Valor del ID "&b&": <b>"&a(b)&"</b><br>"
 Next
 End If
 %>

Que en pantalla nos escribiría lo siguiente:

Valor del ID 0: 1
Valor del ID 1: 2

La mayor ventaja de utilizar éstas funciones es que en las mismas, tanto el nombre como el valor de los parámetros se devuelven totalmente saneados al usuario, previniendo ataques Cross-Site Scripting (XSS), por lo que el usuario puede trabajar tranquilamente con dichos valores en pantalla.

Samplx y el objeto Request.Form

Trabajar con formularios bajo POST es tan simple cómo utilizar la colección Form del objeto Request de ASP, lo único que debemos tener en cuenta es de nunca utilizar las variables de servidor "REQUEST_METHOD" para averiguar si es con "GET" u "POST" la petición que se está realizando.

Un ejemplo claro, de uso típico en nuestros formularios es:

<%If Request.ServerVariables("REQUEST_METHOD")="POST" Then
 Dim txt,Item
 For Each Item In Request.Form
 txt = txt & Item & "="& Request.Form(Item) & "<br>"
 Next
 End If%>
 <!--llamo al código VbScript en nuestro HTML-->
 <%=txt%>

En su lugar deberemos utilizar la función Samplx.Post() de la siguiente forma:

<%If Samplx.Post() Then
 Dim txt,Item
 For Each Item In Request.Form
 txt = txt & Item & "="& Request.Form(Item) & "<br>"
 Next
 End If%>
 <!--llamo al código VbScript en nuestro HTML-->
 <%=txt%>

Observa como sólo se diferencia en la primera línea del código fuente, escribiendo incluso mucho menos y con algunas ventajas adicionales de seguridad (Anti-SpamBots), aunque si además agregamos una funcionalidad extra a nuestro código para hacerlo más seguro (cómo evitar inyecciones XSS), entonces escribimos lo siguiente.

<%If Samplx.Post() Then Dim txt,Item For Each Item In Request.Form txt = txt & Samplx.XSSdead(Item) & "="& Samplx.XSSdead(Request.Form(Item)) & " " Next End If%>  <%=resultado%>

Funciones, procedimientos y métodos

Samplx.putApp(a,b) (función) inserta una nueva variable en el objeto Application (o edita la misma)
"test" a es el nombre de la aplicación y "demo" b es el valor que la misma contiene <%Samplx.putApp("test","demo")%>
Samplx.clearApp(a) (función) destruye el objeto Application si existe <%Samplx.clearApp("test")%>
Samplx.Include(a) (función) incluye un archivo y ejecuta su código, soporta HTML, XML, CSS, JavaScript y ASP 3.0 & VbScipt (Server Side) <%Samplx.Include("/archivo.asp")
Samplx.IncludeRemote(a) (función) idéntica a la función Samplx.Include(a), sólo que el archivo puede estar alojado en cualquier servidor Web <%Samplx.IncludeRemote("http://my.web.site/api/?test=demo")
Samplx.remoteFile(a,b,c) (función) incluye un archivo remoto, soporta HTML, XML, CSS y JavaScript. <%=Samplx.remoteFile("http://my.web.site/api/?test=demo")
Samplx.Post() (función) nos indica si se está utilizando el método POST de HTTP. <%If Samplx.Post() Then
Samplx.maskUrl(a) (función) enmascara dinámicamente los hipervínculos de nuestras páginas <%=Samplx.maskUrl("/productos.asp?id=1")%>
Samplx.getVar(a) (función) devuelve el valor de la variable <%=Samplx.getVar("id")%>

Trabajando con la función Samplx.FSO (FileSystemObject)

Verificando si existe la carpeta "productos" en la raíz del servidor, ejemplo:

<% If Samplx.FSO(0,"/productos","") Then ' tu código fuente End If%>

Verificando si existe el archivo "productos/default.htm" en la raíz del servidor, ejemplo:

<% If Samplx.FSO(1,"/productos/default.htm","") Then ' tu código fuente End If%>

Leer el archivo "productos/default.htm" en la raíz del servidor, ejemplo:

 <%=Samplx.FSO(3,"/productos/default.htm","")%>

Escribiendo el archivo "default1.htm" en la raíz del servidor, ejemplo:

 <%=Samplx.FSO(4,"/productos/default.htm","el contenido de la pagina")%>

Borrando el archivo "productos/default.htm" del servidor, ejemplo:

 <%=Samplx.FSO(5,"/productos/default.htm","")%>

Borrando la carpeta "productos" del servidor, ejemplo:

 <%=Samplx.FSO(6,"/productos","")%>

Obtener todas las subcarpetas de "productos" del servidor, ejemplo:

<%Dim arrayCarpetas,n,carpetas '' el valor de la funcion que devuelve las subcarpetas es un array arrayCarpetas=Samplx.FSO(7,"/productos","") carpetas="" For n=0 To UBound(arrayCarpetas)-1 carpetas=carpetas&arrayCarpetas(n)&" " Next%>  <%=carpetas%>

Obtener todos los archivos de la carpeta "productos" del servidor, ejemplo:

<%Dim arrayFiles,n,files '' el valor de la funcion que devuelve los archivos es un array arrayFiles=Samplx.FSO(8,"/productos","") files="" For n=0 To UBound(arrayFiles)-1 files=files&arrayFiles(n)&" " Next%>  <%=files%>

Limitaciones de Samplx

El modo de trabajar con Samplx hará que tengas que realizar pequeñas modificaciones en el código fuente de tus funciones, así como evitar ciertas prácticas de uso común entre desarrolladores que usen ASP/VbScript, éstas son:

Trabajar con determinadas funciones en VbScript

Típicamente cuando deseamos saber si el valor de una variable es igual/mayor o igual/menor a otra utilizamos el siguiente código:

<%
 '' si var1 menor/igual var2
 If var1 <= var 2 Then
 '' si var1 mayor/igual var2
 If var1 >= var 2 Then
 %>

Cuando usemos Samplx debemos sustituir dicha función por la siguiente:

<%
 '' si var1 menor/igual var2
 If minusPlus(var1,var,0) Then
 '' si var1 mayor/igual var2
 If minusPlus(var1,var,1) Then
 %>

Esto ocurre porque cómo estamos ejecutando código, el intérprete de VbScript pensará que estamos asignado un valor ("If var1 <") a alguna variable ("var 2 Then") y provocará un error de compilación, otra limitación que también provocará el mismo error, es el uso de la función "Eval" de VbScript, ejemplo:

<%
 If Eval("var1 = var2") Then
 %>

Cuando usemos Samplx debemos sustituir dicha función por la siguiente:

<%
 If oEval(var1,var) Then
 %>

Uso del Response.Write

Lo más normal es que utilicemos esto muchisimas veces en nuestro código, el mejor consejo es que te olvides de dicha sentencia y concatenes todo tu código ASP en variables y/o funciones, para llamarlo de la siguiente forma dentro de tu HTML:

<%
 '' creo una variable simple con numeros
 Dim var1,n
 var1=""
 For n=0 To 10
 var1=var1&n&"<br>"
 Next
 %>

<html> <head> </head> <body> <%=var1%> </body> </html>

Esto ocurre porque toda respuesta a través del uso del Response.Write se escribirá primero en la página, incluso ántes del código HTML, de paso es una forma de optimizar código y no sobrecargar al servidor con constantes responses.

Heredando clases y funciones globales o en determinadas secciones

Muchas veces en nuestros desarrollos, necesitamos crear determinadas clases o incluir funciones para luego poder llamarlas en las páginas de nuestro sitio, y hasta algunas veces nos encontramos la necesidad de que determinada clase y/o función "viva" en todo nuestro sitio Web, en ese caso Samplx ayuda al desarrollador a crear clases u objetos que pueden fácilmente ser heredados por determinadas páginas o secciones del sitio, incluso haciéndolas globales para toda la aplicación si es que el desarrollador así lo cree conveniente.

La forma más fácil de crear una clase global (sólo dicho objeto!), es editar el archivo "samplx.xml" en nuestro directorio "/bin/api" y agregar una nueva clase (class) que automáticamente se declarará cómo global para todo el sitio, con lo cuál podrá ser llamada en cualquier momento de la aplicación sin importar desde que página o sección se trate.
Para ello simplemente crea un nuevo nodo con un único argumento ("name") al que le asignarás el nombre de cómo va a ser llamada tu clase desde el código fuente, ejemplo:

<% '' llamo a una determinada función '' de la clase creada en el archivo "samplx.xml" con el nombre "myClass" Dim resultado resultado=myClass.myFunction() %>

Nota cómo no debes crear el objeto ya que el mismo se encuentra declarado en la página, con lo cuál lo único que debemos hacer es simplemente llamar a sus propiedades y/o funciones.

La forma válida de incluir tu nueva clase en el archivo "samplx.xml" sería:

<class name="myClass"><![CDATA[<% '' aqui el código de la clase, IMPORTANTE!, no es necesario declararla cómo tal '' código fuente de la clase %>]]></class>

IMPORTANTE!, al incluir tu nueva clase en el archivo "samplx.xml", sólo es necesario darle un nombre al argumento "name", no es necesario declararla cómo tal, ejemplo de código que no es válido y que provocaría un mensaje de error sería el siguiente:

<class name="myClass"><![CDATA[<% '' ejemplo de código no válido '' IMPORTANTE!, una nueva clase no es necesario declararla cómo tal '' Class myClass '' algo de código '' End Class %>]]></class>

Ahora bien, si lo que se desea es agregar funciones globales o cualquier otro objeto e incluso otras clases (las cuales SI deben declararse), lo único que debes hacer es editar el archivo "global.xml" dentro del mismo directorio e incluir todo tu código dentro del nodo "<object name="global">" de dicho archivo, en el mismo incluso puedes realizar los llamados a tus funciones a través de las propias funciones que Samplx te brinda para ello, esto es utilizando "Samplx.Include()","Samplx.IncludeRemote()", "Samplx.FSO()") y/o "Samplx.Mods()" (uso recomendado).

Si lo que se desea es únicamente declararla para determinadas secciones de nuestro sitio (esto es páginas Web), se pueden utilizar diferentes funciones ("Samplx.Include()","Samplx.IncludeRemote()" y/o "Samplx.FSO()") que se agregaran dentro de las páginas que las incluyan, cómo también podemos usar la función "Samplx.Mods()" de la cuál trataremos más adelante.

Otra forma con la cuál podemos heredar clases o funciones que no necesiten ser globales, es a través del parámetro "include" de nuestro archivo "rewrite.xml", para ello sólo necesitamos agregar los archivos que necesitan ser llamados separados por comas ",", ejemplo: include="/myClass.asp,/myFunction.asp,http://my.web.service/mySub.asp", hecho esto dichos archivos y sus funciones estarán activas y podrán ser llamadas en la página a dónde se estén redirigiendo las peticiones, nota que todas las páginas comienzan por "/" que es la ruta de la raíz de tu sitio Web interno, esto es no desde la raíz pública de tu sitio, sino desde la raíz del directorio "/bin/src", si no se escribe dicho carácter al principio de la cadena se entenderá que el archivo se encuentra en la raíz de dicho directorio, caso que el mismo sea una URL (ejemplo del archivo "http://my.web.service/mySub.asp", el código se incluirá de forma remota (puedes también incluir archivos a través de HTTPS ya que el funcionamiento es idéntico).

Resumiendo las llamadas a través del parámetro "include" de nuestro XML son válidas de las siguientes formas.

include="/myClass.asp,/myFunction.asp,http://my.web.service/mySub.asp"
include="myClass.asp,myFunction.asp,http://my.web.service/mySub.asp"

¿Que sucede si me equivoco escribiendo mis objetos heredados?

Respuesta: Absolutamente nada, pongamos de ejemplo la situación siguiente:

include="/myClass.asp,/myFunction.asp/mySub.asp"

Nota cómo "myFunction.asp" y "mySub.asp" no se encuentran separados por coma ",".
Lo que sucede en éste caso es que el archivo "/myClass.asp" se llamará correctamente y estará listo para usarse, pero los archivos siguientes myFunction.asp" y "mySub.asp", no serán incluidos y por lo tanto las funciones y/o procedimientos que éstos contengan no estarán disponibles.

Trabajando con Mods (aplicaciones en XML)

¿Que es son los Mods y para que sirven?

Los Mods no son más que archivos XML que pueden contener desde simples variables hasta funciones, clases e incluso una aplicación completa en su seno.

Los Mods son ejecutados desde la carpeta "/bin/mods", que a su vez pueden contener subcarpetas con diferentes Mods (si es que necesitas varios XML para crear una nueva aplicación y te resulta incómodo trabajar con todo el código embebido en un único archivo, siempre puedes conservar todo el código centralizado en una sola carpeta).

Un ejemplo muy básico de la creación y uso de los Mods es la siguiente:

Creamos un nuevo XML con el siguiente texto y lo salvaremos con el nombre "demo.xml" en la subcarpeta "test" dentro de la carpeta raíz "/bin/mods":

<?xml version="1.0" encoding="iso-8859-1" ?> <myobject> <myobject name="test"><![CDATA[<% Dim myTestVar myTestVar="something" %><%=myTestVar%>]]></myobject> </myobject>

Luego llamamos al Mods que hemos creado desde cualquier lugar de nuestro sitio de la siguiente forma:

<%=Samplx.Mods("/test/demo.xml","myobject","name:test")%>

Lo que nos escribirá en pantalla el valor de la variable "myTestVar" creada dentro del Mods que hemos creado, pero que tal si nos queremos "complicar" un poco más y deseamos tener varios "objetos" con diferentes argumentos en el mismo archivo para llamarlos según nos sea conveniente?
Volvemos nuevamente a nuestro archivo "demo.xml" y modificaremos un poco su código hasta dejarlo de la siguiente forma:

<?xml version="1.0" encoding="iso-8859-1" ?> <myobject> <myobject name="test" complex="data"><![CDATA[<% Dim myTestVar myTestVar="something" %><%=myTestVar%>]]></myobject> <myobject name="test" complex="data_var"><![CDATA[<% Dim myTestVar myTestVar="something" %>]]></myobject> <myobject name="test1" complex="one"><![CDATA[<% Dim myTest1 myTest1=Samplx.Mods("/test/demo.xml","myobject","name:test,complex:data") %><%=myTest1%>]]></myobject> <myobject name="test1" complex="two"><![CDATA[<% Dim myTest1 Response.Write Samplx.Mods("/test/demo.xml","myobject","name:test,complex:data_var") myTest1=myTestVar %><%=myTest1%>]]></myobject> </myobject>

Ahora llamaremos a nuestro Mods de cualquiera de las siguientes formas:

<%=Samplx.Mods("/test/demo.xml","myobject","name:test,complex:data")%> <%=Samplx.Mods("/test/demo.xml","myobject","name:test1,complex:one")%> <%=Samplx.Mods("/test/demo.xml","myobject","name:test1,complex:two")%>

¿Que es lo que sucede en los tres casos?, nos sigue escribiendo en pantalla el valor de la variable "myTestVar" cualquiera sea la forma en la cual llamemos al Mods.

Cómo veras los Mods no sólo sirven para crear pequeños objetos, sino que además puedes utilizarlos para embeber complejas aplicaciones con sólo simples argumentos.

Cabe acotar que los Mods pueden contener la cantidad de nodos que tu aplicación necesite, siempre teniendo en cuenta que el árbol de nodos sea siempre el mismo dentro del archivo XML.

También es importante destacar que la cantidad de argumentos y/o los nombres de cada uno de ellos, además del nombre del árbol de objetos es totalmente libre, pudiendo de ésta forma escribirlos adaptándolo a tus necesidades, y ya por último, aunque no por ello menos importante, es saber que cuando escribimos nuestros Mods, podemos mezclar código ASP, VbScript, HTML, JavaScript y/o CSS indistintamente.

Nunca ejecutes código externo que no sea de tu propiedad, de esa forma estarás entregando la llave de tu servidor a un tercero que podría atacarte robando toda tu información, llegando incluso a borrar todos los archivos de tu sitio Web y ocasionándote un daño irreparable!

Samplx se encuentra protegido bajo una licencia de Creative Commons.