Exibindo a lista dos usuários logados atualmente

Salve,

neste artigo, iremos descrever o processo de criação de uma listagem dos usuários logados no site, quer sejam anônimos ou autenticados, tal como possuímos aqui no ASP4Developers, na aba "onliners" aí ao lado. Isso é interessante para manter os usuários cientes de que não estão sozinhos, possibilitando uma maior interação entre os mesmos.

Antes de mais nada, precisaremos trabalhar com o Global.asa. Se seu host não suportar seu uso, infelizmente, não há como fazer o que estamos propondo. Chovendo no molhado, o Global.asa deve estar no diretório raiz da pasta virtual, criada no IIS ou PWS. Iniciaremos com o Application_OnStart, onde iremos inicializar a variável que armazenará a lista dos usuários.

Sub Application_OnStart()
 Application("UsuariosLogados") = "<usuarios />"
End Sub

Antes que você pense: "Lá vem o Rubens com aquele papo de XML", já adianto que vai ser com XML mesmo. Não há um motivo específico para isso. Poderíamos armazenar arrays, strings separadas por vírgulas, ou mesmo um objeto Dictionary. Acho XML mais interessante, pois permite que façamos testes com estruturas simples, que podem ser facilmente migradas para outras, mais complexas, além de nos familiarizarmos com aplicações que fazem uso do XML. Como veremos adiante, isso *não* deixa o código mais complicado.

Ok, vamos agora alimentar a variável de aplicação. Toda vez que um usuário acessar a aplicação (leia-se: quando o Session_OnStart for disparado), incluiremos um elemento no documento XML. Ficaria assim:

Sub Session_OnStart

 'Impedir que outros usuários acessem este código simultaneamente
 Application.Lock

 Dim objXMLDoc, objUsuario
 'Instanciar objeto XML. Verifique se o mesmo existe no seu servidor.
 Set objXMLDoc = Server.CreateObject("MSXML2.DOMDocument.3.0")
 'Carga síncrona. Não passe para a próxima instrução sem carregar o xml inteiro.
 objXMLDoc.async = false
 'Carregue a string XML, já tomando cuidado com caracteres acentuados.
 objXMLDoc.loadXML "<?xml version=""1.0"" encoding=""ISO-8859-1""?>" & _
  Application("UsuariosLogados")

 'Criar um novo elemento
 Set objUsuario = objXMLDoc.createElement("usuario")
 'Setar os atributos "id" e "nome"
 objUsuario.setAttribute "id", Session.SessionId
 objUsuario.setAttribute "nome", "Anônimo"
 'Adicionar o novo elemento ao documento já existente
 objXMLDoc.documentElement.appendChild objUsuario

 'Atualizar variável de aplicação
 Application("UsuariosLogados") = objXMLDoc.documentElement.xml
 'Liberar recursos alocados com o objeto
 Set objXMLDoc = Nothing

 'Liberar aos demais usuários (no bom sentido, é claro!)
 Application.Unlock

End Sub

O que é muito importante percebermos no código acima, é que o componente MSXML2.DOMDocument.3.0 precisa estar instalado no servidor. Caso o seu não o possua, o mesmo pode ser obtido gratuitamente no site da Microsoft.

Muito bem! Já possuímos a variável de aplicação com a lista de usuários. Mas, onde/quando removê-lo da lista ? Em outras palavras, não quero que um determinado usuário seja listado para sempre! Como proceder ?

Isso mesmo que você pensou! Vamos usar o evento Session_OnEnd para remover o usuário da lista! Mãos à obra:

Sub Session_OnEnd()

 Application.Lock

 Dim objXMLDoc, objUsuario
 Set objXMLDoc = Server.CreateObject("MSXML2.DOMDocument.3.0")
 objXMLDoc.async = false
 objXMLDoc.loadXML "<?xml version=""1.0"" encoding=""ISO-8859-1""?>" & _
  Application("UsuariosLogados")

 'Pesquisar no documento XML por um usuário com atributo id igual ao informado.
 Set objUsuario = objXMLDoc.selectSingleNode("//usuario[@id = " & Session.SessionId & "]")
 'Se encontrar, removê-lo
 If Not objUsuario Is Nothing Then objUsuario.parentNode.removeChild objUsuario

 Application("UsuariosLogados") = objXMLDoc.documentElement.xml
 Set objXMLDoc = Nothing

 Application.Unlock

