Septiembre del 2005
En mi artículo anterior os hablaba de las prendas y virtudes de Ajax, y me quedé con la sensación de haberme quedado muy corto en mis explicaciones y en las implicaciones que conlleva este método (no lo llamaré tecnología tal y como explica Jesse James Garrett en http://www.adaptivepath.com/publications/essays/archives/000385.php.
No obstante, ahora que ya tenemos más o menos claro qué es Ajax, cómo se hace con javascript etc... Llega el "momento API"!!!!!
El momento API es el momento de perfeccionamiento de una técnica o de cualquier tipo de programación. Es el momento en el que todo ese código diseminado, "scattered", forma un conjunto y se vuelve algo profesional.
Yo he optado por tomar prestado una API que hasta el momento ha atendido todas mis necesidades. Se trata de la API de Sarissa:
https://sourceforge.net/projects/sarissa/
Es un proyecto "open source" con el que unificamos el uso de Ajax para diferentes navegadores, no sé si Opera y otros, pero sí para Mozilla e Internet Explorer, y KHTML(Konqueror y Safari).
APIs javascript
Quien nunca haya utilizado una API de javascript, pensará una API de javascript? Ese lenguaje horrible que no puede depurarse como los verdaderos lenguajes de programación?
Eso no puede traer nada bueno!!
Pues bien, se equivocan, por supuesto, javascript no es perfecto, pero conocer javascript para un programador web es como el volante para un conductor, y sin javascript, no hay programador web. Suena obvio pero no es tanto así, porque el programador web tiende a aferrarse al lenguaje de servidor y aunque en una gran empresa todo el trabajo está dividido y seguramente no le toque escribir ni una línea de javascript, para optimizar la navegación del usuario, resulta necesario al 100%.
Al igual que antes los locos del javascript debieron adaptarse a los descubrimientos más óptimos de las CSS, ahora que xmlhttpRequest está dando fuerte, a los programadores ya no les queda otra que aprender javascript o se quedarán obsoletos. De hecho, todos los programadores tenemos que reintepretar la web y la forma de programar, y se debe invertir un período en reflexiónar al respecto.
Beneficios de una API:
-Una API de javascript hace como cualquier otra API, centraliza el código, ahorra código y se edita con facilidad
porque sólo hay que modificarlo una vez.
Negativos de una API:
-El código se vuelve más difícil, el programador tiene que aprender nuevos códigos y sin una buena documentación es de difícil modificación.
Tomando todo esto en cuenta, yo principalmente opto por las APIs de javascript pero no las totalizadoras, que hacen todo lo que quieras en tu web, sólo en casos concretos, donde las diferencias de códigos entre navegadores se vuelve más dispar.
El caso más claro de una buen API es la maravillosa y famosa API de dhtmlcentral.com. Es una API que me ha acompañado siempre y que he mejorado con el tiempo.
Qué conseguimos con una API si javascript hace unas tareas muy sencillas? Pues simplemente, unificamos el javascript que utilizan todos los navegadores. Por ejemplo, para ocultar una capa se hace diferente en IE4 que en IE6, Mozilla o Netscape 4.5. Con la API de dhtmlcentral escribimos una línea y lo hace compatible para todos.
Esto mismo conseguimos con Sarissa, más otras tareas relacionadas con el DOM.
Sarissa, la API para Ajax
En este tutorial, voy a tratar 2 métodos de cargar XML con Ajax.
Uno utilizando XmlhttpRequest y otro cargando XML con el objeto load, que en IE pertenece al ActiveX Msxml2.DOMDocument, y que en Mozilla se implementa de otra manera.
No obstante, como decía más arriba, no nos vamos a preocupar de las diferencias entre navegadores porque Sarissa hará los deberes por nosotros.
El resultado con ambos métodos es el mismo. No obstante, xmlhttpRequest, nos ofrece un mejor control sobre el estado de la carga del xml, porque podemos utilizar la propiedad ReadyState.
Como último apunte, Sarissa no se implementa creando una clase Sarissa, sino que se llama de manera estática.
Empecemos de lleno:
1.-Bajamos la API de su web.
2.-Incluimos los js:
<script language="javascript" src="sarissa.js"></script>
<script language="javascript" src="sarissa_ieemu_xpath.js"></script>
3.-Creamos el formulario que describía en mi último tutorial sobre Ajax, pero incluyendo un nuevo enlace que llama a getDatosXML para cargar XML utilizando load:
<div id="lblError">
</div>
<form id="detalles" name="detalles" method="post">
<table cellpadding="0" cellspacing="0" border="0">
<tr>
<td nowrap="nowrap" class="items" style="visibility:hidden">Metatags:</td><td>
<textarea cols="40" rows="1" name="metatags" id="metatags"></textarea>
</td>
</tr>
<tr>
<td nowrap="nowrap" class="items" style="visibility:hidden">Descripción:</td><td>
<textarea cols="40" rows="1" name="descripcion" id="descripcion"></textarea>
</td>
</tr>
<tr>
<td nowrap="nowrap" class="items" style="visibility:hidden">Descripción larga:</td><td>
<textarea cols="40" rows="1" name="descripcionlarga" id="descripcionlarga"></textarea>
</td>
</tr>
</table>
<div class="buttons1"><a href="javascript:getDatos()">Llenar</a></div>
<div class="buttons1"><a href="javascript:getDatosXML()">LlenarXML</a></div>
</form>
4.-Ahora incluyamos las funciones getDatos y getDatosXML:
var xmlhttp=null;
function getDatos(){
if(xmlhttp && xmlhttp.readyState!=0 && xmlhttp.readyState!=4){
alert("espere mientras la conexión anterior termina")
return;
}
strUrl="xmlhttp_select.cs.asp?docid=4"
xmlhttp = new XMLHttpRequest();
xmlhttp.open("GET", strUrl, true);
xmlhttp.onreadystatechange=handlergetDatos
xmlhttp.send(null);
}
function getDatosXML(){
strUrl="xmlhttp_select.cs.asp?docid=4"
respuestaXML= Sarissa.getDomDocument();
respuestaXML.async = false;
respuestaXML.load(strUrl);
mostrarDatos(1)
}
Como vemos más arriba, hemos reducido mucho el código, ya no tenemos ninguna función que se encarga de crear la compatibilidad del objeto xmlhttpRequest. De esto se encarga Sarissa, que ha redefinido el objeto, un poco como se hace con los métodos en .Net con la propiedad "override".
De momento, ya vemos un ahorro de código, y además el sistema está mejorado porque Sarissa para IE, va a hacer un loop a través de los diferentes Activex que utiliza IE para crear el xmlHttpRequest hasta que encuentre el apropiado. Es decir, los activeX:
"Msxml2.XMLHTTP.5.0", "Msxml2.XMLHTTP.4.0", "MSXML2.XMLHTTP.3.0", "MSXML2.XMLHTTP", "Microsoft.XMLHTTP.
Para la función getDatosXml. También ahorramos porque la forma de crear el objeto, lo hará de modo conveniente dependiendo del navegador, y además para IE mejorará el método haciendo un loop buscando la clase apropiada entre:
"Msxml2.DOMDocument.5.0", "Msxml2.DOMDocument.4.0", "Msxml2.DOMDocument.3.0", "MSXML2.DOMDocument", "MSXML.DOMDocument", "Microsoft.XMLDOM"
En mi código, he incluido una mejora:
if(xmlhttp && xmlhttp.readyState!=0 && xmlhttp.readyState!=4){
alert("espere mientras la conexión anterior termina")
return;
}
Con lo cual nos aseguramos que las diferentes conexiones no se pisan.
5.-Incluyamos la función que controla la carga de datos del xmlhttprequest:
function handlergetDatos(){
if(xmlhttp.readyState==2)
{
document.getElementById("lblError").innerHTML="Cargando datos";
}
if(xmlhttp.readyState==3)
{
document.getElementById("lblError").innerHTML="Datos cargados";
}
if(xmlhttp.readyState==4)
{
document.getElementById("lblError").innerHTML="Carga de datos completada";
if(xmlhttp.status==200)
{
respuestaXML=xmlhttp.responseXML
mostrarDatos();
}else{
alert("no se encuentra el documento xml")
}
}
}
Aquí hemos mejorado la forma de hacer un seguimiento del estado de la conexión.
Un detalle a tener en cuenta es que al final la función mostrarDatos, va a utilizar el objeto respuestaXML. En el caso de cargarlo como documento XML usando load. La respuesta xml ya estaá contenida en el objeto mismo,pero en el caso de xmlhttpRequest, respuestaXML equivale a xmlhttp.responseXML.
Desde ese momento ambos XML son iguales y se tratan igual.
6.-Incluimos la función mostrarDatos:
function mostrarDatos(){
numNode=0;
document.getElementById("lblError").innerHTML="";
try{
if(respuestaXML.parseError!=0){
throw "Posible formato erróneo:" + respuestaXML.parseError;
}
xmlmetatags=Sarissa.getText(respuestaXML.selectNodes("root/message/metatags")[numNode])
xmldescripcion=Sarissa.getText(respuestaXML.selectNodes("root/message/descripcion")[numNode])
xmldescripcionlarga=Sarissa.getText(respuestaXML.selectNodes("root/message/descripcionlarga")[numNode])
Sarissa.clearChildNodes(document.getElementById("metatags"))
Sarissa.clearChildNodes(document.getElementById("descripcion"))
Sarissa.clearChildNodes(document.getElementById("descripcionlarga"))
document.getElementById("metatags").appendChild(document.createTextNode(xmlmetatags))
document.getElementById("descripcion").appendChild(document.createTextNode(xmldescripcion))
document.getElementById("descripcionlarga").appendChild(document.createTextNode(xmldescripcionlarga))
}
catch(e)
{
document.getElementById("lblError").innerHTML="error cargando xml."+e+"<br>Lea la descripcíon del error y
póngase en contacto con su departamento técnico:<br>"+Sarissa.getParseErrorText(respuestaXML);
}
}
Esta es la función que crea la magia.
Después de haber comprobado que se ha cargado sin problemas, seguimos haciendo comprobaciones:
if(respuestaXML.parseError!=0){
Con esto vamos a saber si el xml está mal formado.
Sarissa en este sentido nos ofrece 1 propiedad:
respuestaXML.parseError
que debería ser 0 si no hay error.
Y un método para recuperar el error:
Sarissa.getParseErrorText(respuestaXML)
Ahora es cuando utilizamos el segundo .js que incluimos sarissa_ieemu_xpath.js:
xmlmetatags=Sarissa.getText(respuestaXML.selectNodes("root/message/metatags")[numNode])
Con el método getText vamos a recuperar el valor del nodo que le indiquemos. Para eso utilizamos el selectNodes si hay
más de una misma etiqueta (en este caso metatags) con un índice (numNode), o si fuera sólo uno, selectSingleNode.
Fin
Hasta aquí llega mi tutorial, un método muy bueno que utiliza google, ver:
http://serversideguy.blogspot.com/2004/12/google-suggest-dissected.html
Es utilizar en vez de una respuesta xml, una respuesta de texto, y ejecutarla como javascript, así:
eval(_xmlHttp.responseText)
Pero el lado de la fuerza incluye muchos otros métodos relacionados con hojas de estilo XML ( http://www-128.ibm.com/developerworks/xml/library/x-xslt/?article=xr ) que exploraremos otro día.Sólo mostraros un ejemplo de diccionario basado en Google Suggests:
http://www.objectgraph.com/dictionary/
Miguel Ángel.
Programador.
|
|
Hay muchos programadores que después de comprarse un flamante portátil último modelo con más caballos que un porsche, se llevan la ingrata sorpresa de que su sistema operativo Windows XP Home no soporta IIS!!!!!!
Al principio, piensan que es un espejismo, se frotan bien los ojos, pero efectivamente no aparece en "Agregar componentes de Windows". Poco después, cogitan, y buscan por todos los lados y el IIS sigue escondido, el muy bribón!
Pero lo cierto es que esos dólares que diferencian la versión Professional de la Home crean un antes y un después a la hora de comprar el sistema operativo.
Tal vez a aquellos que usan piratería normalmente esto les importe un rábano, pero los legales y aquellos que no tienen ganas de ponerse a formatear su portátil y agenciarse el sistema profesional, puede ser realmente un inconveniente molesto.
Pero relajémonos, la comunidad web, en concreto Richard Sandoz, nos ofrece una alternativa con un fantástico hack que podéis encontrar por internet en inglés (www.15seconds.com/issue/020118.htm).
Las explicaciones de R. Sandoz son muy diversas y desordenadas, además de omitir algunos pasos, y por lo tanto, altamente frustantes!!
El hackeador se merece un premio pero el profe suspenso!!
Es mejor y más detallada la explicación de adamV.com:
http://adamv.com/dev/articles/iis-on-xp-home
Os hago un pequeño resumen, que yo mismo he probado (o sufrido), y os doy unas referencias para que investiguéis. Cuando terminéis este artículo, con suerte, tendréis vuestro IIS funcionando en el XP home!!
Antes de nada decir una evidencia, no por conseguir el IIS en el Home estamos pasando un Home a Professional. Estas 2 ediciones del famoso OS tienen muchas más diferencias, sobre todo en seguridad. Para ver un buen resumen:
www.winsupersite.com/showcase/windowsxp_home_pro.asp
Lo más impresionante del hack es que vamos a utilizar en realidad el IIS del Windows 2000 pro (necesitas el CD) para utilizarlo en el XP Home!!!
Antes de llegar a este punto, hagamos el trabajo sucio.
Empecemos:
1.-Localiza:
C:WINDOWSINFSYSOC.INF
Busca la entrada:
iis=iis.dll,OcEntry,iis.inf,hide,7
Sustitúyela por:
iis=iis2.dll,OcEntry,iis2.inf,,7
2.-Copia los archivos iis.dl_ and iis.in_ (el guión bajo existe y no es un fallo, esto signifca que es un dll comprimido) del disco de Windows 2000 pro. Se encuentran en la carpeta i386 del disco de instalación.
3.-Copia el iis.in_ en C:WINDOWSINF y el iis.dl_ en C:WINDOWSSYSTEM32SETUP.
4.-Abre una consola msdos y bajo cada uno de esos directorios de arriba, escribe bajo C:WINDOWSINF en msdos:
expand iis.dl_ iis2.dll
Escribe bajo C:WINDOWSSYSTEM32SETUP en msdos:
expand iis2.in_ iis2.inf
Con lo cual, hemos descomprimido los archivos que copiamos en las carpeta idóneas, y el archivo sysoc.inf indicará a windows que busque esos archivos.
5.-Ahora ya sólo nos queda ir a agregar/quitar programas>agregar componentes de windows, y buscar en esa lista el IIS.
Marcamos la opción y desmarcamos la casilla de SMTP, este servicio nos dará problemas si lo instalamos.
6.-Siguiente. Nos pedirá el CD. Utiliza el CD de Windows 2000 pro. Y busca la carpeta i386.
7.-Una vez se haya instalado todo. Hemos hecho el camino más duro, pero caminante no hay camino, y queda aún un trecho.
De esta parte se olvidan casi todos los tutoriales que hay en internet pero es fundamental y no todo el mundo está al tanto.
Al instalar un IIS del Windows 2000, este IIS va a utilizar la forma que tenía de gestionar la seguridad bajo aquel sistema operativo, pero en la edición XP home ha variado. Ahora para el usuario anónimo, se necesita especificar el nombre de la máquina. En W2k sólo hace falta el IIS_NAME como usuario anónimo, cuando en XP home es NAME/IIS_NAME ("NAME" es el nombre de tu máquina, que puedes ver en propiedades de mi PC).
Teletranspórtate a "Administrador de servicios Internet" o sea al Manager del IIS,y cliquea botón derecho sobre el icono de tu ordenador.
a.-Junto a Servicio WWW, cliquea Modificar.
b.-elige la pestaña Seguridad de directorio
c.-verifica las casillas de acceso anónimo y seguridad de windows integrada.
d.-cliquea Modificar de acceso anónimo.
e.-En el formulario de Cuenta de Usuario Anónimo desverifica "permitir que IIS controle contraseñas"
f.-Ahora Examinar, y tienes que buscar el usuario IUSR_NAME ("NAME" es el nombre de tu máquina), lo seleccionas, aceptas las pantallas precedentes y ahora aparecerá el usuario NAME/IUSR_NAME ("NAME" es el nombre de tu máquina).
g.-Acepta todas las pantallas y OK.
8.-Comprueba escribiendo un archivo asp bajo wwwroot, y http://localhost/NombreArchivo.asp.
Y voilà!!!!!
Con esto hemos efectuado un largo camino, para algunos tal vez demasiado pesado y antes de terminar el tutorial, han instalado el XP Pro.
Esto era la primera parte.
La segunda parte habla del Visual Studio 2003 y el IIS que hemos hackeado.
1.-Instalamos el Visual Studio 2003 (por supuesto y como es obligatorio, con todos sus "prerequisites" o requisitos previos).
2.-Depuramos y fallo, no se encuentra el filtro de ASP.NET.
3.-Esto no sólo nos pasa a nosotros los hackeadores de postín.
Tenemos que registrar la dll para que aparezca como filtro en los filtros Isapi del IIS, para navegamos a:
<DRIVE>:WINDOWSMicrosoft.NETFramework<FRAMEWORK VERSION>
(normalmente:
C:WINNTMicrosoft.NETFramework 1.1.4322)
Y picamos:
asp_regiis -i
También funcionaría:
regsvr32 aspnet_isapi.dll
Este debería ser el fin de nuestros problemas, pero a mí me acosó otro error. Seguí sin hacer funcionar el .NET, y el motivo era que no tenía permisos para escribir en el wwwroot.
Esto se soluciona cambiando la carpeta raíz de nuestro IIS en el "Administrador de Servicios de Internet" a una nueva carpeta que creemos, o simplemente, cambiándole los permisos a la carpeta wwwroot.
Bueno, espero haber servido de ayuda, este artículo se lo dedico a todos aquellos que perdieron su tiempo para ayudar a los enmarronados del XP Home.
M.A.
Programador.
|
|
Por dactivo el 12 de Septiembre, 2005, 9:58 en ASP
|
A veces nos hemos preguntado. ¿Y si fuera más fácil y más claro en ASP hacer un datagrid sin tener todos los códigos html y asp entremezclados?
Qué gran injusticia sentimos cuando programamos en asp, y no podemos utilizar el control DataGrid de .Net!!! Qué desgracia para un purista ver todos esos comandos enredados y apelogotonados!!
No nos quejemos que los códigos están en nuestras manos para intentar crear la ilusión de que todo se automatiza más.
Los controles de .Net no son más que clases y por lo tanto cualquier otro lenguaje puede imitarlo, aunque sin el soporte de la magnífica plataforma de Visual Studio.
He programado una clase que tiene bastantes posibilidades, aunque no la he perfeccionado, quería ofrecerla aquí al mundo internauta y si alguien tiene el tiempo y la paciencia de perfeccionarla. Please, make me know!!
Vamos a producir un Datagrid con esta clase que pagina cada 30 ítems y que va a mostrar hasta 20 números a los que navegar, que además mostrará enlaces de "inicio", "anterior", "siguiente" y "fin.
dim updateGrid
set updateGrid=new HtmlDatagrid
updateGrid.arConexion=arConexion
updateGrid.arCampos= Array("idcentro","nombre","direccion","codigopost","prov","telefono")
updateGrid.strOrder="nombre ASC"
updateGrid.arCamposVisible=Array(0,1,1,1,1,1)
updateGrid.arThCampos=Array("id","Nombre","Dirección","Código Postal","Provincia","Teléfono")
updateGrid.btnPaginar=1 'con esto hacemos que aparezcan los botones de inicio etc...
updateGrid.numPaginar=30
updateGrid.numerosPaginacion=20
updateGrid.TableAttr="cellSpacing=""1"" id=""itemstable"" cellPadding=""1"" width=""100%"" border=""0"" style=""margin-top:30px"" summary=""Resultados de búsqueda de centros, dividido en: nombre, dirección y teléfono"""
'estilos de las filas
updateGrid.arAttr= Array ("valign='top' align='center'","valign='top'","valign='top'","valign='top' align='center'","valign='top'","valign='top'")
'estilos de la cabecera
updateGrid.arThAttr=Array("class=""fondocolorlogoclaro"" width=""60"" align=""left""","class=""fondocolorlogoclaro"" width=""120"" align=""left""","class=""fondocolorlogoclaro"" width=""160"" align=""left""","class=""fondocolorlogoclaro"" width=""100"" align=""center""","class=""fondocolorlogoclaro"" width=""120"" align=""left""","class=""fondocolorlogoclaro"" width=""120"" align=""left""")
updateGrid.display()
Como se ve es bastante sencillo.
Pero bueno, estudiemos el abracadabra-pata-de-cabra del código.
1.-Creamos la instancia de la clase.
set updateGrid=new HtmlEditDatagrid
2.-Le asignamos la conexión que debe ser un array con 5 valores:
updateGrid.arConexion=arConexion
tal que así:
Dim arConexion(5) 'array de conexion
arConexion(0)="SQLOLEDB" 'proveedor de base de datos
arConexion(1)="servidor" 'direccion del servidor
arConexion(2)="basededatos" 'base de daots
arConexion(3)="usuario"
arConexion(4)="contraseña"
arConexion(5)="tabla"
3.-Definimos los campos que vamos a recoger de nuestra consulta a la base de datos en un array, y cómo queremos que aparezcan ordenados:
updateGrid.arCampos= Array("idcentro","nombre","direccion","codigopost","prov","telefono")
updateGrid.strOrder="nombre ASC"
4.- Le colocamos el nombre de cabecera que se nos antoje, pero queremos que no aparezca una columna que se llame id, así que con la propiedad arCamposVisible le asignamos un 0:
updateGrid.arThCampos=Array("id","Nombre","Dirección","Código Postal","Provincia","Teléfono")
updateGrid.arCamposVisible=Array(0,1,1,1,1,1)
5.-Ahora definimos cómo queremos paginar:
updateGrid.btnPaginar=1 'igualado a 1, incluimos hiperenlaces a inicio, anterior,siguiente…
updateGrid.numPaginar=30 'mostrar 30 ítems
updateGrid.numerosPaginacion=20 'mostrar hiperenlaces a 20 páginas
6.-Lo demás: updateGrid.TableAttr, updateGrid.arAttr, updateGrid.arThAttr
sirve para definir los estilos de la tabla, de las filas y la cabecera etc…
7.-Finalmente lo mostramos:
updateGrid.display()
Para realizar esta maravilla os dejo la clase más abajo, pero aviso, no está nada pulida, pero cubre bastantes de las necesidades del día a día del programador.
Con esta clase he podido hacer también que las filas sean editables, sin tocar casi nada, también se pueden separar las celdas por celdas de imágenes que no tengan ninguna funcionalidad, se pueden agrupar campos y colocarlos en uno sólo, se puede crear un filtro en la consulta (where x like '%x%'), etc…
Ya iré mostrando otros ejemplos sobre el uso de esta clase en el futuro.
CLASE HTMLDATAGRID:
class HtmlDatagrid
public arConexion
public arCampos
public arCamposVisible
public arFilter
public strAdicional
public strOrder
public TableAttr
public arThcampos
public arThAttr
public arAttr
public numPaginar
public numerosPaginacion
public separadorCells
public btnCampos
public classTr
public btnPaginar
function display()
Response.Write(me.createDataGrid())
end function
function createDataGrid()
Dim conn1 'la conexión
Dim rs1 'el recordset
Dim strQuery 'cadena de la consulta
Dim strCells 'el resultado devuelto: las celdas
Dim arCamposLen 'longitud del array de campos
Dim pagina_actual 'por si estamos paginando recupera el valor de página actual
on error resume next
arCamposLen=Ubound(arCampos)
set conn1=Server.CreateObject("ADODB.Connection")
conn1.ConnectionString="Provider=" & arConexion(0) & ";Data Source=" & arConexion(1) & ";Initial Catalog=" &arConexion(2) & ";uid=" & arConexion(3) & ";PWD=" & arConexion(4)
conn1.Open
'----------------[creación de recordset]---------------
set rs1=Server.CreateObject("ADODB.Recordset")
'ordenación por strOrder
rs1.Sort=strOrder
rs1.ActiveConnection=conn1
rs1.CursorType=1
rs1.LockType=3
rs1.CursorLocation=3
'-----------construimos cadena de la consulta
Dim i 'dummy
Dim campo 'dummy
for i=0 to arCamposLen
'si el campo es un array
'puede ser un array porque es posible que queramos agrupar
'varios campos en una fila
if isArray(arCampos(i)) then
for each campo in arCampos(i)
strQuery=strQuery & campo
strQuery=strQuery & ","
next
else
'si el campo no es un array
strQuery=strQuery & arCampos(i)
strQuery=strQuery & ","
end if
next
'le quitamos la última coma
strQuery=left(strQuery,Len(strQuery)-1)
'------------------[filtramos según arFilter]
if isArray(arFilter) then
Dim strFilter
Dim strSeparadorIni
Dim strSeparadorFin
'nuestro filtro incluye 3 campos así que saltamos de 3 en 3
for i=0 to Ubound(arFilter) step 3
'aquí es donde vamos a utilizar un tipo de operador u otro
if arFilter(i+1)="like" then
strSeparadorIni="'%"
strSeparadorFin="%'"
else
strSeparadorIni="'"
strSeparadorFin="'"
end if
strFilter=strFilter & arFilter(i) & " " & arFilter(i+1) & strSeparadorIni & arFilter(i+2) & strSeparadorFin & "and "
next
'le extraemos el último "and"
strFilter=left(strFilter,Len(strFilter)-4)
strFilter=" where " & strFilter
end if
strQuery="select " & strAdicional & strQuery & " from " & arConexion(5) & strFilter
'Response.Write(strQuery)
rs1.Source=strQuery
rs1.Open
if not rs1.EOF then 'if -rs1.eof
'--------recuperamos la página en la que nos encontramos en caso de estar paginando
Dim strResults ' recoge los números de la paginación etc...
Dim numRegistros 'número de registros del recordset
numRegistros=rs1.recordcount
'Response.Write(numRegistros)
if numPaginar<>"" and numRegistros>numPaginar then '--------if-paginacion
if (request.queryString("page") <> "") then
pagina_actual = request.queryString("page")
else
pagina_actual = 1
end if
'si existe algún resultado, ejecuta el resto
rs1.pagesize=numPaginar
rs1.absolutePage = pagina_actual 'nos situamos en la página actual
'---------creamos el índice de páginas
'resultados
strResults=strResults & "<br>Resultados <b>" & (pagina_actual*numPaginar-numPaginar+1) & " a " & ((pagina_actual*numPaginar)) & "</b>"
strResults=strResults & "<br><br>"
strResults=strResults & "<center>"
if pagina_actual <>1 then
'hacemos que aparezcan los botones de inicio etc...
if btnPaginar<>"no" then
strResults=strResults & "<a href=""?page=1"" class=""paginar"" title=""ir a inicio"">[Inicio]</a>"
strResults=strResults & "<a title=""Ir a pagina anterior"" class=""paginar"" href=""?page=" & (pagina_actual-1) & """>[Anterior]</a>"
end if
end if
'números de paginación
dim k 'dummy
dim hrefClass 'la clase de los números
k=1
dim numDiv 'nos va a servir para corregir un error
dim numPag
numPag=0 'guarda número del menu de las páginas que se muestra
Do While k <= rs1.PageCount
numDiv=roundDown(pagina_actual/numerosPaginacion)
if pagina_actual mod numerosPaginacion = 0 then
numDiv=numDiv-1
end if
numPag=numDiv*numerosPaginacion
numPag=numPag+k
'sólo vamos a mostrar numerosPaginacion páginas
if k<=numerosPaginacion and numPag<=rs1.PageCount then
'sólo vamos a mostrar numerosPaginacion páginas
if rs1.PageCount>numerosPaginacion then
if numPag=cint(pagina_actual) then
hrefClass="negrita"
else
hrefClass="paginarN"
end if
strResults=strResults & " <b><a title=""ir a pagina " & numPag & """ class=""" & hrefClass & """ href=""?page=" & numPag & """>" & numPag & "</a> </b>"
else
if k=cint(pagina_actual) then
hrefClass="negrita"
else
hrefClass="paginarN"
end if
strResults=strResults & " <b><a title=""ir a pagina " & k & """ class=""" & hrefClass & """ href=""?page=" & k & """>" & k & "</a> </b>"
end if
k=k+1
else
exit do
end if
Loop
'insertamos letreros de siguiente y fin
if cint(pagina_actual)<> rs1.PageCount then
if btnPaginar<>"no" then
strResults=strResults & "<a href=""?page="& (pagina_actual+1) & """ class=""paginar"" title=""ir a página siguiente"">[Siguiente]</a>"
strResults=strResults & "<a title=""Ir a página final"" class=""paginar"" href=""?page=" & (rs1.PageCount) & """>[Fin]</a>"
end if
end if
strResults=strResults & "</center>"
strCells=strCells & strResults
end if '-------if-paginacion
'-------------------[loop: creación de cabecera]-------------------
strCells=strCells & "<table " & TableAttr & ">"
dim j 'dummy
if isArray(arThcampos) then'if-arthAttr
strCells=strcells & "<tr>"
for j=0 to arCamposLen
if arCamposVisible(j)=1 then
strCells=strCells & "<TH " & arThAttr(j) & "><b> " & arThcampos(j) & "</b> </TH>"
end if
next
strCells=strCells & "</tr>"
end if'if-arthAttr
'----------------[loop: creación de tabla]---------------
if numPaginar="" then 'colocamos la paginación más allá de cualquier límite si no existe
numPaginar=100000
end if
Dim cuentaRegistros
cuentaRegistros=0 'contaremos cuántos registros muestra para que pare en numPaginar
dim cellValue 'valor de los campos, de no haber, se sustituye por en caso de que utilicemos bordes es útil
dim m 'dummy
dim boton 'variable que utilizaremos si hay botones
dim campovalor'tambien lo utilizamos si hubiera botones
if classTr<>"" then
classTr="class=""" & classTr & """"
end if
do while not rs1.EOF and cuentaRegistros<numPaginar
cuentaRegistros=cuentaRegistros+1 'esto hará que se pare en numPaginar
strCells=strCells & "<tr " & classTr & " >"
'creamos las celdas
for j=0 to arCamposLen 'for-arcamposlen
cellValue=""
'si queremos que se vea
if arCamposVisible(j)=1 then 'if -visible
'si es una agrupación de valores
if IsArray(arCampos(j)) then
m=0
for each campo in arCampos(j)
cellValue=cellValue & rs1(campo)& arGroupFSeparators(m)
m=m+1
next
'si es botón es que el campo es "' ' as"
'si es un alias para crear botones etc...
elseif left(arCampos(j),1)="'" then
boton=btnCampos(j)
campovalor=arCampos(j)
campovalor=mid(campovalor,2,1)
campovalor=arCampos(campovalor)
campovalor=rs1(campovalor)
execute("cellValue=" & boton & "(""" & campovalor & """)" )
else
if rs1(arCampos(j))="" or rs1(arCampos(j))=" " or rs1(arCampos(j))=" " then
cellValue=" "
else
cellValue=rs1(arCampos(j))
end if
end if
strCells=strCells & "<TD " & arAttr(j) & ">"& cellValue & "</td>"
end if'if -visible
next 'for-arcamposlen
strCells=strCells & "</tr>"
|
|
|