- ASP, che cosa è? A cosa serve?
Breve introduzione al linguaggio ASP.
- I primi passi
Cominciamo dall’inizio con qualche semplice esempio.
- Scaviamo un pò le fondamenta
I primi oggetti, metodi e proprietà.
- Dai, facciamo qualcosa un pò più divertente ;o)
Il primo esempio concreto.
- Il Request oggetto continua
Le collezioni Form e Querystring.
- L’architettura dell’ ASP object model
La struttura del file global.asa.
- Vbscript e le lingue che usiamo per parlare con il browser
Primi concetti del linguaggio Visual Basic Script.
- Usare Funzioni & Procedure
Primi passi verso la programmazione
- E adesso la vera ragione per cui adoperiamo tecnologie come ASP
Cominciamo a capire il motivo per cui utilizzare ASP
- Database access with ADO
La prima connessione ad un database
- Facciamo la conoscenza con il Connection e il Recorset
L’oggetto Recordset: cosa è e come gestirlo
- Conoscenza col Connection e Recordset non basta
Ulteriori informazioni sul Recordset
- Non ho ancora finito. Lezione pratica.
Inserire informazioni in un database tramite form.
- Come presentare l’Output
Suggerimenti su come impostare l’output delle informazioni.
- Come lavorare dal letto
Automatizzare al massimo le nostre applicazioni.
- Il pannello di controllo
Creare un pannello di controllo per l’applicazione
- Come mantenere i nostri dati
Dare la possibilità di modificare le informazioni da pannello.
- Le News non bastano
Personalizzare con email il tutto.
- E poi possiamo partire per l’Australia
Gestire i feedback dell’applicazione.
- Vogliamo degli altri in Ufficio?
Gestire più utenti nel pannello di controllo.
- Allora diamogli le chiavi e facciamoli lavorare
Dare l’accesso agli altri utenti.
- Conclusione
Conclusioni e suggerimenti.
ASP, che cosa è? A cosa serve?
Lo sai cosa è un protocollo no?
Beh, nel caso che il termine sia nuovo, un protocollo è un gruppo di regole che ci permettono di comunicare l’uno con l’altro. Per esempio, l’italiano è un protocollo, lo stringere la mano quando ci si incontra, adoperare il coltello e la forchetta, fermarsi quando il semaforo è rosso (non un buon esempio per gli italiani) sono tutti protocolli. Quando due eskimesi si incontrano si strofinano il naso, i russi si baciano 3 volte, gli inglesi una, gli italiani due, ecc. E’ così che ci capiamo.
L’unica cosa importante è che tutti coloro che sono coinvolti nella comunicazione condividano le stesse regole.
L’HTTP (HyperText Transfer Protocol), la lingua franca dell’internet, è un protocollo. Quando due computer conoscono le regole dell’HTTP possono comunicare tranquillamente.
La ragione per cui è così popolare ed ha ricevuto così tanto successo, più che altro, è perché è un protocollo molto semplice. Ogni computer riesce a parlare HTTP!
Sfortunatamente questa sua grande forza, come sempre nella vita, è anche la sua più grande debolezza.
Il HTTP protocollo funziona così:
tu mi chiedi una pagina web e io te la mando. Punto, basta. Non so chi sei, no so dove stai e non me ne importa niente. Basta che mi dai un Internet Protocol (IP) verso cui spedire il pacchetto e io lo riesco a far arrivare a destinazione.
Sfortunatamente un protocollo così semplice non ci permette una grande sofisticazione nel processo comunicativo. È un po’ come vivere senza la memoria. Un po’ come un pesce rosso che gira dentro al suo vaso: “Hello! Guarda qui! Che bel sasso!”
È in questo contesto che vengono utilizzate tecnologie come Microsoft Internet Information Server (IIS), Macromedia ColdFusion Server, Apache Server ecc.
Impiegando un po’ di risorse sul server ci permettono di comunicare più intelligentemente. In un senso, introducono la memoria nei processi di comunicazione HTTP.
IIS (il server) per esempio, quando riceve una richiesta da te (il cliente) per un pagina mette da parte un po’ di spazio nella sua memoria e ci scrive il tuo nome, indirizzo, la pagina e un mucchio di altre cose (che vedrai nella prossime lezioni) riguardo a chi sei e cosa hai chiesto. Quando richiedi un’altra risorsa il server controlla la tua area di memoria riconoscendoti subito.
Come programmatore, usando Active Server Pages (ASP) sul server (IIS), io posso guardare in quest’area di memoria e, per esempio, trovare il tuo nome e stamparlo in cima alla pagina prima di mandartela.
ASP è la tecnologia che è a nostra disposizione per manipolare le informazioni che IIS raccoglie e mantiene.
In conclusione possiamo dire che tecnologie come IIS e ASP espandono il protocollo HTTP con l’introduzione della continuità e ci permettono di maneggiare la conversazione fra il server e il cliente in una maniere più ricca.
Prima che tu possa cominciare a sperimentare le tue applicazioni con questa tecnologia hai bisogno di un server e della DLL di ASP. Ci sono diversi siti che spiegano come si fa ad installare l’ambiente ASP.
Questo sito spiega come si fa ad installare il Personal Web Server per Window98 ed è uno dei migliori
http://www.soft-land.org/faq/asppws.html
A questo punto, penso sia ragionevole assumere che tu sei gia un discreto programmatore in HTML (la lingua di HTTP), altrimenti non saresti qui a volere imparare di più ;o)
Allora, cominciamo subito.
Il seguente file, buongiorno.htm, scrive “Buongiorno a tutti” sul tuo schermo quando lo chiami dal tuo browser.
|
<html><head><title>Buongiorno</title></head> |
Se volessimo adoperare ASP per fare la stessa cosa, cosa dobbiamo fare? Beh, guarda qui:
|
<html><head><title>Buongiorno</title></head> |
Salva il file come buongiorno.asp e richiamalo dal browser. Come vedi i due file ottengono lo stesso risultato.
Analizziamo la sintassi di ASP:
<% e %> sono I delimitatori che ASP riconosce come propri. Tutto quello che è dentro a questi delimitatori è codice ASP.
Response è l’oggetto di ASP che risponde al client, mentre write (scrivi) è una delle cose che l’oggetto sa fare.
Parleremo di oggetti in più approfonditamente nella prossima lezione ;o)
Adesso modifichiamo questo programmino in modo da farne qualcosa di più interessante
|
<html><head><title>Buongiorno a tutti</title></head> |
Una volta che riesci a far funzionare lo script sul tuo browser, dai un’occhiata al codice sorgente ;o) (Visualizza -> HTML)
Questo è il codice che vedrai visualizzato:
|
<html><head><title> Buongiorno a tutti </title></head> |
Allora, che cosa fa esattamente questo ASP?
ASP è un interprete. Quando chiediamo il file buongiorno.asp all’IIS, questo riconosce l’estensione .asp e invia il file al motore di ASP (asp.dll).
Il motore legge dal primo carattere all’ultimo costruendo una stringa normale in HTML e, quando trova uno dei suoi delimitatori (<%) dice “Oh, questo è il mio!” e esegue l’azione appropriata. Nel nostro caso ha trovato un semplice loop. Lo esegue e continua a costruire la stringa in HTML. Quando trova il delimitatore che chiude (%>) attacca la sua stringa a quella precedente e così continua fino alla fine del file. Quando ha finito, il motore manda la stringa in HTML a IIS che la invia al browser dell’utente (un po’ semplicistico ma vero ;o).
Ne segue che ASP e HTML possono essere mescolati in ogni maniera. Finché stiamo attenti a mantenere i delimitatore, funziona sempre.
Per esempio buongiorno.asp potrebbe essere scritto così:
|
<html><head><title>Buongiorno a tutti </title></head> <% <font size=+<%= cresci %>Buongiorno a tutti</font><br> <% </body> |
Come vedi, qui abbiamo inserito la variabile “cresci” nel HTML
L’unica cosa da notare è che per ottenere il suo valore, la sintassi è <%=
Ah! un’altra cosa. I commenti in ASP usano ‘, non dimenticarti, sono molto importanti ;o)
Abbiamo detto prima che il Response è un oggetto. Ma cosa intendiamo per oggetto?
In termini tecnici un oggetto è “un coso” e il modello di questo “coso” e il gruppo di regole che ne determina le funzionalità.
Non è proprio così sciocco come sembra, vediamo un semplice esempio in linguaggio umano.
Se dovessimo descrivere una bicicletta a una persona che non ne ha mai vista una, quale credi sia la maniera migliore per descriverla? Potremmo cominciare a descrivere le cose che la bicicletta deve essere in grado di fare oppure i metodi della bicicletta. Per esempio:
Metodi: pedalare, suonare il campanello, frenare, ecc.
Se un oggetto deve diventare una bicicletta, è indispensabile che riesca a fare queste cose. Questi sono i “metodi” comuni a tutte le biciclette.
Ma non basta, ci sono anche un mucchio di biciclette diverse in giro e per descriverle tutte bisogna che definiamo anche qualche proprietà:
Proprietà: il colore, l’altezza del telaio, la misura delle ruote, ecc.
Allora. Una volta che abbiamo definito tutti i Metodi e le Proprietà dell’oggetto, il nostro nuovo amico dovrebbe essere in grado di rappresentarsi una bicicletta abbastanza reale.
Per aiutarlo ancora un po’ di più c’è un’altra cosa che sarebbe molto utile definire: gli eventi o le azioni che possiamo fare con l’oggetto, per esempio:
Eventi: quando salgo, quando scendo, quando casco, ecc.
In una tecnologia come DHTML un esempio di un oggetto è una window. Metodi che possiamo adoperare sono aprire o chiudere. Proprietà di questo oggetto sono Top, Bottom, Left, Right, ecc.
Un evento è il OnClick quando il mouse ci manda un segnale.
Lo stesso vale per l’oggetto Response che abbiamo adoperato prima. Anche questo ha Metodi e Proprietà. Adoperandoli come vogliamo siamo in grado di costruire molti Response, oggetti che, nei loro limiti, possono fare molte cose diverse.
L’oggetto Response ha i seguenti “Metodi”:
|
AddHeader, AppendToLog, BinaryWrite, Clear, End, Flush, Redirect, Write |
E queste “Proprietà”:
|
Buffer, CacheControl, Charset, ContentType, Expires, ExpiresAbsolute, IsClientConnected, PICS, Status |
E tanto per complicare le cose il Response ha anche una “Collezione”:
|
Cookies |
La sintassi come abbiamo gia visto è semplice:
|
Response.Clear |
Ma basta per ora.
Nella prossima lezione vedremo come questi oggetti si mettono insieme per costruire delle applicazioni utili e efficienti.
Dai, facciamo qualcosa un pò più divertente ;o)
Al giorno d’oggi lavorare con queste tecnologie e un po’ come giocare con il Lego.
Metto 2 mattoni rossi da 2 + 2 mattoni verdi da 2, ci metto sopra un bel mattoncino blue da 6 e: “hey presto, ho fatto un ponte!”.
Vediamo cosa si può fare con i pezzi di ASP, l’oggetto Response + l’oggetto Request.
Usando il metodo Write del Response siamo in grado di scrivere sullo schermo. Usando il Request siamo in grado di leggere dallo schermo.
Per riferimento vi mostro il modello dell’oggetto Request:
Proprieta : TotalBytes
Collections : ClientCertificate, Cookies, Form, QueryString, ServerVariables
Metodi : BinaryRead
Come col Lego, con questi due oggetti siamo in grado di costruire un ponte fra una pagina e l’altra.
Cominciamo col costruire una pagina che raccoglie l’input da una form e restituisce una risposta appropriata.
Chiamiamola il file chiedimi.asp
|
<html><head><title>Chiedimi</title></head> |
Vedi subito cosa succede qui, no? Naturalmente avremmo potuto scrivere questo senza ASP, direttamente in HTML ma volevo solo farti vedere cosa si può fare con il Response.
Adesso costruiamo una pagina per la risposta chiamiamola rispondimi.asp.
Lo so che il Request lo abbiamo appena guardato ma, sono sicuro che capirai, dopo lo guarderemo più in dettaglio.
|
<html><head><title>Rispondimi</title></head> Semplice no? <html><head><title>Rispondimi</title></head> |
Questo modo ha il vantaggio di accedere il nome del controllo insieme con il valore. Per esempio se sono io che rispondo, il programma restituisce:
Nome = Giorgio
Citta = Surfers Paradise
Il ponte è fatto no?
È facile passare valori da un pagina all’altra con ASP?
Non è comunque l’unico modo per passare variabili da una pagina a un’altra. Dopo tutto non possiamo mettere form dappertutto e non sempre le variabili che vogliamo passare hanno a che fare con i nostri utenti. Spesso abbiamo bisogno di mandare delle flags per avvertirci su che corso prendere in dipendenza da un valore o un altro.
Per esempio se volessimo combinare i due file chiedimi.asp e rispondimi.asp in uno solo, potremmo farlo? E se la risposta è sì, come facciamo?
Segue domanda_rispondi.asp
|
<html><head><title>Domanda e Rispondi</title></head> <% </body> |
Non c’è una grande differenza nel modo con cui abbiamo operato, ma guarda alla linea:
|
<form action=’domanda_rispondi.asp?clickato=true’ method=’post’> |
Qui prima di tutto rimandiamo il file in sé stesso passandogli un valore clickato=true. In questo caso il valore di clickato è contenuto nella collezione QueryString dell’oggetto Request.
Quindi lo possiamo recuperare semplicemente con:
|
clickato = Request.Querystring(“clickato”) |
In questa maniera il valore è passato insieme all’URL (infatti lo vedi nell’URL nel browser):
http://localhost/domanda_rispondi.asp?clickato=true
Le collezioni Form e QueryString sono certamente le due più utili dell’oggetto Request e sono quelle che adopererai di più. Ma c’è anche un’altra collezione molto utile che si può adoperare con un po’ di attenzione.
Prova questo:
|
For each nome in Request.ServerVariables |
I valori di tutte queste variabili sono contenute nell’header di un a richiesta HTTP e sono tutti accessibili (però stai attento poiché sono dipendenti dal browser dell’utente quindi non sono sempre tutti accessibili) .
Per esempio qui potremmo:
|
strFirma = Request.ServerVariables(“HTTP_USE_AGENT”) |
Poi analizzando questa stringa potremmo trovare che tipo di browser ha fatto una richiesta alle nostre pagine. Così se è Netscape, restituiamo una pagina per Netscape se no restituiamo pagine disegnate per Internet Explorer.
|
<% |
In caso che tu non lo sappia, la funzione Instr cerca un match nella stringa di input:
|
Instr(stringa1,stringa2) |
Come dire “Dimmi se la stringa2 è dentro a stringa1″
Questa collezione è molto utile per esempio quando cominciamo a rendere automatico il passaggio da una pagina all’altra. Questo è un pochettino più complicato al momento, ma funziona ottimamente per trovare quale è la pagina che effettua una chiamata. Di conseguenza potremmo automatizzare il titolo o il colore o qualunque cosa vogliamo.
|
strDaDoveVengo = Request.Servervariables(“HTTP_REFERER”) |
Ricordati che queste variabili dipendono dalla configurazione della tua macchina per cui non sempre sono disponibili.
Ecco una semplice applicazione che adopera le variabili per tracciare chi è venuto sul nostro sito, che pagina ha visto e che lingua parla. Il tutto lo scriviamo in un file ospite.txt. Studiala e se è un po’ troppo complicata lascia perdere per adesso. Fra un paio di lezioni la capirai benissimo.
Prima di tutto devi creare un file vuoto di nome ospite.txt, fallo con Notepad (Blocco Note).
|
<% ‘raccogli le informazioni che vuoi scrivere ‘crea un FileSystem oggetto ‘trova il path del file ‘costruisci la stringa da scrivere ‘aprila per scrivere ’scrivi ‘chiudi |
L’architettura dell’ ASP object model
Prima che continuamo a saltare troppo di palo in frasca, facciamo un passo indietro e guardiamo a come un’applicazione scritta con ASP funziona nella sua completezza.
Quando accediamo per la prima volta ad un file asp, IIS guarda nella directory root per vedere se trova un file chiamata global.asa (Active Server Application).
È questo file che ci permette di controllare due degli oggetti più importanti di ASP: l’Application e il Session.
Se ricordi, al principio di questo tutorial abbiamo parlato del fatto che il protocollo HTTP è senza memoria. L’oggetto Request ci ha aiutato un po’ a mantenere la memoria ma solo da una pagina all’altra. Si potrebbe dire che l’oggetto Request è un po’ la memoria corta. Beh, l’Application e il Session sono la memoria lunga. Per essere ancora più precisi, nell’universo di IIS, il Session è la memoria lunga che rimane in vita finchè rimane in vita la tua connessione, mentre l’Application è il codice genetico che rimane in vita per tutti, finchè l’universo di IIS continua.
Come vedi, in questa metafora tu hai un potere enorme e in realtà sei tu che decidi come questo universo funziona o non funziona.
Il Global.asa ha 4 events principali. Eccone uno standard
|
<script LANGUAGE=”VBScript” RUNAT=”Server”> Sub Application_OnStart Sub Application_OnEnd Sub Session_OnStart Sub Session_OnEnd </script> |
Per esempio se definiamo una variabile di scopo Application così:
|
<% |
In qualunque delle mie pagine, posso scrivere
|
<% |
e queste variabili rimangono valide finché noi stessi uccidiamo l’applicazione o fermiamo IIS.
Un altro esempio. Nel global.asa durante Session OnStart event, definiamo:
|
<% |
Potremmo adoperarla in tutte le pagine nel nostro sito per controllare se il cliente ha l’autorizzazione per vedere la pagina. Come? Così:
|
<% |
Naturalmente questo presume che tu abbia un meccanismo per permettere che il cliente effettui il login nel tuo sito e che il tuo codice cambi lo stato della variabile (Set Session (“login”) = True) quando il login è avvenuto correttamente.
Nell’oggetto Session la durata delle variabili è valida fino a quando non chiudi il tuo browser, oppure, se non hai attività, IIS chiude di solito la sessione dopo 30 minuti.
Un esempio pratico che puoi applicare subito.
Diciamo che tu hai un sito dove è importante che i tuoi clienti entrino da una pagina specifica che vuoi tu e non da dove loro hanno messo un bookmark:
Facile, lo facciamo con il Response:
|
Sub Session_OnStart |
Appena la Session comincia, cioè quando qualcuno entra nel sito attraverso il suo bookmark, IIS spara l’azione Session_OnStart che ti ridirige esattamente dove vuoi tu.
C’è chi dice che l’internet mette sempre più potere nelle mani dei clienti ma non certo con noi programmatori. Abbiamo sempre tutto sotto controllo ;o)
Vbscript e le lingue che usiamo per parlare con il browser
Le pagine ASP sono una combinazione di script in ActiveX e di tag HTML. IIS usa questi scripts, per darci la funzionalità nelle nostre applicazioni.
IIS ha due motori interni per interpretare questi scripts:
· VBScript che è un subset di Visual Basic for Application (VBA)
· Jscript un versione di JavaScript da Microsoft
Javascript, un subset del linguaggio C, è un prodotto di Netscape e di Sun Microsystem ed è interpretato dal suo motore.
Quali di queste lingue adoperare è una tua scelta e dipende naturalmente dalla familiarità che hai con questi linguaggi. In pratica però adoperiamo un po’ di una e un po’ dell’altra.
Per esempio, qui adoperiamo Vbscript per scrivere server side script e adoperiamo Javascript per scrivere client side script. La ragione è che Netscape non capisce VBScript e quindi tutti i nostri utenti Netscape non vedrebbero quando siamo svegli.
Siccome questo è un tutorial su ASP, non VBScript, cerchiamo di non perdere troppo tempo. Ci sono ottimi manuali per VBScript anche online. Per citarne uno, all’indirizzo riportato qui sotto trovi l’help di Microsoft che puoi scaricare e installare liberamente sul tuo computer.
http://msdn.microsoft.com/scripting
32-bit VBScript Documentation Download (VBSDOC.exe 473KB) for Windows 95 and Windows NT.
Guardiamo solo velocemente quello di cui abbiamo bisogno. Come tutte le lingue VBScript impiega delle strutture di controllo per creare la logica nelle nostre applicazioni. Ci sono due tipi principali di strutture:
· Decisioni, che definiscono su che ramo logico andare in base al risultato di un test
· Loops, che processano ciclicamente fino a che una specifica condizione non è raggiunta.
Decisioni:
|
<% |
Questa è la decisione più comune di tutte e c’è poco da spiegare.
“Se passi la condizione allora facciamo qualcosa”
La struttura che segue è un allargamento della precedente
“Se passi la condizione allora facciamo qualcosa altrimenti facciamone qualche altra”"
|
<% |
La prossima struttura invece è adoperata per scegliere fra decisioni multiple:
|
<% |
Questa struttura è molto efficiente e in più produce del codice che si legge bene.
Loop
Come abbiamo detto queste sono strutture cicliche che continuano a riprodursi fino a che una condizione predeterminante è raggiunta.
Questo lo abbiamo già visto nella prima lezione
|
<% |
Logico no? Comunque, usando il For loop dobbiamo sapere quanti gradini ci sono prima di cominciare altrimenti rimaniamo a metà della scala!
La seguente struttura ci permette invece di arrivare in cima alla scala in tutte le maniere
|
<% |
Quando arriviamo in cima e non ci sono più scalini il Loop esce.
Ti ricordi ospite.asp che abbiamo scritto nella lezione 5?
Allora prova questa struttura:
|
<% Set fs = Server.CreateObject(“Scripting.FileSystemObject”) ‘trova il path del file |
se ti trovi nei guai qui, usa il Response per vedere cosa succede.
Per esempio se il tuo programma non trova il file, utilizza un’altra dichiarazione:
|
<% Response.Write “il filepath del mio file è =: ” & filepath & “<br>” %> |
così vedi dove sei e lo puoi riparare.
|
<% ‘leggi finché End of File è diverso da true ‘esci e chiudi la porta |
Come vedi questo programma legge tutto il tuo file ospite.txt. Così se domani sei in vacanza in Sardegna e vuoi vedere chi è venuto sul tuo server, facile: apri looping.asp e il gioco è fatto.
La creazione di Funzioni e Procedure nel nostro programma è una tecnica programmatica utile per diverse ragioni. Prima di tutto rende il programma più leggibile partizionando dei blocchi di logica che compiono dei lavori definitivi e in più, poiché spesso la stessa cosa deve essere fatta in molti posti diversi, ci permette di riutilizzare del codice.
Per esempio, ti ricordi il programma che abbiamo scritto nella lezione 4, quando abbiamo combinato in un unico file l’input di una form col suo output nella presentazione?
|
<html><head><title>Chiedi e Rispondi</title></head> <% </body> |
Questo programma, essendo così corto, è certamente leggibile; ma se le righe invece di essere poche fossero diverse centinaia? Con una form molto lunga e con una presentazione complessa basata su un numero di parametri passati da pagine precedenti? Tipo una situazione di e-commerce dove raccogliamo dati di carte di credito?
Guarda un po’ com’è bello usando procedure:
|
<% Sub Main() clickato = Request.QueryString(“clickato”) If NOT clickato then MostraLaForma() Else LeggiLaForma(form) DaiLaRisposta() End if FaiLaCoda() End Sub Sub FaiLaTesta() Sub MostraLaForma() End Sub Sub LeggiLaForma(form) End Sub Sub DaiLaRisposta() Sub FaiLaCoda() |
Certo che a vederlo in questo contesto sembra un po’ strafatto ma immagina che la prossima volta che dobbiamo costruire un file simile ne abbiamo già una metà già scritta. Comunque svilupperemo l’argomento durante il corso di queste lezioni e vedrai che questo metodo è molto utile. Nel programma precedente non ci sono Funzioni ma solo Procedure. Così mettiamone una e vediamo qual è la differenza.
|
<% cheora = Hour(Now) Select case cheora ParteDelGiorno = cheora End Function |
Come vedi questa Funzione è certamente riutilizzabile anche se un po’ semplice (ma bisogna pur cominciare da qualche parte o no? ;o).
Aggiungi queste due linee nel codice fra:
|
<% saluti = ParteDelGiorno() MostraLaForma() |
Come vedi, poiché la funzione ci restituisce un valore, bisogna dargli una variabile per raccogliere l’informazione. Oppure volendo avremmo potuto scriverla direttamene con:
|
<% Response.write ParteDelGiorno() %> |
Allora, in sostanza, abbiamo messo un po’ di ordine nel nostro programma.
Anche se ti sembra un po’ troppa strutturato per quello che fa, so di sicuro che mi ringrazierai se per caso ritorni a questo programma fra qualche mese ;o)
Torna a indice
E adesso la vera ragione per cui adoperiamo tecnologie come ASP
Fino ad ora tutta l’enfasi nello sviluppo dei siti web è stata “messa in vetrina”. Abbiamo fatto delle vetrine stupende che sono costate una fortuna, ma dentro al negozio? Molto poco. Spesso un cliente ha l’impressione che non ci sia nessunno e spesso il cliente ha ragione! Come facciamo a rimediare?
In questo caso tecnologie come ASP ci aiutano proprio. Per esempio tutti sanno che un sito deve avere un mezzo con cui il cliente può comunicare con noi. La maniera più semplice è un “mailto:” collegato al tuo email.
Sfortunatamente questo metodo fallisce molto spesso poiché presuppone che il programma di posta elettronica dell’utente sia configurato correttamente e spesso non lo è.
Il secondo metodo è una form mantenuta dall’ISP presso cui risiede il nostro sito. Gli Script dietro a questa form di solito mandano un e-mail al cliente. Il metodo migliore però è costruire la tua form da solo e controllare le informazioni che vuoi sapere dai tuoi clienti e la risposta che gli vuoi dare.
A questo punto, cominciamo a costruire un’applicazione che ci servirà quando avremo finito le nostre lezioni: costruiamo una Form che ci permette di raccogliere informazioni dai nostri clienti, restituendo loro un messaggio di ringraziamento e mandando a noi una email. Il primo pezzo lo sai già fare da solo.
Cominciamo a fare un file chiamato feedback.asp e vediamo dove ci porta.
|
<HTML> <BODY> </BODY> |
Feedback.asp ha 2 text boxes, 1 textarea per i commenti e un checkbox nel caso i nostri clienti vogliano ricevere una newsletter regolarmente o pubblicità o qualcosa che ce li leghi a noi un po’. In inglese si chiama stickyness (come il miele, appiccicoso)
La form chiama in azione manda_feedback.asp con il metodo Post. Questo file raccoglie l’input del cliente e lo invia a noi per email. In più presenta al cliente una pagina ringraziando per i suoi commenti.
Volendo, se sei avventuroso, potresti adoperare lo stesso metodo di prima e costruire l’applicazione nello stesso file. Come vuoi tu, ormai sei già un esperto ;o)
Allora costruiamo questa manda_feedback.asp.
Per mandare una email dobbiamo adoperare il NewMail oggetto dalla CDONTS library di Micorsoft.
Il modo in cui adoperiamo questo oggetto è simile agli altri e molto semplice.
|
<% %> call Main() Sub Main() Sub no_email() Sub manda_posta(form) ‘facciamo la vendemmia dell’input mandamiquesto = nome & “VBcrlf” & email & “Vbcrlf” & commenti ‘e adesso puliamo prima di andarcene Sub ecco_fatto(nome) %> </body> |
Ed ecco qui che abbiamo la nostra form funzionante. L’oggetto NewMail è abbastanza semplice no?
Se volessimo delle copie carbone il NewMail ci permetterebbe di specificare anche:
|
<% |
O potremmo formattare la email in HTML con la proprietà:
|
<% ObjMail.BodyFormat = CdoBodyFormatHTML %> |
Ma adopereremo questo oggetto di nuovo nelle prossime lezioni e impareremo di più.
Se il nostro sito diventa popolare dovremmo ricevere un mucchio di email e presto ci accorgeremo che programmi come Outlook o Eudora non sono adeguati a conservare questo dati. Ma grazie a Dio, ci sono le banche dati. In un sito moderno, le banche dati sono come il cuore in un essere umano: indispensabili. Costruiamone una subito.
Io ne ho fatta una in Microsoft Access. L’ho chiamata CRM.mdb poiché vogliamo costruire un sistema di Customer Relationship Management (CRM, gestore dei rapporti con i clienti) che ci permetta di comunicare con i nostri clienti in una maniera più efficiente. Dentro crm.mdb ho messo una tabella chiamata:
|
tbl_feedback |
|
|
Nome campo |
Tipo campo |
|
Id Autonumber |
primary key |
|
Nome |
Text |
|
|
Text |
|
Commenti |
Memo |
E poi ho inserito un paio di records in modo da fare un test dell’intera procedura.
A questo punto lasciami chiarire la scelta di Access come database. Io di solito uso MS SQL ma ho pensato che Access sia un pò più accessibile come costo. Però il tipo di database che adoperi per questi esercizi non è molto rilevante. Il code che scriveremo funziona per quasi tutte le banche dati commerciabili, quindi scegli quella con cui sei più comodo.
Prima che andiamo troppo avanti però, devo dirti che Access non è una soluzione industriale, non è il tipo di applicazione che vorrei adoperare su un web server per un sito commerciale.
Allora cominciamo a fare cose serie. Fino a poco tempo fa, costruire un sito dinamico con un database era un lavoro solo per i “big boys” ma adesso con oggetti (o meglio super oggetti) come ActiveX Database Object (ADO) è diventato un gioco da ragazzi.
ADO è come un superset di un oggetto. È una collezione di oggetti che, tutte insieme, semplificano il lavoro di collegare e manipolare i dati che risiedono dentro il database. In più ADO è inserito dentro un’altra tecnologia di Microsoft, Object Linking & Embedding DataBase (OLE DB), il che rende le cose ancora più facili.
La prima cosa da fare per lavorare con un database è di creare una connection. Se vuoi dare acqua al giardino devi attaccare il tubo al rubinetto, è uguale.
Il metodo che adoperiamo per collegarci è sempre lo stesso indipendentemente dal tipo di database che utilizziamo, la sintassi però varia. Ci sono diverse maniere per collegarsi ma qui, per semplicità adoperiamo la Connection String.
Per esempio per collegarci con il nostro database dobbiamo inserire il seguente codice:
|
<% |
Un consiglio gratuito: non salvare mai il database nella stessa directory dei tuoi file ASP. Mettilo sempre fuori dal tuo Web Root, in modo da renderla inaccessibile agli utenti.
Lo stesso code per MS SQL per esempio è
|
<% |
Comunque una volta che abbiamo inserito uno di questi due comandi per la nostra pagina ASP siamo collegati al database.
Non ci credi? Beh, prova un po’ questo codice (chiama il file check_connection.asp)
|
<% Set objRs = Server.CreateObject(“ADODB.Recordset”) Do while NOT objRs.EOF objRs.Close |
Se non ha funzionato, leggi i messaggi che il Browser ti dà sulla pagina. Io qui uso IE5.5 e se per esempio metto l’indirizzo del database sbagliato mi dice:
Error Type:
Microsoft JET Database Engine (0×80004005)
‘C:\asptutorial\tut\crm.mdb’ is not a valid path. Make sure that the path name is spelled correctly and that you are connected to the server on which the file resides.
/tut/check_connection.asp, line 4
Svelto, guardo subito alla linea 4 e vedo subito dove è il problema.
Se a questi punto il database non funziona non puoi continuare con le lezioni. Quindi concentrati e lavora. Quando sei riuscito a vedere il contenuto del tuo database, prosegui con la lezione 11 e vediamo un po’ che cosa è che abbiamo fatto in realtà.
Facciamo la conoscenza con il Connection e il Recorset
Congratulazioni ;o)
Adesso che hai passato questo ostacolo, non ce ne sono più. Di qui in poi, è tutta discesa. A dir la verità, è proprio incredibile come si fa presto al giorno d’oggi. Fino a poco tempo fa ci sarebbero volute delle settimane per fare una cosa simile. La metafora del Lego sta diventando più e più realtà.
Allora cos’è che abbiamo fatto esattamente? Cosa significa il codice che abbiamo usato?
Cominciamo dal principio:
Abbiamo già visto prima come si costruisce un oggetto con NewMail. Qui faremo lo stesso. Costruiamo un oggetto Connection che appartiene ad ADO e lo chiamiamo objConn.
|
Set objConn = Server.CreateObject(“ADODB.Connection”) |
Poi usando il metodo Open del Connection Object ci colleghiamo al database:
|
objConn.Open(“Provider = Microsoft.Jet.OLEDB.4.0; Data Source = C:/asptutorial/crm.mdb”) |
Adesso abbiano bisogno di un oggetto Recordset (anche questo di ADO) per metterci dentro tutti i nostri dati che vengono fuori quando interroghiamo il database.
|
Set objRs = Server.CreateObject(“ADODB.Recordset”) |
E poi con il metodo Execute dell’oggetto Connection eseguiamo una query al database e depositiamo il risultato nel recordset che abbiamo costruito.
|
set objRs = objConn.Execute(“SELECT * from tbl_feedback”) |
Ciò che faremo di qui in poi l’abbiamo già visto. Questo While Loop semplicement dice “fai finché non siamo arrivati alla fine del file” (EOF = End Of File)
|
Do While NOT objRs.EOF |
Scrivimi il nome, email e commenti del primo record:
|
response.write “nome = ” & objRs(“nome”) & “<br>” |
e quando l’hai fatto spostati al prossimo record
|
objRs.Movenext |
e rifallo
|
Loop |
Poi si pulisce.
|
<% |
Tutto qui.
Naturalmente questa non è l’unica maniera di scrittura del codice e forse neanche la più efficiente, comunque avrai poi tempo di sperimentare per conto tuo. Questo metodo è semplice e valido.
Bisogna sottolineare che è molto importante chiudere il recordset e la connection. Vedremo i motivi un po’ più avanti.
La regola più importante per accedere ad una database è uguale a quella nell’affrontare una rotonda stradale: entra più svelto che puoi ed esci appena possibile. Quindi la connection deve essere chiusa al più presto possibile in modo da far posto a un’altra macchina. È più che sicuro che nella nostra applicazione queste righe di code saranno ripetute molte volte anche spesso nella stessa pagina. Anche se fai 100 chiamate nella stessa pagina mai lasciare aperta la connection, chiudila sempre e crearne un’altra quando ne hai bisogno. Altrimenti se continui a girare intorno e intorno gli altri faranno fatica ad entrare.
Allora, vediamo se possiamo semplificare un po’ il codice che abbiamo scritto per evitare di scrivere sempre tutto.
Per esempio la string che usiamo per collegarci al database, poiché è sempre la stessa, non potremmo metterla nel global.asa? Ricordi? Se la mettiamo in quel file ce l’abbiamo sempre e se spostiamo il database da un’altra parte o se ne facciamo un’altra dobbiamo solo cambiare quella linea e tutto il resto funziona.
|
<% |
Cosi che nelle nostre pagine ci colleghiamo così:
|
<% objConn.Open Application(“dbconn”) %> |
O ancora meglio, potremmo scriver una procedura
|
<% |
Tutte le volte che devi accedere al database basta una riga sola
|
<% |
e così finiamo questo programma per bene. (Segue check_connection.asp)
|
<% call Main() Sub Main() call Prendi_Recordset(strConn, strsql) ‘pulisci e chiudi Sub Guarda_Recordset(objRs) Function Prendi_Recordset(strConn, strsql) |
Conoscenza col Connection e Recordset non basta
Nella lezione precedente siamo riusciti a estrarre un recordset dal nostro database. Bene, da qualche parte si deve pur cominciare. Se non l’avevi mai fatto sono sicuro che sei molto contento con te stesso ;o)
L’oggetto Recordset però è un po’ più complicato di quello che abbiamo fatto fino adesso. Se ci hai fatto caso, nel programma check_connection.asp abbiamo dovuto mantenere la Connection con il database aperta finché non abbiamo finito col recordset. La ragione è che il metodo che abbiamo adoperato, essendo il più semplice, ci ha dato un Connected Recordset. C’è un’altra maniera, e più efficiente di estrarre un recordset che ci permette di chiudere la connection non appena i dati sono arrivati. Questo è il Disconnected Recordset.
Modifichiamo il nostro Prendi_Recordset così che possiamo chiudere la connection subito. Prima però abbiamo bisogno di includere un file che contiene i valori delle costanti di ADO. Il file si chiama adovbs.inc e si include nella pagina con questa sintassi:
|
<!–#include virtual=”yourwebroot/dovelatrovo/adovbs.inc”–> |
Lo so che non abbiamo parlato di Includes e forse è meglio se ne parliamo subito.
Gli Includes sono un po’ come le Funtions e le Procedures e si adoperano per incapsulare del codice in modo da poterlo riutilizzare in molte pagine. Il motore di ASP, quando vede una direttiva “include”, cerca il file e inserisce il codice che trova in quel punto del file. Personalmente io adopero poco i file include perché rendono il codice più difficile da leggere e possono creare problemi se la struttura del directory del sito cambia. Di regola si fa una folder chiamata include e tutte le include si chiamano di li. Per convenzione sono chiamati con estensione .inc ma le puoi chiamare anche con .asp. Come tutto il resto possono contenere ASP, HTML o una mescolanza di tutto.
Con un po’ di giudizio sono molto utili e anche noi li adopereremo presto. Il più grande vantaggio è che se mettiamo un file include che, per esempio, contiene un numero di funzioni utili al principio di tutte le nostre pagine, quando cambiamo l’include non dobbiamo cambiare nessuna delle nostre pagine.
Ma riprendiamo con la nostra funzione che ci dà indietro un recordset disconnesso.
|
<% Set objConn = Server.CreateObject(“ADODB.Connection”) objRS.CursorLocation = adUseClient Set objRS.ActiveConnection = Nothing Prendi_RecordSet = objRS End Function |
Ne segue che dalla nostra pagina la chiamiamo con:
|
<% Set objRS = Prendi_RecordSet(strConn, strsql) %> |
La ragione per cui è preferibile chiudere le connessioni al database al più presto è che le connessioni richiedono al server risorse considerevoli. In più se non le chiudiamo esplicitamente rimangono aperte, con il risultato che le performance del Server deteriorano drasticamente. Non vogliamo, insomma, fare aspettare i nostri utenti più di quello che devono.
Spesso però dobbiamo fare delle query al database che non richiedono che il codice ci ritorni un recordset. Per esempio se volessimo inserire un nuovo record nella nostro database o se ne volessimo cambiare uno già in esistenza.
In questi casi è sufficiente collegarci e eseguire la query, così:
|
<% strsql = “INSERT INTO tbl_feedback ( nome, email, commenti, ricevuto ) Values(‘amerigo vespucci’,'amerigo@nave.net’,'hello therè,Now());” Set objConn = Server.CreateObject(“ADODB.Connection”) |
Quando questi programmi non funzionanao subito come vorresti, usa il response.write per vedere cosa è che non va. Per esempio con:
|
<% Response.write strsql %> |
Potresti vedere il code sql della tua query. Se lo tagliamo e lo incolliamo nella query window di Access vedi subito se funziona o no. Lo puoi mettere a posto da lì e quando ha funzionato in Access lo puoi incollare di nuovo nel tuo programma.
Anche in questi case sarebbe meglio fare una Function così che la possiamo usare dappertutto e in una maniera uniforme.
|
<% Set objConn = Server.CreateObject(“ADODB.Connection”) objConn.Execute strSQL objConn.Close End Sub |
Quando la chiamiamo dal nostro programma, questo basta
|
Call fai_query( strConn, strsql) |
A questo punto abbiamo un bell’esempio per l’uso di una include file. Se mettiamo queste Procedure e funzioni che abbiamo scritto per connetterci al database in un file unico e chiamandolo attrezzi_db.inc, possiamo adoperarle dappertutto nelle nostre pagine.
|
<!–#file virtual=lamiaWebRoot/include/attrezzi_db.inc –> |
Il nostro programma diventa molto più facile da leggere, ci risparmiamo un mucchio di linee di codice e siamo sicuri che chiudiamo le Connections.
Non ho ancora finito. Lezione pratica.
Adesso che sai recuperare un record dal database e metterne dentro uno nuovo non ci rimane un gran che da fare. Per fare qualcosa di utile cerchiamo allora di costruire un’applicazione che ci permetta di inserire delle informazioni nel database attraverso una form e di mostrarle quando visualizziamo una pagina. Per esempio: se volessimo mostrare notizie di attualità sul nostro sito e cambiarle ogni giorno, non sarebbe meglio automatizzare il lavoro invece di scrivere HTML in continuazione? Io penso di sì!
Allora scriviamo il pseudocodice che descrive l’applicazione:
Input
Se la form è vuota
Mostrala
Se no
Entra I dati nel database
Output
Prendi il recordset dal database
Formattalo e mostralo all’utente
Subito costruiamo un’altra tabella per questa applicazione dove mettiamo i seguenti campi:
|
tbl_news |
|
|
Nome campo |
Tipo campo |
|
Id |
primary key |
|
Titolo |
Text |
|
Sottotitolo |
Memo |
|
Testo |
Memo |
|
Data_vivo |
date/time |
|
Data_morto |
date/time |
Hai fatto? Via! La form la fai con gli occhi chiusi. Io, qui sotto, modifico quella che abbiamo già fatto per il feedback, è quasi uguale. Salva questa form e chiamala news.inc Io uso i file include (.inc) di rado, ma ora voglio farti vedere un po’ tutte le maniere in cui si può lavorare.
|
<– NEWS.INC–> <BODY> </BODY> |
L’unica cosa che ancora non hai visto qui è la maniera in cui inseriamo il valore dalla data di oggi. Mi sembra che ne abbiamo parlato nella prima lezione. Inutile farlo a mano, no?
|
<tr> |
Le date sono sempre un po’ problematiche con le banche dati e nel maneggiarle di sicuro ti verrà qualche capello bianco. Infatti paesi diversi adoperano formati diversi. Per esempio negli USA la data è sempre riportata come mese/giorno/anno, mentre in Europa è giorno/mese/anno. A dirti la verità io odio le date ma, hey! Non si può farne a meno.
Adesso mettiamoci intorno il resto del programma adoperando quella library che abbiamo già fatto attrezzi_db.asp. Includendola abbiamo accesso alle nostre funzioni.
|
<% call Main() Sub Main() Sub vendemmia(form) Function costruisci_query(titolo,sottotitolo,news,vivo,morto) Sub quale_risultato(message) end sub |
Non è un gran che diverso da quello che abbiamo già fatto prima. Ma come sempre quando si comincia a scrivere il codice il pseudocodice si espande e così il nostro originale è diventato:
Input
Se la form NON è vuota
includi il file attrezzi.asp
vendemmia la form
costruisci la query
esegui la query
chek per errori
Entra I dati nelil database
cronaca il risultato
Se no
Mostra la Form
finito
Costruire la query, cosa che ancora non avevamo fatto, è sempre un po’ difficile ma richiede solo attenzione. Le prime volte è sempre meglio stamparla così si vede cosa non va. Più che altro stai attento alla sintassi mettendola in ordine come ho fatto io, o ancora di più se vuoi. Ordine is GOOD!
Per esempio guarda come spesso si programma in ASP:
|
<% |
Come fai a vedere errori di sintassi qui? e questa è una query da bambini. Ancora meglio di quello che ho fatto io sarebbe:
|
<% |
Vedi come è più facile trovare errori con un buon layout? Un altro cambiamento è avvenuto nella nostra fai_query(), la funzione che esegue la query. Quando si fanno delle query al database c’è sempre la possibilità che qualche cosa non funzioni e così è indispensabile controllare ogni errore. Guarda come abbiamo modificato il code di fai_query():
|
objConn.Execute strSQL if err = 0 then |
la linea On Error Resume Next forza il programma a continuare in caso di errore. Se non c’è un errore, l’oggetto Error rimane a zero e noi implementiamo un flag che dice “ok” ma se un errore è occorso allora mandiamo un messaggio al nostro utente per dirgli che qualcosa non ha funzionato. La nuova procedura quale_risultato(message) manda il messaggio che vogliamo noi invece di uno che vuole Microsoft.
Allora tutto quello che rimane è formattare l’Output ma lo faremo nella prossima lezione.
Questa lezione sarà di riposo. Vogliamo solo finire la nostra applicazione per le news e sappiamo già cosa dobbiamo fare. Vediamo allora come formattare l’output:
Output
Prendi il recordset dalil database
Format e mostrala al cliente
Se modifichiamo il nostro file check_connection.asp esso dovrebbe già fare tutto. Cambiamo la query e basta.
Ma adesso mi accorgo che questa lezione non è un riposo poiché abbiamo a che fare con delle date ;o(
Beh, tanto vale che risolviamo il problema.
Se vogliamo che il nostro programmino di News sia utile bisogna che facciamo vedere solo le News che si riferiscono alla data corrente quindi la nostra query deve tener conto forzatamente della data e dovrebbe diventare
select * from tbl_news where data_morto < oggi
In genere il formato della data dipende da come il server è stato configurato e non sempre noi abbiamo controllo del server. Diciamo che il tuo sito è su un server a Bologna e tutto funziona perfettamente. Domani invece lo muovi su un server a Seattle (USA) perché ti costa la metà, funzionerà tutto bene anche lì?
Io credo di no. Il server americano di sicuro salva la data come mese/giorno/anno mentre a Bologna tu adoperavi giorno/mese/anno. Se, per esempio, si vuole inserire un comando del tipo:
se
02/03/01 è diverso da 03/02/01
allora cambia la data
a Bologna sarà vero ma a Seattle non lo sarà più anche se la data è la stessa. Come facciamo a risolvere questi problemi?
Non è poi così difficile è solo una seccatura. Prova un po’ questo:
|
<% oggi = date() response.write “x(0) = ” & x(0) & “<br>” |
Con la funzione Split riusciamo a separare i tre campi della data. Una volta che li abbiamo così, possiamo rimetterli a posto come vogliamo noi
|
<% |
Allora adesso che abbiamo risolto il problema della data, torniamo al nostro output per il programma News.
Prendi il vecchio check_connection.asp è chiamalo news_out.asp. L’unica cosa da fare qui è cambiare:
|
Sub Guarda_Recordset(objRs) |
così che si presenta un po’ meglio.
Prima però mettiamo un altro campo nel database così che possiamo mandare i nostri clienti direttamente ad un’altra pagina dove la news viene mostrata per intero o ad un altro sito dove ci sono informazioni più approfondite.
Naturalmente bisogna anche cambiare l’input così che possiamo inserire questo URL nel database.
Ora la nostra tbl_news ha un campo chiamato url e questi comandi vanno nel nostro news.inc:
|
<tr> |
Allora adesso dobbiamo fare in modo che la pagina mostri il titolo e il sottotitolo di tutte le news che abbiamo con la data_morto > (maggiore) di oggi. Poi quando il cliente clicca sul titolo il testo deve apparire per intero.
Adesso la mia procedura è diventata:
|
<% ‘vendemmia la form Do while NOT objRs.EOF <table width=”80%” border=”0″ cellpadding=”4″ cellspacing=”2″> <% End sub |
Come vedi puoi formattare l’output come vuoi e come hai sempre fatto.
L’unica linea che non abbiamo commentato è quella dell’URL
|
<a href=”<%=objRs(“url”)%>”><%=titolo%></a> |
Si potrebbe anche fare molto meglio passando l’id della news nella Request.Querystring così:
|
<a href=”<%=objRs(“url”)%>?id=<%=objRs(“id”)%><%=titolo%></a> |
se questa sintassi ti sembra un po’ confusa prova invece:
|
response.write “<a href=’” & url & “?id=” & id “‘>” & titolo & “</a>” |
tutte e due danno lo stesso risultato.
Ormai è tutto semplice no?
Adesso che abbiamo imparato a usare un database dal Web e sappiamo costruire pagine che ci danno accesso a tutti i nostri dati non dobbiamo più essere in ufficio per lavorare. Volendo, possiamo rimanere a letto e con il portatile continuare a mantenere il sito in tutta tranquillità.
Però… prima bisogna creare un’area privata sul nostro sito altrimenti chiunque sapesse l’URL potrebbe modificare il nostro database attraverso le nostre pagine. Un grosso NO, NO. Il database è il nostro tesoro. Prima di rimanere a letto sarà meglio che creiamo una Login con una password in modo da essere al sicuro proprio come Ali Baba dentro la sua caverna.
Cosa si fa? Di sicuro hai già una buona idea su come procedere. Io di solito faccio così:
Nel global.asa metto:
|
<% |
Ok, così quando vieni nella pagine la variabile mi dice che tu non sei autorizzato. Quindi in ognuna delle mie pagine che voglio mantenere private, in cima, prima che succeda niente, controllo per vedere se il mio cliente ha l’autorizzazione.
|
<% |
Siccome tutte le mie pagine adoperano due include, una per la testa della pagina e una per la coda, di solito questa parte del codice risiede lì.
Allora con questo sistema non possono entrare ma sfortunatamente non possiamo entrare neanche noi ;o)
Quindi creiamo subito una tabella nel nostro database chiamandola tbl_login. Qui ci mettiamo:
|
tbl_login |
|
|
Nome campo |
Tipo campo |
|
Id |
primary key |
|
Nome |
Text |
|
Cognome |
Text |
|
Login |
Text |
|
Password |
Text |
e adesso scriviamo il programma Login.asp.
Da ora in poi non strutturerò più il codice in quanto i programmi sono un po’ troppo corti per farlo. Lo puoi far tu se vuoi, è una buona abitudine da prendere.
Siccome abbiamo già messo la nostra variabile Login nella global.asa, quando entriamo nel sito per la prima volta è già inizializzata come:
login = false
La logica, come sempre, è
Se clickato
fai quello che devi fare
se no
mostra la form
|
Dim objConn, strConn, objRs, strsql <html> <% If Submitted then strConn = Application(“dbconn”) login = Request.Form(“login”) strsql = “Select id, login, password FROM tbl_login “ Set objConn = Server.CreateObject(“ADODB.Connection”) If objRs.EOF then <div align=”center”> </body> <% Response.end |
I dati della form sono entrati in una query al database e se il recordset è vuoto vuol dire che non abbiamo trovato una valida combinazione di login/password quindi rimandiamo al login.asp per riprovare.
Qui potresti contare fino a 3 per esempio e poi far scomparire il login.
Se il recordset contiene dati, vuol dire che la combinazione esiste e quindi:
|
<% Session(“login”) = true %> |
che ci permette di entrare dentro al nostro sito in un area che controlliamo solo noi.
Se tu volessi adoperare questa tecnica per fare entrare i tuoi clienti in un area privata sarebbe comodo mantenere informazioni sul tuo utente. Informazioni che ti possono servire per comunicare con esso durante il tempo che spende con te nel tuo sito. Siccome abbiamo guardato al suo record tanto vale che teniamo le informazioni. Cose come:
|
<% |
La pagina Login.asp che abbiamo appena costruito è un po’ come la chiave dell’ufficio. Virtuale, naturalmente, e raggiungibile direttamente dal letto. Il nostro ufficio però è piuttosto vuoto e sarà meglio che cominciamo a riempirlo con le cose di cui abbiamo bisogno per lavorare.
Il file a cui ci manda il login.asp si chiama ufficio.asp per una ragione.
Questo qui sotto, per esempio, è uno dei miei. Di solito ne costruisco uno per ogni sito ma adesso che ci penso dovrei costruirmene uno solo che funziona per tutti i siti. Ah!, si impara sempre in questo lavoro…
eCalcx Home
Latest Stats
Daily
Weekly
Monthly
Menu Administration
Add new Tool
Change Tool Status
View/Edit /Delete Tool
Add admin
Add New Ad
Maintain Ad Campaign
View Ad Reports
Mailing
Maintain Maling list
Send email to list
Add subscriber
Subscribe/Unsubscribe from list
Feedback
CRM tool
Distribute
Analysis
Archive
Manage remote staff
Links
Edit/Delete links
Approve links
Workshop
Manage remote developers
Ognuna di queste entrate è un piccolo programma che mi permette di lavorare a letto. Beh, non proprio dal letto ma certo che non ho bisogno di essere in ufficio per mantenere questo sito.
Cominciamo allora a costruire il nostro ufficio.asp.
Il file è una semplice tabella dove possiamo continuare a metterci entrate ogni volta che costruiamo qualcosa di nuovo. Al momento ho paura che le news sono l’unica cosa che possiamo fare, ma di sicuro tu stai già pensando a un mucchio di altre cose.
|
<% |
Come vedi tutto quello che facciamo qui è controllare che la chiave ci sia altrimenti mandiamo un messaggio e rifiutiamo l’ingresso. Prova a incollare http://dovehaimessoquesta/ufficio.asp nell’area di indirizzo del browser e vedrai che non ti fa entrare.
Ora che hai aperto il tuo ufficio virtuale cominciamo a sistemarlo per bene.
Torniamo al programma News.asp. Ok, ci permette di inserire una nuova notizia ma cos’altro?
Bisognerebbe anche averne uno che ci permette di modificarla. Diciamo che siamo a letto e guardando il sito vediamo che abbiamo fatto un errore in un News, come lo accomodiamo?
Vediamo di modificare questa News e farla un po’ più utile. Bisognerebbe essere in grado di
aggiungere una nuova – lo facciamo già
cambiare una esistente
cancellare una esistente
Tutto qui? Tu forse ne sai più di me adesso ma io, al momento, non riesco a pensare ad altro.
Facciamolo in una maniera semplice. Creiamo un’altra entrata nel nostro ufficio:
|
<a href=”mantieni_news.asp”><font color=”teal”>Mantieni le News</font></a> |
e una fila chiamata mantieni_news.asp:
|
<% ‘abbiamo le chiavi? strConn = Application(“dbconn”) Set objConn = Server.CreateObject(“ADODB.Connection”) set objRs = objConn.Execute(strsql) response.write “<div align=center>” |
Con questa file vediamo tutte le nostre news, un titolo alla volta. Poi ad ogni titolo mettiamo un option per cambiare o cancellare quella specifica entrata.
Quando clicchiamo su “cambia” chiamiamo un’altra fila cambia_news.asp che ci permette di farlo.
Come? così:
|
<% ‘abbiamo le chiavi per l’ufficio? strConn = Application(“dbconn”) ’si, ma è clickata la Form? id = Request.QueryString(“id”) ‘raccogliamo I dati dall nostra form ‘costruiamo la query Set objConn = Server.CreateObject(“ADODB.Connection”) set objRs = objConn.Execute(strsql) objConn.Close else strsql = “Select * from tbl_news where id = ” & id Set objConn = Server.CreateObject(“ADODB.Connection”) set objRs = objConn.Execute(strsql) ‘vendemmia il recorset end if |
Tutto qui. Adesso possiamo cambiare quello che vogliamo, quando vogliamo e da dove vogliamo.
Nella stessa maniera puoi implementare il bottone che cancella, con un file cancella_new.asp. Questa è ancora più semplice. Tutto quello che devi fare è attivare una Delete query quando il bottone è cliccato.
Qui abbiamo usato una soluzione molto semplice ma si potrebbe/dovrebbe fare un po’ più elegante e con meno file. Queste sono questioni di preferenza. Avremmo potuto usare lo stesso file con un Select statement. La logica diventa un po’ più complicata ma di sicuro lo sapresti fare adesso.
Finisci questa applicazione da solo e vedrai che la troverai utile. Una volta che hai imparato a fare:
Insert
Select
Update
hai imparato a fare tutto ;o) Il resto è questione di pazienza, di stile, di sintassi. Non si finisce mai di imparare. In più come ti ho detto, ci sono molte maniere per spellare un gatto, molto più efficienti di quello che ti ho fatto vedere. Di sicuro troverai le tue.
Adesso che hai visto come si fa presto a lavorare senza dover essere in ufficio comincia a pianificare le tue prossime vacanze in Australia (è bello qui, sai?). Prima di partire sarà meglio che ci costruiamo un po’ più di attrezzi per il nostro sito altrimenti chi paga il mangiare?
Per esempio adesso che abbiamo un servizio di news efficiente e da poter cambiare tutti i giorni certamente le visite al nostro sito cresceranno e con quelle anche la comunicazione con i nostri clienti crescerà di volume. I nostri clienti ci faranno più domande (il che naturalmente vuol dire più business ;o) ed è importantissimo che noi gli rispondiamo il più presto possibile.
Se ti ricordi, nella lezione 9 abbiamo scritto una piccola applicazione che mostra una feedback form, e quando è inviata, ci manda un email. Troppo indietro? Beh, ormai fai prima a riscriverla. Però se la riscrivi tanto vale che la migliori allo stesso tempo. Cambiamola in modo che compia queste azioni:
Mostra la form
quando e submitted
mandaci una email
entra I dati nelil database
Trova il code vecchio così che ne ricicliamo dei pezzi. È vero che adesso ne sappiamo molto di più ma forse avevamo già fatto qualcosa di utile anche allora.
E infatti:
feedback.asp è la form, trovala e cambiamo solo la linea:
|
<FORM ACTION=”manda_feedback.asp” METHOD=”post”> |
apriamo un file nuovo e chiamiamolo feedback_extra.asp così poi lavoriamo tutto in un unico file. Io preferisco sempre meno file che più.
Allora la linea diventa:
|
<FORM ACTION=”feedback_extra.asp?clickato=true” METHOD=”post” onSubmit=”return submitIt(this)”> |
Oh, in più stavolta facciamo la verifica dei dati nella form sul cliente. Usiamo una semplice funzione in Javascript che controlla se l’email è vuota. Se non hai familiarità con Javascript prova a mandare la form senza email e vedi subito cosa succede.
|
<script language=”JavaScript”> |
Se il cliente non inserisce l’email facciamo aprire una piccola dialog window in cui chiediamo il suo l’indirizzo. Poi, quando torniamo alla form, collochiamo il cursore sull’email text box, per rendere tutto più facile.
E sempre meglio essere gentili, no?
Feedback_extra.asp comincia così, come al solito.
|
<% |
Il ‘facciamo tutto qui’ segue in dettagli:
|
<% <script language=”JavaScript”> </head> <% call Main() Sub Main() If clickato then else ‘——————————————————- nome = Request.Form(“nome”) end sub ‘——————————————————- strConn = Application(“dbconn”) strsql = “INSERT INTO tbl_feedback ( nome, email, commenti)” Set objConn = Server.CreateObject(“ADODB.Connection”) objConn.Close ‘——————————————————- messaggio = “Molte grazie per il feedback” & VBcrlf Set objMail = Server.CreateObject(“CDONTS.NewMail”) objMail.importance = 0 Sub mostra_grazie() %> |
Facile no? Adesso che abbiamo la nostra email in un database possiamo disegnarci e costruire una applicazione simile alla gestione delle news che ci permette di rispondere alla email con comodo e dal database. Questa applicazione deve:
· mostrarci il feedback “non risposto”
· permetterci di scrivere una risposta
· mandare la risposta all’utente
· inserire la nostra risposta nel database insieme al suo feedback
sarebbe anche bello se potesse mostrarci, se lo abbiamo, il feeedback precedente dallo stesso cliente. Per esempio, in caso che il feedback sia parte di una conversazione che ci siamo dimenticati, o se abbiamo più di una persona che risponde al feedback come lavoro quotidiano.
Proviamo?
E poi possiamo partire per l’Australia
Come sempre la logica viene per prima.
Qui siamo in ufficio così subito controlliamo se hai le chiavi.
si
Do
Finché ce n’è
prendi tutto il feedback che ancora non ha avuto risposta
mostralo
scegli quello a cui vuoi rispondere
dammi un area per la risposta
hai bisogno della conversazione precedente?
se si
mostrala in una nuova window
manda la risposta al cliente
entra la risposta nelil database
loop
no
messaggio “Fuori dal mio ufficio…!”
Guardando alla logica mi sembra che non possiamo proprio fare tutto senza fare un piccolo cambiamento al file della lezione precedente. Poiché vogliamo vedere solo il feedback cui non è stato risposto abbiamo bisogno di un campo nel database che ci indica lo stato di quel particolare feedback. Diciamo tre stati diversi, oppure come vuoi tu, ma almeno due sono necessari.
Quindi inseriamo un campo in tbl_feedback chiamato “status” e nel nostro codice inseriamo un controllo per questi tre stati. Vedi subito che puoi aggiungerne altri senza dover cambiare il database.
1. attivo
2. risposto
3. cancellato
La nostra Sub metti_dentro(a,b,c) in feedback_extra cambia così per tenere conto dello stato.
Naturalmente ho anche inserito il campo nella tbl_feedback in CRM.mdb:
|
<% strConn = Application(“dbconn”) strsql = “INSERT INTO tbl_feedback ( nome, email, commenti, status)” Set objConn = Server.CreateObject(“ADODB.Connection”) objConn.Close |
Adesso che abbiamo il campo status possiamo estrarre facilmente i nostri feedback non risposti con una query che abbia queste istruzioni:
select * from tbl_feedback where status=’attivo’
Allora via senza perder tempo. facciamo
feedback_mostra che ce li lista tutti
feedback_rispondi – ci permette di rispondere quello che scegliamo
feedback_manda – che manda l’email e entra la risposta nelil database/
Ecco feedback_mostra.asp:
|
<% If Session(“login”) then strconn= Application(“dbconn”) |
Nella nostra query, ordiniamo l’output così che la più vecchia viene fuori per prima, siccome non vogliamo fare aspettare I nostri clienti per troppo tempo.
|
<% strsql = “Select * from tbl_feedback where status = ‘attivo’ order by ricevuto” Response.write “<table border=’0′ width=’80%’ cellpadding=’2′ cellspacing=’2′>” |
Quando un oggetto è richiesto come in questo caso il Request, è sempre più efficiente estrarre il suo contenuto tutto in una volta. Nell’aprire un oggetto ci sono sempre dei costi e raccogliendo tutti i dati che ci servono in una volta li minimizziamo.
Avremmo anche potuto fare:
|
<% Response.write “<td width=’5%’><font color=red>” & objRs(“id”) & “</font></td>” %> |
ma l’oggetto si sarebbe riaperto e chiuso per ogni linea di codice
|
<% |
E’ per questo che io adopero funzioni come vendemmia(form) e raccolgo i dati dall’oggetto tutti in una volta. Questo concetto è valido per qualunque oggetto in ASP.
Questa è un funzione di VBScript per formattare una data in modo da non scrivere l’ora e i minuti ecc.
|
ricevuto = formatdatetime(objRs(“ricevuto”),VBShortdate) |
Qui abbiamo messo una immagine come un ancora. Quando vi clicchiamo sopra chiamiamo la pagina per rispondere e passandogli l’id del feedback che abbiamo scelto
|
Response.write “<a href=’feedback_rispondi.asp?id=id’>” Response.write “<td width=’5%’><font color=red>” & id & “</font></td>” objRs.MoveNext |
per quando abbiamo finito o vogliamo interrompere il nostro lavoro
|
Response.write “<tr><td><a href=’Javascript:history.back()>Torna indietro</a></td></tr>” else Sub niente_chiave() end sub </body> |
Nessun problema finora? Allora avanti.
Adesso il file feedback_rispondi deve solo prendere l’Id che abbiamo passato nella collezione QueryString dell’oggetto Request e eseguire una query al database con quello. Poi deve mostrarci un’interfaccia che ci permetta di rispondere al nostro feedback. Per la nostra risposta possiamo entrare una textarea che ci permette di scrivere. Ecco tutto il programma
|
<% <html> If Session(“login”) then |
Allora prendiamo subito l’id di cui abbiamo bisogno per trovare il feedback che vogliamo
|
id = Request.QueryString(“id”) |
e l’id lo adoperiamo qui:
|
strsql = “Select * from tbl_feedback where id = ” & id |
tutto fatto, ora formattiamo l’output così che lo vediamo e come vogliamo noi. Se tu vuoi puoi naturalmente usare del’HTML normale. Io mi sono abituato così’ e sono ormai troppo vecchio per cambiare ;o)
Anche qui vedi, apriamo l’oggetto objRs una volta sola e lo vuotiamo di tutto
|
<% |
Ricordati che anche se rimaniamo nella stessa pagina il server la tratta come una pagina nuova. Quando il cliente clicca su Invia esegue una richiesta al server per questa pagina e il server la manda indietro. È solo la nostra logica che le fa fare cose diverse. Quindi dobbiamo passare l’id ancora per inviare la nostra risposta nel feedback giusto del database e in più abbiamo bisogno dell’email per mandargli la risposta:
|
Response.write “<form action=’feedback_manda.asp?id=’” & id & “&email=” & email & ” method=’post’>” Response.write “<table border=’1′ width=’95%’ cellpadding=’2′ cellspacing=’1′ bgcolor=’#f5deb3′>” |
E adesso tutto quello che ci è rimasto da fare è mettere la nostra riposta.
Oh, mi sono dimenticato! Non abbiamo un campo risposta nella nostro database o sì? Non mi ricordo, vado a controllare.
Non c’è. Mettiamolo e, già che ci siamo, mettiamo anche un campo per la data in cui abbiamo inviato la nostra risposta. Poi quando abbiamo usato questo programma per un po’ e abbiamo un mucchio di dati, possiamo fare delle analisi per vedere quanto siamo efficienti nel rispondere ai nostri clienti. Per esempio:
“trovami il numero dei feedback in cui la differenza ( ricevuto, mandato) > 24 ore”
Ho messo due campi in tbl_feedback:
risposta – memo
mandata – date/time
allora la file feedback_manda.asp diventa così:
|
<% |
L’oggetto response deve essere dichiarato per primo se vogliamo usarlo nella pagina. Poche dichiarazioni come
Option explicit
Language…
riescono a stargli davanti. Tutto ciò riguarda il fatto che l’oggetto response deve inserire delle informazioni nell’header HTTP, quindi se è già scritta lui non può farlo.
Comunque te ne accorgerai subito perché il motore di ASP ti restituirà un brutto errore.
Se vuoi vedere queste cose, semplicemente commenta la prossima linea e poi vedi cosa succede. La prossima volta che ti succede non ti devi rompere la testa inutilmente poiché quell’errore lo sai già
|
Response.buffer = true ‘——————————————————– <html> ‘If Session(“login”) then |
prendiamo tutto il contenuto della querystring
|
id = Request.QueryString(“id”) |
e della form:
|
risposta = Request.Form(“risposta”) |
il vecchio problema delle " più che altro per MS SQL credo…
|
risposta = Replace(risposta,”‘”,”””) |
usiamo la funzione date per ottenere la data di oggi
|
mandata = Date() strconn= Application(“dbconn”) |
e naturalmente cambiamo lo status del feedback così che non torna più:
|
strsql = strsql & ” status = ‘risposto’” Set objConn = Server.CreateObject(“ADODB.Connection”) |
questa lo presa da una lezioni di prima e l’ho leggermente modificata:
|
call manda_posta(email, risposta) |
e adesso che abbiamo fatto tutto, il response.redirect ci rimanda al nostro file che ci mostra tutti i feedback e, se tutto ha funzionato al meglio, quello che abbiamo appena risposto non dovrebbe apparire più.
|
response.redirect “feedback_mostra.asp” else ‘——————————————————– Set objMail = Server.CreateObject(“CDONTS.NewMail”) objMail.From = “ilnostroindirizzo” objMail.importance = 0 Set objMail = Nothing |
Tutto qui. Non c’è male per un paio d’ore di lavoro, no? Adesso comincia a tenere il tuo portatile sul comodino così, quando ti svegli alla mattina, rispondi subito ai tuoi clienti che sono venuti durante la notte. Quindi, comincia pure a pianificare il tuo viaggio che ormai il sito te lo mantieni da dove vuoi.
Ho messo anche un campo al feedback nel mio ufficio.asp e siccome ci comincio a lavorare dentro l’ho fatto anche un po’ più bello ;o)
|
<% If session(“login”) then <th align=”left” width=”170″><img src=”NFM.GIF” width=”158″ height=”100″ alt=”" border=”0″></th> </td></tr></table> <!———–comincia CRM———————-> </td></tr></table> |
Vogliamo degli altri in Ufficio?
Adesso abbiamo le News e il Feedback. Il concetto delle News lo possiamo applicare in molte maniere. Potremmo permettere, ad esempio, che i nostri utenti le inseriscano da soli. Diciamo che invece di news sono degli avvenimenti pubblici ed è nell’interesse del cliente mantenerli in regola. Credi di saperlo fare questo?
Cosa bisogna fare?
1. costruire una form per l’applicazione del cliente
2. entrare I dati del cliente nelil database
3. generare la password e mandargliela per email
4. provvedere il cliente con un attrezzo per mantenere le sue pagini (solo le sue)
Ecco la form che non presenta nessun problema
|
<% |
Qui adoperiamo Javascript per validare il contenuto della form. Fare queste cose sul browser è molto più logico che dover fare un altro salto sul server
|
<script language=”JavaScript”> if (theform.nome.value == “”) { |
e qui mettiamo semplicemente il focus sulla prima text box, ossia il nome
|
<body OnLoad=”Javascript:document.frm_client.nome.focus();”> |
Quando viene attivato l’evento OnSubmit chiamiamo la routine in Javascript che controllo se le text boxes che vogliamo noi sono state riempite o no.
|
<form ACTION=”metti_aggiungi_cliente.asp” name=”frm_cliente” method=”post” OnSubmit=”return submitIt(this)”> </body> |
Ed ecco metti_aggiungi_cliente.asp che
1) raccoglie i dati
2) genera la password
3) inserisce i dati nel database
4) manda un email al cliente
|
<% ‘vendemmia la form ‘metti dentro al database strsql = “INSERT INTO tbl_login (nome, cognome, login1, password1, data_ricevuto, email)” |
Non so se hai notato che ho dovuto cambiare il nome del login e password nella tbl_login. Li ho semplicemente cambiati con un 1. Il perché? Quando ho usato questa pagina mi ha data un errore nella query ma la sintassi era giusta. Cosi ho fatto un <% response.write strsql %> ho guardato alla query, l’ho inserita nel motore query di Access e mi ha funzionato alla perfezione. Deve avere a che fare con parole riservate. È sempre meglio usare notazioni giuste per le variabili.
|
Set objRs = objConn.Execute(strsql) objConn.close ‘molte grazie… ‘e via la posta ‘pulisci e chiudi ‘——————————————————————– x = 0 Sub manda_posta(nome,password,email) Dim objMail, messaggio messaggio = “Grazie per ……” Set objMail = Server.CreateObject(“CDONTS.NewMail”) objMail.From = “latuaemail” objMail.importance = 0 Set objMail = Nothing |
L’unica cosa da fare qui è costruire le pagine che permettono ai tuoi utenti di mantenere i loro dati.
Di sicuro questo ormai lo puoi fare anche da solo. In pratica è quasi uguale alle news. L’unica cosa è che devi organizzare le query con (where id = id) così che ogni cliente ha accesso alla sua area soltanto. Forse è sempre meglio se passi questo valore nell’oggetto Request.QueryString da una pagina all’altra.
Allora diamogli le chiavi e facciamoli lavorare
Tanto per finire questo tutorial e per essere sicuro che mi hai seguito fino a qui, facciamo anche questo piccolo programma. Cosa vogliamo fare? Adesso che abbiamo degli impiegati virtuali, dobbiamo dargli accesso al nostro ufficio virtuale.
Questo è facile, abbiamo già il nostro login e dobbiamo solo presentarlo all’utente. Poiché i suoi dati sono già inseriti dovrebbe essere in grado di eseguire il login senza problemi.
Prima però bisognerebbe considerare questo problema. Non tutti i nostri impiegati virtuali sono uguali quindi bisogna che li classifichiamo in modo da dargli gli strumenti di cui hanno bisogno per lavorare.
Mettiamo un nuovo campo in tbl_login e chiamiamolo permesso. Io l’ho reso numerico in modo da ottenere:
0 = permetti tutto
1 = permetti solo le news
Se vuoi lo puoi rendere anche testuale specialmente se dovessi aver bisogno più di 2 livelli.
Ora cambiamo il necessario in Login.asp:
|
<% strsql = “Select id, login, password FROM tbl_login” %> |
questa linea deve cambiare. Adesso abbiamo bisogno di sapere non solo id, login, password ma anche che tipo di permesso ha l’utente. In più possiamo anche prendere tutti i dettagli in modo da poterlo chiamare per nome. Ad esempio:
|
<% strsql = ” Select * FROM tbl_login” %> |
poi login.asp cambia così:
|
<% ‘raccogli tuttle le variabili di cui abbiamo bisogno objRs.close |
A questo punto vediamo un paio di scelte che dipendono dal tipo di sito con cui lavoriamo.
Siccome vogliamo mantenere queste variabili durante tutto il tempo che il nostro impiegato rimane nel nostro ufficio virtuale, sarebbe molto comodo se rendessimo le sessioni variabili così che le possiamo chiamare da qualunque pagina:
|
<% |
Se prendiamo questa strada, ci rendiamo la vita molto più semplice ma, poiché IIS mantiene uno spazio di memoria per ogni sessione che apre i costi per mantenere queste variabili crescono proporzionalmente con il numero di sessioni che apriamo o, per dirlo in un’altra maniera, il numero di utenti che adoperano il nostro sito.
Ne segue che se diventiamo vittime del nostro successo, che spesso capita con siti scritti bene e apprezzati dal pubblico, saremmo forzati a cambiare questo programma per tenere conto delle risorse sulla memoria del nostro server.
Questo problema si risolve facilmente usando la collezione QueryString dell’oggetto Request cambiando la linea seguente:
|
<% response.redirect “ufficio.asp?id=” & id & “&nome=” & nome & “&email=” & email & “&permesso=” & permesso & “”" %> |
così ci passiamo da pagina a pagina le variabili di cui abbiamo bisogno e le richiamiamo quando vogliamo. C’è un po’ più da scrivere ma in questo modo non stressiamo la memoria del nostro IIS.
Allora ecco tutto il nostro login.asp coi cambiamenti che abbiamo fatto:
|
<% If Submitted then strConn = Application(“dbconn”) login = Request.Form(“login”) strsql = “Select * FROM tbl_login “ response.write strsql & “<br>” Set objConn = Server.CreateObject(“ADODB.Connection”) If objRs.EOF then objRs.close <div align=”center”> </body> <% Response.end |
Ed ecco anche il nuovo ufficio.asp che tiene conto del permesso dell’utente così che mostriamo gli attrezzi disponibili nel nostro ufficio in accordo col permesso del cliente. Per esempio nel mio database ho inserito un utente col permesso 1 e lo lascio lavorare con le news ma non con il feedback che non è il suo lavoro.
Ed ecco il nuovo ufficio.asp:
|
<% ‘dichiariamo le variabili nuove |
Qui cambiamo leggermente così che possiamo usare l’ufficio come porta di entrata. Per esempio, oltre a mettere un click sulla nostra pagina per lasciare accesso ai nostri clienti potremmo anche comunicargli: vieni direttamente a questo URL. Se non ha effettuato il login chiederemo di inserire i dati di autenticazione.
|
<% <html> <th align=”left” width=”170″><img src=”NFM.GIF” width=”158″ height=”100″ alt=”" border=”0″></th> |
naturalmente dobbiamo passare l’id alla news.asp in modo da sapere chi è che ha inserito questa news nel database e nel sito. In più bisogna mettere un campo in più nella tbl_news per sapere chi è responsabile per quel specifico pezzo. Io lo chiamo “responsabile”:
|
<td width=”100> </td></tr></table> </td></tr></table> |
Adesso tutto quello che c’è rimasto da fare è modificare le news in modo che ognuno è solo responsabile per i suoi pezzi. Penso che in sostanza dovrebbe tutto rimanere come prima con la piccola differenza che quando costruiamo le nostre query dobbiamo tenere conto dell’id dell’utente.
Cambiamo questa linea ed è tutto fatto:
|
<% strsql =”Select * from tbl_news where id = ” & id & “,” & “data_morto >= #” & oggi & “#” %> |
adesso il cliente vede solo le sue notizie che è esattamente quello che volevamo fare.
Segue news.asp con diversi piccoli cambiamenti, ma di sicuro tu li vedi subito.
|
<% call Main() Sub Main() response.write id ‘bisogna passargli anche l’id e spero che tutit sia ricordato di entrare il campo nell tbl_news query = costruisci_query(titolo,sottotitolo,testo,vivo,morto,id) |
cambiato il nome. Poiché ho messo delle variabili nella vecchia news_inc ora bisogna chiamarla news_in.asp
|
<!– #include file=”news_in.asp”–> Sub vendemmia(form) morto = Request.Form(“morto”) ‘abbiamo una nuova variabile ’se hai dei guai costruendo questa, metti un Sub quale_risultato(message) end sub |
poi viene la form normale in cui ho solo messo il nome dell’utente.
News_in.asp:
|
<HTML> <BODY> <td><h1><%= nome %>, entra le news per oggi qui…<hr align=”LEFT” size=”1″ width=”100%” color=”navy”></h1></td> </BODY> |
Adesso che il nostro utente può entrare nelle News con un suo id, le possiamo anche estrarre alla stessa maniera quando vuole mantenere i suoi dati. Prendiamo il nostro vecchio file mantieni_new.asp e modifichiamolo:
|
<% id = Request.QueryString(“id”) If Session(“login”) then ‘come vedi cambiamo la query con la clausola id strsql = “Select * from tbl_news where responsabile= ” & id & ” order by data_morto Asc” Set objConn = Server.CreateObject(“ADODB.Connection”) objRs.CursorLocation = adUseClient response.write “<div align=center>” Do while Not objRs.EOF ‘quando hai tempo, metti questa in un .inc e formatala con un bel messaggio |
E adesso basta. Chiudiamo questo benedetto ufficio e andiamo a farci una pensata sopra.
Ok, io penso di fermarmi qui. Spero che tu adesso abbia appreso abbastanza per continuare a lavorare e per imparare ad adoperare questa tecnologia. In più spero che tu adesso sia in grado di identificare, disegnare e costruire gli strumenti di cui hai bisogno per il tuo lavoro.
Le regole sono semplici come hai visto. Scrivi il pseudocodice in lingua normale e poi segui con il codice.
Durante questo tutorial io ho preso molte scorciatoie. L’ho fatto più che altro per semplificare le lezioni e cercare di rimanere sul percorso di ASP. Ho persino adoperato alcuni tag HTML che sono già abolite come <font> ma, hey! non volevo cominciare a parlare di fogli di stile (CSS).
Ugualmente con l’arrivo di ASP3 ci sono molti più strumenti per connettersi con databases e per presentare il display sulla macchina del cliente.
Non li ho analizzati di proposito perché penso che è sempre meglio cominciare dal semplice. Adopera e analizza questi piccoli programmi che abbiamo scritto insieme. Vedrai che formeranno le basi di un mucchio di aggeggi che troverai utili e divertenti da costruire. E quando hai finito buttali via perché tanto il nostro lavoro è sempre così. Quello che fai oggi, domani è già obsoleto e devi ricominciare dal principio. Impara i concetti non la sintassi. La sintassi cambia ma i principi di queste tecnologie sono sempre gli stessi e quando hai imparato ASP le prossime tecnologie diventano molto più facili da usare. L’intelligenza è nascosta nei database, quando sai come mettere dentro dati, ritirarli e modificarli non c’è più limite a quello che puoi fare.
Ricordati, il database è il tuo amico.
Buon divertimento e Auguroni.