End Sub

Parabéns, estamos quase lá! Note que adicionamos um pequeno trecho para verificar existe um usuário com o id informado no documento XML. A priori, sempre deveria existir, mas o seguro morreu de velho.

Maravilha, só precisamos agora atualizar os dados do mesmo, quando ele se logar no seu site. Adapte a mesma conforme sua necessidade.

<%

If Trim(Request.Form("txtUsuario")) <> "" And Trim(Request.Form("txtSenha")) <> "" Then

 'Abrir conexão com o banco de dados.
 'Pesquisar o registro na base de dados. Cuidado com as aspas simples nos campos postados!
 'Se encontrou então

  Application.Lock

  Dim objXMLDoc, objUsuario
  Set objXMLDoc = Server.CreateObject("MSXML2.DOMDocument.3.0")
  objXMLDoc.async = false
  objXMLDoc.loadXML "<?xml version=""1.0"" encoding=""ISO-8859-1""?>" & _
   Application("UsuariosLogados")

  'Pesquisar usuário
  Set objUsuario = objXMLDoc.selectSingleNode("//usuario[@id = " & Session.SessionId & "]")
  If Not objUsuario Is Nothing Then
   'Se encontrá-lo, alterar o nome pelo que
   ' (provavelmente) existe no banco de dados.
   objUsuario.setAttribute "nome", recordset("nome_usuario")
  End If

  Application("UsuariosLogados") = objXMLDoc.documentElement.xml
  Set objXMLDoc = Nothing

  Application.Unlock

 'Senão
  Response.Redirect "erro_login.asp"
 'Fim se

 '... restante da implementação ...'

End If

%>

Desta forma, podemos fazer com que os usuários marcados inicialmente como anônimos possam ser atualizados quando o detentor da sessão autenticar-se na aplicação.

Agora, basta listar os usuários. Acerte o design da forma que melhor lhe convier:

<%

Sub ListarUsuariosSite()

 Dim objXMLDoc, objUsuario, objUsuarios
 Set objXMLDoc = Server.CreateObject("MSXML2.DOMDocument.3.0")
 objXMLDoc.async = false
 objXMLDoc.loadXML "<?xml version=""1.0"" encoding=""ISO-8859-1""?>" & _
  Application("UsuariosLogados")

 'Coleção com todos os usuários na aplicação
 Set objUsuarios = objXMLDoc.selectNodes("//usuario")
 'Para cada usuário, ...
 For Each objUsuario In objUsuarios
  '... mostrar o nome do mesmo ...
  Response.Write "<b>" & objUsuario.getAttribute("nome") & "</b>"
  ' ... e seu respectivo id.
  Response.Write ", id " & objUsuario.getAttribute("id") & "<br>"
 Next
 'Mostrar a quantidade de usuários na aplicação
 Response.Write objUsuarios.length & " usuário(s) navegando no site, neste momento."
 Set objXMLDoc = Nothing

End Sub

%>

Resumindo: neste artigo implementamos uma lista dos usuários atualmente no site, vimos um exemplo de inclusão, alteração e exclusão de elementos e atributos em um documento XML via DOM e ainda, de quebra, ganhamos um contador de usuários online :)

Note que esta implementação é simples e flexível. Você pode colocar um campo com a data e hora de login, implementar uma rotina de comunicação como o "InterCOM" do ASP4Developers, ou mesmo possibilitar que um usuário convide outro para uma sessão de chat. Estamos limitados somente à nossa imaginação.

Espero que este artigo tenha sido útil para você.

Boa sorte e até a próxima.

Esta matéria foi postada originalmente no ASP4Developers por Rubens N. Farias (site), que na época era "pós-graduado em análise de sistemas orientados a objetos, MCP, MCSD, MCAD, MCSD.NET e consultor em TI, além de idealizador do projeto ASP4Developers. Desenvolve sistemas sob medida, focados na satisfação do usuário, com qualidade e custo realista.". Hoje, vai saber...

Tutorial: Validação de formato de horas usando expressões regulares

Há pouco tempo, tive um pequeno problema para resolver: verificar se horas digitadas pelos usuários, no formato HH:MM:SS, eram válidas. A princípio, não parece ser uma tarefa complexa, mas, dependendo da abordagem utilizada, podemos ter pouco ou muito trabalho.

Pare um momento e reflita: como fazer tal validação ? Usando JavaScript, poderíamos pensar em usar o método .split() para decompormos os elementos da string digitada e verificar se estas partes compõem um conjunto válido. Talvez o código acabasse, no final, parecido com o código abaixo:

<script>
function isHoraValidaSplit(strHora)
{
 // Concatenamos dois "dois pontos" para o caso da string
 // passada não contê-los, pois esperamos um array com,
 // no mínimo, 3 posições: horas, minutos e segundos.
 var arrElementos  = ( strHora + "::" ).split( ":" );
 var bolHorasOk    = consistirIntervalo( arrElementos[0], 0, 23 );
 var bolMinutosOk  = consistirIntervalo( arrElementos[1], 0, 59 );
 var bolSegundosOk = consistirIntervalo( arrElementos[2], 0, 59 );

 return( bolHorasOk && bolMinutosOk && bolSegundosOk );

 // Quando uma function aparece dentro de outra function,
 // tem sua visibilidade reduzida. Assim, consistirIntervalo()
 // só poderá ser acessada dentro de isHoraValidaSplit().
 function consistirIntervalo( strValor, intMenor, intMaior )
 {
  var bolRetorno = true;
  // Valor informado precisa ser numérico...
  if( isNaN( strValor ) || strValor == "" ){
   bolRetorno = false;
  }
  else
  {
   // ... e estar contido no intervalo
   var intValor = parseInt( strValor, 10 )
   if( intValor < intMenor || intValor > intMaior ){
    bolRetorno = false;
   }
  }
  return( bolRetorno );
 }
}
</script>

Para sabermos se o código acima funciona, utilizamos uma massa de dados de teste. Note que temos inconsistências em diversos pontos da hora, para podermos explorar cada ponto do algoritmo. Temos horas com apenas os minutos inválidos, apenas os segundos válidos, testamos os limites inferior e superior. Uma boa massa de testes pode ajudá-lo a identificar diversos problemas latentes do seu código, antes que o usuário final descubra esses erros para você :)

<script>
// Massa para testes da função isHoraValida()
var strMensagem = "Método Split:\n--------------------\n"
var arrTestes = new Array(
  "12:34:56", "65:43:21", "02:68:03", "21:43:65", "00:00:00", "23:59:59",
  "24:00:00", "teste123", "11:77:88", "55:66:11", "33:00:99", "99:99:99" )
for( var i=0; i < arrTestes.length; i++ ){
 strMensagem +=
  "\"" + arrTestes[i] + "\" = " +
  isHoraValidaSplit(arrTestes[i]) + "\n";

}
alert( strMensagem )
</script>

"Ok, a função funciona. Então, o que há de errado com ela ?"

Na verdade, não há nada de errado. Minha intenção é de apresentar outro forma de fazer a consistência de horas, usando expressões regulares, lembra ? Vamos começar analisado uma hora válida: "19:48:26". Mas o que torna "19:48:26" uma hora válida ?

Comecemos com simplicidades lógicas: uma hora válida possui dois números, um sinal de dois-pontos, mais dois números, outro sinal de dois-pontos e mais dois números. Apesar de um passo óbvio, já começamos a isolar um padrão, que é justamente do que trata as expressões regulares: a pesquisa de padrões em strings.

Podemos, então, começar a reescrever a função de validação, assim:

<script>
function isHoraValidaRegExp(strHora){
 var re = /^\d\d:\d\d:\d\d$/
 return re.test( strHora );
}
</script>

Como o leitor mais atento deve ter percebido, "\d" é a indicação de dígito numérico. A cada dois deles, temos o sinal de dois-pontos. O caracter "^" indica início da string a ser testada e o "$" indica seu término. Isso consiste a "máscara básica" de uma hora válida.

"Perae! Mas este código está chamando de 'válida' horas descaradamente inválidas!"

Calma, jovem Jedi. Acredite na Força.

Precisamos consistir agora o intervalo de horas, minutos e segundos. Como consistir segundos é a mesma coisa que consistir minutos, vamos continuar por aqui.

O que é um "minuto válido" ? São os minutos entre "00" e "59", inclusive. Então precisamos incrementar a expressão regular, pois não são quaisquer dois números válidos, tal como está codificado hoje:

<script>
function isHoraValidaRegExp(strHora){
 var re = /^\d\d:[0-5]\d:[0-5]\d$/
 return re.test( strHora );
}
</script>

É isso mesmo que você está pensando: os colchetes indicam um conjunto de valores possíveis, e o traço indica um ubtervalo, no nosso caso, os números compreendidos entre "0" e "5". O caracter seguinte permanece sendo o "\d", pois unidades de "0" a "9" são permitidas.

"Não olhe agora, mas ainda está consistindo errado!"

Sim, eu sei. Ainda precisamos consistir as horas. E, aproveitando o embalo, o que é uma "hora válida" ? São as horas compreendidas entre "00" e "23", inclusive. Assim, teremos que adaptar a linha de raciocínio que adotamos no passo anterior. Ficaria assim:

<script>
function isHoraValidaRegExp(strHora){
 var re = /^[01]\d:[0-5]\d:[0-5]\d$/
 return re.test( strHora );
}
</script>

Assim resolvemos o problema das horas compreendidas entre "00" e "19". Precisamos tratar a exceção. Como proceder ?

Pensando mais um pouco: as horas precisam estar contidas em "00" e "19" ou entre "20" e "23". Significa que há dois padrões que necessitamos avaliar. Note que eles são mutuamente exclusivos, ou seja, só pode ocorrer um de cada vez. O código ficaria assim:

<script>
function isHoraValidaRegExp(strHora){
 var re = /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d$/
 return re.test( strHora );
}
</script>

Cuidado! Note bem que alteramos o código que vinha antes do primeiro "dois-pontos". Mantivemos a expressão anterior, que validava horas até as 19 horas, acrescentamos um pipe ("|") que representa o "OU" e acrescentamos a condição que faltava "2, seguido de um número entre 0 e 3". Colocamos tudo isso dentro de uma indicação de padrão não-capturável, representado por "(?:)". Os detalhes desta indicação fico devendo para outro artigo.

Para podermos comparar ambas implementações, preparei um teste de performance, que segue abaixo:

<script>

// Método original
function isHoraValidaSplit(strHora)
{
 // Concatenamos dois "dois pontos" para o caso da string
 // passada não contê-los, pois esperamos um array com,
 // no mínimo, 3 posições: horas, minutos e segundos.
 var arrElementos  = ( strHora + "::" ).split( ":" );
 var bolHorasOk    = consistirIntervalo( arrElementos[0], 0, 23 );
 var bolMinutosOk  = consistirIntervalo( arrElementos[1], 0, 59 );
 var bolSegundosOk = consistirIntervalo( arrElementos[2], 0, 59 );
 return( bolHorasOk && bolMinutosOk && bolSegundosOk );

 // Quando uma function aparece dentro de outra function,
 // tem sua visibilidade reduzida. Assim, consistirIntervalo()
 // só poderá ser acessada dentro de isHoraValidaSplit().
 function consistirIntervalo( strValor, intMenor, intMaior )
 {
  var bolRetorno = true;
  // Valor informado precisa ser numérico...
  if( isNaN( strValor ) || strValor == "" ){
   bolRetorno = false;
  }
  else
  {
   // ... e estar contido no intervalo
   var intValor = parseInt( strValor, 10 )
   if( intValor < intMenor || intValor > intMaior ){
    bolRetorno = false;
   }
  }
  return( bolRetorno );
 }
}

// Método sugerido
function isHoraValidaRegExp(strHora){
 var re = /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d$/
 return re.test( strHora );
}

function testarSplit(intLoop){

 var arrTestes = new Array(
   "12:34:56", "65:43:21", "02:68:03", "21:43:65", "00:00:00", "23:59:59",
   "24:00:00", "teste123", "11:77:88", "55:66:11", "33:00:99", "99:99:99" )

 for( var n=0; n <= intLoop; n++ )
 {
  var strMensagem = "Método Split:\n--------------------\n"
  for( var i=0; i < arrTestes.length; i++ )
  {
   strMensagem +=
    "\"" + arrTestes[i] + "\" = " +
    isHoraValidaSplit(arrTestes[i]) + "\n";

  }
 }
 return strMensagem
}

function testarRegExp(intLoop){

 // Massa para testes da função isHoraValida()
 var arrTestes = new Array(
   "12:34:56", "65:43:21", "02:68:03", "21:43:65", "00:00:00", "23:59:59",
   "24:00:00", "teste123", "11:77:88", "55:66:11", "33:00:99", "99:99:99" )

 for( var n=0; n <= intLoop; n++ )
 {
  var strMensagem = "Método RegExp:\n--------------------\n"
  for( var i=0; i < arrTestes.length; i++ )
  {
   strMensagem +=
    "\"" + arrTestes[i] + "\" = " +
    isHoraValidaRegExp(arrTestes[i]) + "\n";

  }
 }
 return strMensagem
}
</script>
<script language="VBScript">

 Const intExecucoes = 5 'Tiramos a média de 5 execuções
 Const intLoop = 1000 'Cada execução avalia 12 horas, 1000 vezes.

 intAcumuladoSplit = 0
 strMensagemSplit  = ""
 For i = 1 to intExecucoes
  inicio = Timer
  strMensagemSplit  = testarSplit(intLoop)
  intAcumuladoSplit = intAcumuladoSplit + ( Timer - inicio )
 Next

 intAcumuladoRegExp = 0
 strMensagemRegExp  = ""
 For i = 1 to intExecucoes
  inicio = Timer
  strMensagemRegExp  = testarRegExp(intLoop)
  intAcumuladoRegExp = intAcumuladoRegExp + ( Timer - inicio )
 Next

 ' Computar o tempo médio dispendido na avaliação das 60.000 validações

 intMediaSplit  = intAcumuladoSplit  / intExecucoes
 intMediaRegExp = intAcumuladoRegExp / intExecucoes

 strMensagemSplit  = strMensagemSplit  & vbTab & vbLF & "=" & _
      formatNumber( intMediaSplit, 4 ) & " s"
 strMensagemRegExp = strMensagemRegExp & vbTab & vbLF & "=" & _
      formatNumber( intMediaRegExp,4 ) & " s"

 arrSplit  = split( strMensagemSplit , vbLF )
 arrRegExp = split( strMensagemRegExp, vbLF )
 strMensagem = ""
 For i = 0 To UBound( arrSplit )
  strMensagem = strMensagem & arrSplit(i) & vbTab & "|  " & arrRegExp(i) & vbCRLF
 Next

 MsgBox strMensagem & vbCRLF & vbTab & _
   " Diferença de " & FormatPercent( intMediaSplit / intMediaRegExp, 2 )

</script>

Pronto, pode rodar o teste e surpreenda-se (o teste completo levou quase 4 segundos num P3 650/512M RAM. Você verá que a implementação da validação com expressões regulares possui a mesma eficiência do algoritmo inicial, mas com 90% menos código e cerca de 307,5% mais rápido! Isso mesmo: trezentos e sete e meio por cento, ou um terço do tempo original. Se o salário mínimo aumentasse na mesma proporção, ia ter muita gente feliz, pois o mesmo passaria de R$ 240,00 para R$ 738,00. Um aumento pra lá de bem vindo.

Bom, fica a dica: expressões regulares, que num primeiro instante parecem complexas, podem resolver problemas de identificação de padrão com menos código e mais performance. Mas nunca esqueça de documentar bem suas expressões regulares. A vítima pode ser você.

Até a próxima!

Esta matéria foi postada originalmente no ASP4Developers por Rubens N. Farias (site), que na época era "pós-graduado em análise de sistemas orientados a objetos, MCP, MCSD, MCAD, MCSD.NET e consultor em TI, além de idealizador do projeto ASP4Developers. Desenvolve sistemas sob medida, focados na satisfação do usuário, com qualidade e custo realista.". Hoje, vai saber...

Verificador (Navegador/Origem de Acesso)

'Verifica navegador e origem de acesso
'Ex.: Call Verifica(TRUE, TRUE)
'Call Verifica(TRUE, FALSE)
'Call Verifica(FALSE, TRUE)
'Call Verifica(FALSE, FALSE)
'<HOST_ORIGEM> = www.asp4developers.com.br

Function Verifica(sNAV, sORIG)
 If sNAV then
  Dim IS_IE, IS_NN, USER_AGENT
  USER_AGENT = Request.ServerVariables("HTTP_USER_AGENT")

  IS_IE = InStr(USER_AGENT,"MSIE")
  IS_NN = InStr(USER_AGENT,"Nav")
  
  If NOT IS_IE then 
   Response.Status = "000 - Somente MSIE 5.x e 6.x"
   Response.Write(Response.Status())
   Response.End
  End If
 End If

 If sORIG then 
  Dim sOrigem
  sOrigem = Request.ServerVariables("HTTP_HOST")
  
  If sOrigem <> "<HOST_ORIGEM>" then
   Response.Status = "403 - Acesso Restrito"
   Response.Write(Response.Status())
   Response.End
  End If
 End If
End Function

Esta matéria foi postada originalmente no ASP4Developers por César M. Conceição (site), que na época era "Analista / Programador Pleno, mais de 4 anos de experiência no desenvolvimento de sistemas online.(HTML/XHTML/ASP/JAVASCRIPT/DHTML/MS SQL/FIREBIRD/INTERBASE/ACCESS)". Hoje, vai saber...

Integrando WORD e XML usando XMLHTTP

Sou professor na Universidade de Passo Fundo e, para evitar a “cola”, elaboro diversas provas, cada uma com as questões em uma ordem diferente.

Já a algum tempo eu queria automatizar o processo de geração das provas e como estava curioso sobre a integração entre WORD e XML desenvolvi esta pequena aplicação, simples mas muito didática.

A aplicação usa o componente XMLHTTP para integrar os dados, o XML como banco de dados, o XSLT para formatar os dados, ASP no processamento da base de dados e VBA como linguagem de macro que insere os dados no documento WORD.

Na verdade nem era necessário o uso de toda esta parafernália, mas resolvi juntar todas as tecnologias que estou estudando numa única aplicação.

 

Arquivos:

provas.xml – bd com as questões.

provas.xsl – arquivo com a formatação dos dados. Na verdade serve apenas para ordenar as questões usando o ID como chave.

xmlhttp.asp – script que responde às solicitações da macro do Word

provas.dot – arquivo de modelo do WORD com uma macro embutida que é acionada na criação de um novo documento.

 

Estude os fontes abaixo e bom trabalho.

Para baixar os arquivos acesse -> http://www.gdez.com.br/barbiero/provas.zip

 

provas.xml

Arquivo contendo as questões que serão reordenadas e inseridas no documento Word.

 

<?xml:stylesheet type="text/xsl"  ?>

<provas>

   <prova id="">

      <questao id="1">Diferencie as cebolas dos abacates.</questao>

      <questao id="2">defina o sabor do xuxu.</questao>

      <questao id="3">Diferencie redes para lambari de redes para tilápia</questao>

      <questao id="4">Para que serve o comando sbórnia?</questao>

      <questao id="5">Para que serve o comando tchê?</questao>

      <questao id="6">Para que serve o serviço de quarto?</questao>

      <questao id="7">O que é um calo?</questao>

      <questao id="8">Defina graxaim?</questao>

      <questao id="9">Descreva as características de Passo Fundo</questao>

      <questao id="10">Em quais camadas ficam os protocolos tartaruga e jacaré?</questao>

   </prova>

</provas>

 

provas.xsl

<?xml version="1.0"?>

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

<xsl:output method="xml"/>

 

<xsl:template match="/provas">

<provas>

            <prova>

                        <xsl:apply-templates select="/provas/prova"/>

            </prova>

</provas>

</xsl:template>  

 

<xsl:template match="/provas/prova">

   <xsl:for-each select="questao" >

     <xsl:sort select="@id"/>

             <questao>       

     <xsl:value-of select="."/>

     </questao>

   </xsl:for-each>

</xsl:template>  

 

</xsl:stylesheet>

 

 

xmlhttp.asp – este arquivo deve ser colocado em uma pasta com permissão de execução de scripts no IIS.

<%@ Language=VBScript %>

<%

            Response.CharSet="iso-8859-1"   'Define o conjunto de caracteres do português

 

            set docXML = Server.CreateObject("Microsoft.XMLDOM")

    docXML.async=false

    docXML.load(server.MapPath("provas.xml"))

   

            set docXSL = Server.CreateObject("Microsoft.XMLDOM")

    docXSL.async=false

    docXSL.load(server.MapPath("provas.xsl"))

 

    set nodelistQuestoes = docXML.documentElement.Childnodes(0).childnodes

    '

    '       Gera números aleatórios para alterar a ordem das questões

    '

    randomize            'inicializa o gerador de números aleatórios

    for i = 0 to nodelistQuestoes.length - 1

                nodelistQuestoes(i).setAttribute "id", int(rnd * 1000)

            next     

            '

            '            Aplica a formatação com o XSLT

            '

            set docTransformadoXML = Server.CreateObject("Microsoft.XMLDOM")

            docTransformadoXML.async = false

            docTransformadoXML.loadxml(docXML.transformNode(docXSL))

            '

            '            Envia as informações no formato exigido pelo Word, uma questão em cada linha.   

    '

    set nodelistQuestoes = docTransformadoXML.documentElement.Childnodes(0).childnodes

    for i = 0 to nodelistQuestoes.length - 1

                response.Write I + 1 & ") " & nodelistQuestoes(i).text & chr(13)

            next     

            '

            '            Destrói os objetos criados

            '

            set nodelistQuestoes = nothing

            set docXML = nothing

            set docXSL = nothing

            set docTransformadoXML = nothing

            %>

 

Macro do Word 2000 – Para integrar o WORD com o XML eu defini esta macro no evento “New” e salvei-a como modelo provas.dot. O usuário deve utilizar a opção “Arquivo” + “Novo” para poder escolher o modelo do documento.

Inicialmente a macro está apontando para um site na Internet: http://www.gdez.com.br mas você pode colocar os três arquivos acima em qualquer site e alterar o link.

 

Para inserir a macro entre no Word pressione ALT+F11, escolha o object “thisDocument”, cole a macro abaixo e salve o documento como um modelo do WORD:

 

Private Sub Document_New()

    Dim xmlhttp

    xmlhttp = Null

    Set xmlhttp = CreateObject("microsoft.XMLHTTP")

 

    ActiveDocument.Content = ""

    For i = 1 To 10

        Call xmlhttp.Open("POST", "http://www.gdez.com.br/barbiero/xmlhttp.asp", False)

        xmlhttp.Send

       

        ActiveDocument.Content = ActiveDocument.Content & xmlhttp.responseText

        ActiveDocument.Sections.Add

       

       

    Next

 

End Sub

 

 

 

Esta matéria foi postada originalmente no ASP4Developers por Marco Aurélio Barbiero (site), que na época era "Analista de Sistemas, trabalha na Receita Federal e desenvolve aplicativos em VB, ASP, Javascript, Notes e XML.
Colaborou algumas vezes com sites como o www.actionjackson.com". Hoje, vai saber...

Pega extensão do arquivo

Essa função pode ser muito útil para renomear um arquivo na hora do upload.

<%
'----------------------------------
' Função: Pega Extensão Do Arquivo
' Autor: Régis Soares
' E-mail: regis_soares@hotmail.com
' Data De Criação: 05/06/2003
' Última Atualização: 06/06/2003
'----------------------------------
Function Extensao(arquivo)
 x = InStrRev(arquivo, ".")
 If x = 0 Then
  Extensao = "Arquivo inválido"
 Else
  y = Mid(arquivo, x)
  If Len(y) < 3 Then
   Extensao = "Arquivo inválido"
  Else
   Extensao = y
  End If
 End If
End Function
%>
<%= Extensao("figura.jpg")%>

Esta matéria foi postada originalmente no ASP4Developers por Régis da Silva Soares, que na época era "Programador ASP e PHP". Hoje, vai saber...