KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > mmbase > module > sessions


1 /*
2
3 This software is OSI Certified Open Source Software.
4 OSI Certified is a certification mark of the Open Source Initiative.
5
6 The license (Mozilla version 1.0) can be read at the MMBase site.
7 See http://www.MMBase.org/license
8
9 */

10 package org.mmbase.module;
11
12 import java.util.*;
13
14 import org.mmbase.util.*;
15 import org.mmbase.module.core.*;
16 import org.mmbase.module.builders.*;
17
18 import org.mmbase.util.logging.Logger;
19 import org.mmbase.util.logging.Logging;
20
21 /**
22  * CLEARSET-NAME : This command clears the session variable called NAME
23  * ADDSET-NAME-VALUE : This command adds VALUE to the SESSION variable set called NAME, no duplicates are allowed
24  * PUTSET-NAME-VALUE : This command adds VALUE to the SESSION variable set called NAME, duplicates are allowed
25  * DELSET-NAME-VALUE : This command deletes VALUE form the SESSION variable set called NAME.
26  * CONTAINSSET-NAME-VALUE : returns "YES" if the session variable NAME contains the VALUE, otherwise returns "NO"
27  * SETSTRING-NAME : This command gives all values of the session variable NAME, comma separated.
28  * SETCOUNT-NAME : This command gives the number of values contained by the session variable NAME.
29  * AVGSET-NAME : This command returns the average of a set numbers.
30  * CLEARSESSIONINFO : This command clears the SessionInfo.
31  *
32  * @application SCAN
33  * @rename Sessions
34  * @author Daniel Ockeloen
35  * @version $Id: sessions.java,v 1.28 2005/01/25 12:45:18 pierre Exp $
36  */

37 public class sessions extends ProcessorModule implements sessionsInterface {
38
39     private static Logger log = Logging.getLoggerInstance(sessions.class.getName());
40
41     Hashtable sessions = new Hashtable();
42     private MMBase mmbase;
43     MMObjectBuilder props,users;
44
45     /**
46      * sessions Module constructor.
47      */

48     public sessions() {
49     }
50
51     public void init() {
52         mmbase=MMBase.getMMBase();
53     }
54
55     public sessionInfo getSession(scanpage sp,String JavaDoc wanted) {
56         if (log.isDebugEnabled()) {
57             log.debug("getSession(): wanted=" + wanted);
58         }
59         if (wanted!=null) {
60             sessionInfo session=(sessionInfo)sessions.get(wanted);
61             if (session==null) {
62                 if (sp.req!=null) {
63                     session=new sessionInfo(sp.req.getRemoteHost(),wanted);
64                 } else {
65                     session=new sessionInfo("<unknown>",wanted);
66                 }
67                 sessions.put(wanted,session);
68                 // get all the propertie values of this node
69
if (mmbase!=null) {
70                     try {
71                         loadProperties(session);
72                     } catch(Exception JavaDoc r) {}
73                 }
74             } else {
75                 session.setValue("COOKIETEST","YES");
76             }
77             return session;
78         }
79         return null;
80     }
81
82     public void forgetSession(String JavaDoc wanted) {
83         if(wanted!=null) {
84             if (sessions.containsKey(wanted)) {
85                 sessions.remove(wanted);
86                 log.info("forgetSession(" + wanted + "): Who? Don't know 'm .. sorry!");
87             } else log.warn("forgetSession(" + wanted + "): This key not found in session!");
88         } else log.error("forgetSession(" + wanted + "): wanted to forget a null!");
89     }
90
91     public String JavaDoc getValue(sessionInfo session,String JavaDoc wanted) {
92
93         if (session==null) {
94             log.error("getValue("+wanted+"): session is null!");
95             return null;
96         }
97
98         if(wanted.indexOf("-xmlescape")!=-1) {
99             wanted = wanted.substring(0,wanted.length()-10);
100             String JavaDoc ret = session.getValue(wanted);
101             return xmlEscape(ret);
102         } else {
103             return session.getValue(wanted);
104         }
105     }
106
107     /**
108      * Sets or changes a parameter in a sessionInfo.
109      *
110      * @param session the sessionInfo wich has to contain
111      * the parameter.
112      * @param key the name of the parameter to be set.
113      * @param value the value to wich the parameter should be set.
114      */

115     public String JavaDoc setValue(sessionInfo session,String JavaDoc key,String JavaDoc value) {
116         if (session!=null) {
117             return session.setValue(key,value);
118         } else {
119             log.error("setValue("+key+","+value+"): session is null!");
120             return null;
121         }
122     }
123
124     /**
125      * Adds a number of Strings to a set.
126      *
127      * @param session the sessionInfo containing the set.
128      * @param key the name of the set.
129      * @param value a Vector containing the
130      * Strings to be added to the set.
131      */

132     public void addSetValues(sessionInfo session,String JavaDoc key,Vector values) {
133         if (session!=null) {
134             String JavaDoc str;
135             for (Enumeration e=values.elements();e.hasMoreElements();) {
136                 str=(String JavaDoc)e.nextElement();
137                 session.addSetValue(key,str);
138             }
139         } else {
140             log.error("addSetValues("+key+","+values+"): session is null!");
141         }
142     }
143
144     /**
145      * Adds a String to a set. If the String is
146      * allready contained by the set nothing happens.
147      *
148      * @param session the sessionInfo containing the set.
149      * @param key the name of the set.
150      * @param value the String to be added to the set.
151      */

152     public void addSetValue(sessionInfo session,String JavaDoc key,String JavaDoc value) {
153         if (session!=null) {
154             session.addSetValue(key,value);
155         } else {
156             log.error("addSetValue("+key+","+value+"): session is null!");
157         }
158     }
159
160     public void setValueFromNode( sessionInfo session, MMObjectNode node ) {
161         String JavaDoc key = node.getStringValue("key");
162         String JavaDoc ptype = node.getStringValue("ptype");
163         String JavaDoc value = node.getStringValue("value");
164         if (ptype.equals("string")) {
165             setValue(session, key, value);
166         } else if (ptype.equals("vector")) {
167             StringTokenizer tok = new StringTokenizer(value,",\n\r");
168             while (tok.hasMoreTokens()) {
169                 addSetValue( session, key, tok.nextToken());
170             }
171         } else {
172             log.error("setValueFromNode(" + key + "," + ptype + "," +
173                       value + "): ptype("+ptype+") neither 'string' nor 'vector'!");
174         }
175     }
176
177     public void loadProperties(sessionInfo session) {
178         // daniel, added a check to switch between old and new users
179
// system. the new one uses a cookies builder so i use
180
// that as a check.
181
if (mmbase!=null) {
182             MMObjectBuilder bul=mmbase.getMMObject("cookies");
183             if (bul!=null) {
184                 loadNewProperties(session);
185                 return;
186             }
187         }
188         try {
189             String JavaDoc sid;
190             if (session!=null) {
191                 sid=session.getCookie();
192                 if (mmbase!=null) {
193                     props=mmbase.getMMObject("properties");
194                     // MOET ANDERS
195
Enumeration res=props.search("WHERE "+mmbase.getStorageManagerFactory().getStorageIdentifier("key")+"='SID' AND "+mmbase.getStorageManagerFactory().getStorageIdentifier("value")+"='"+sid+"'");
196                     if (log.isDebugEnabled()) {
197                         log.debug("loadProperties(): got SID(" + sid + ")");
198                     }
199                     if (res.hasMoreElements()) {
200                         MMObjectNode snode = (MMObjectNode)res.nextElement();
201                         int id=snode.getIntValue("parent");
202                         setValue(session,"USERNUMBER",""+id);
203                         res=props.search("parent=="+id);
204                         while (res.hasMoreElements()) {
205                             setValueFromNode( session, (MMObjectNode)res.nextElement() );
206                         }
207                     }
208                 } else log.error("loadProperties(): mmbase is null!");
209             } else log.error("loadProperties(): session is null!");
210         } catch (Exception JavaDoc e) {
211             // log.error(Logging.stackTrace(e));
212
}
213     }
214
215     public void loadNewProperties(sessionInfo session) {
216         // new system uses cookies/users builder to find
217
// the correct SID
218
try {
219             String JavaDoc sid;
220             if (session!=null) {
221                 if (mmbase!=null) {
222                     sid=session.getCookie();
223                     Users users=(Users)mmbase.getMMObject("users");
224                     int id=users.getNumber(sid);
225                     if (id==-1) {
226                         Cookies cookies=(Cookies)mmbase.getMMObject("cookies");
227                         id=cookies.getNumber(sid);
228                     }
229                     if (id!=-1) {
230                         props=mmbase.getMMObject("properties");
231                         System.out.println("NEW SID="+id);
232                         Enumeration res=props.search("parent=="+id);
233                         while (res.hasMoreElements()) {
234                             setValueFromNode( session, (MMObjectNode)res.nextElement() );
235                         }
236                     }
237                 } else log.error("loadProperties(): mmbase is null!");
238             } else log.error("loadProperties(): session is null!");
239         } catch (Exception JavaDoc e) {
240             // log.error(Logging.stackTrace(e));
241
}
242     }
243
244     public String JavaDoc saveValue(sessionInfo session,String JavaDoc key) {
245         // daniel, added a check to switch between old and new users
246
// system. the new one uses a cookies builder so i use
247
// that as a check.
248
if (mmbase!=null) {
249             MMObjectBuilder bul=mmbase.getMMObject("cookies");
250             if (bul!=null) {
251                 return saveValueNew(session,key);
252             }
253         }
254         if (mmbase==null) {
255             log.error("saveValue(" + session + "," + key + "): mmbase is null!");
256             return null;
257         }
258         if (session!=null) {
259             if( key != null ) {
260                 int id=-1;
261                 String JavaDoc sid=session.getCookie();
262                 MMObjectNode node=session.getNode();
263
264                 if (node==null) {
265                     // node not found
266
// --------------
267
props=mmbase.getMMObject("properties");
268                     users=mmbase.getMMObject("users");
269                     // does the sid have any properties?
270
if (props==null || users==null) {
271                         log.warn("Can't Save: One of the needed builders is not loaded either users or properties");
272                     } else {
273                         Enumeration res=props.search("key=='SID'+value=='"+sid+"'");
274                         if (res.hasMoreElements()) {
275                             // yes, is it a user?
276
// ------------------
277
// get the parent for this ID value
278
MMObjectNode snode = (MMObjectNode)res.nextElement();
279                             id=snode.getIntValue("parent");
280                             node=users.getNode(id);
281                             if( node != null ) {
282                                 session.setNode(node);
283                             } else {
284                                 log.warn("saveValue(" + key + "): node("+id+") for user("+sid+") not found in usersdb, maybe long-time-no-see and forgotten?!");
285                             }
286                         } else {
287                             // ----------------------------------------------------------------------
288
// Server has given a cookie, but *now* we create a new user & properties
289
// ----------------------------------------------------------------------
290
if (log.isServiceEnabled()) {
291                                 log.service("saveValue(" + key + "): This is a new user(" + sid + "), making database entry..");
292                             }
293
294                             node = users.getNewNode ("system");
295                             if( node != null ) {
296                                 node.setValue ("description","created for SID = "+sid);
297                                 id = users.insert ("system", node);
298                                 node.setValue("number",id);
299
300                                 // hier
301
// ----
302
MMObjectNode snode = props.getNewNode ("system");
303                                 snode.setValue ("parent",id);
304                                 snode.setValue ("ptype","string");
305                                 snode.setValue ("key","SID");
306                                 snode.setValue ("value",sid);
307                                 props.insert("system", snode);
308                                 session.setNode(node);
309                             } else {
310                                 log.error("saveValue(" + session + "," + key + "): No node(" + id + ") could be created for this user(" + sid + ")!");
311                             }
312                         }
313                     }
314                 } else {
315                     id=node.getIntValue("number");
316                 }
317                 // set value in the users node and save in database
318
// ------------------------------------------------
319
if (node!=null) {
320                     MMObjectNode pnode=node.getProperty(key);
321                     if (pnode!=null) {
322                         String JavaDoc value=session.getSetString(key);
323                         if (value==null) {
324                             value=session.getValue(key);
325                         }
326                         pnode.setValue("value",value);
327                         pnode.commit();
328                     } else {
329                         MMObjectNode snode = props.getNewNode ("system");
330                         String JavaDoc value=session.getSetString(key);
331                         if (value==null) {
332                             value=session.getValue(key);
333                             if( value==null )
334                             {
335                                 log.warn("saveValue("+key+"): value("+value+") is null!");
336                                 log.warn(" - values(" + session.values +")" );
337                                 log.warn(" - setvalues(" + session.setvalues +")" );
338                             }
339                             snode.setValue ("ptype","string");
340                         } else {
341                             snode.setValue ("ptype","vector");
342                         }
343                         snode.setValue ("parent",id);
344                         snode.setValue ("key",key);
345                         snode.setValue ("value",value);
346                         int id2=props.insert("system", snode);
347                         snode.setValue("number",id2);
348                         node.putProperty(snode);
349                     }
350
351                     return null;
352                 }
353                 else
354                 {
355                     log.error("saveValue("+session+","+key+"): no node("+node+") found for user("+sid+")!");
356                     return null;
357                 }
358             } else {
359                 log.error("saveValue("+session+","+key+"): key is null!");
360                 return null;
361             }
362         } else {
363             log.error("saveValue("+session+","+key+"): session is null!");
364             return null;
365         }
366     }
367
368     public String JavaDoc saveValueNew(sessionInfo session,String JavaDoc key) {
369         if (mmbase==null) {
370             log.error("saveValue("+session+","+key+"): mmbase is null!");
371             return null;
372         }
373         if (session!=null) {
374             if( key != null ) {
375                 int id=-1;
376                 String JavaDoc sid=session.getCookie();
377                 MMObjectNode node=session.getNode();
378
379                 if (node==null) {
380                     // node not found
381
// --------------
382
props=mmbase.getMMObject("properties");
383                     Users users=(Users)mmbase.getMMObject("users");
384                     // does the sid have any properties?
385
if (props==null || users==null) {
386                         log.warn("Can't Save: One of the needed builders is not loaded either users or properties");
387                     } else {
388                         id=users.getNumber(sid);
389                         // get use the new way !
390
if (id!=-1) {
391                             node=users.getNode(id);
392                             if( node != null ) {
393                                 session.setNode(node);
394                             } else {
395                                 log.warn("saveValue("+key+"): node("+id+") for user("+sid+") not found in usersdb, maybe long-time-no-see and forgotten?!");
396                             }
397                         } else {
398                             // ----------------------------------------------------------------------
399
// Server has given a cookie, but *now* we create a new user & properties
400
// ----------------------------------------------------------------------
401
// Daniel: for now removed what should we do ??
402
}
403                     }
404                 } else {
405                     id=node.getIntValue("number");
406                 }
407                 // set value in the users node and save in database
408
// ------------------------------------------------
409
if (node!=null) {
410                     MMObjectNode pnode=node.getProperty(key);
411                     if (pnode!=null) {
412                         String JavaDoc value=session.getSetString(key);
413                         if (value==null) {
414                             value=session.getValue(key);
415                         }
416                         pnode.setValue("value",value);
417                         pnode.commit();
418                     } else {
419                         MMObjectNode snode = props.getNewNode ("system");
420                         String JavaDoc value=session.getSetString(key);
421                         if (value==null) {
422                             value=session.getValue(key);
423                             if( value==null )
424                             {
425                                 log.warn("saveValue("+key+"): value("+value+") is null!");
426                                 log.warn(" - values(" + session.values +")" );
427                                 log.warn(" - setvalues(" + session.setvalues +")" );
428                             }
429                             snode.setValue ("ptype","string");
430                         } else {
431                             snode.setValue ("ptype","vector");
432                         }
433                         snode.setValue ("parent",id);
434                         snode.setValue ("key",key);
435                         snode.setValue ("value",value);
436                         int id2=props.insert("system", snode);
437                         snode.setValue("number",id2);
438                         node.putProperty(snode);
439                     }
440                     return null;
441                 } else {
442                     log.error("saveValue("+session+","+key+"): no node("+node+") found for user("+sid+")!");
443                     return null;
444                 }
445             } else {
446                 log.error("saveValue("+session+","+key+"): key is null!");
447                 return null;
448             }
449         } else {
450             log.error("saveValue("+session+","+key+"): session is null!");
451             return null;
452         }
453     }
454
455     public Vector getList(scanpage sp, StringTagger tagger, String JavaDoc cmd) throws ParseException {
456         String JavaDoc val;
457         sessionInfo tmps;
458
459         if (cmd.charAt(0)=='"') cmd=cmd.substring(1,cmd.length()-1);
460         if (cmd.equals("sessions")) {
461             Vector results = new Vector();
462             for (Enumeration e=sessions.keys();e.hasMoreElements();) {
463                 val = (String JavaDoc)e.nextElement();
464                 results.addElement(val);
465                 tmps=(sessionInfo)sessions.get(val);
466                 results.addElement(tmps.getHostName());
467             }
468             return results;
469         }
470         if (cmd.equals("SESSION")) {
471             Vector results=new Vector();
472             String JavaDoc key;
473             sessionInfo session=getSession(sp,sp.sname);
474             for (Enumeration e=session.values.keys();e.hasMoreElements();) {
475                 key=(String JavaDoc)e.nextElement();
476                 results.addElement("VAR");
477                 results.addElement(key);
478                 results.addElement(session.getValue(key));
479             }
480             for (Enumeration e=session.setvalues.keys();e.hasMoreElements();) {
481                 key=(String JavaDoc)e.nextElement();
482                 results.addElement("SET");
483                 results.addElement(key);
484                 results.addElement(session.getSetString(key));
485             }
486             return results;
487         }
488
489         String JavaDoc line = Strip.DoubleQuote(cmd,Strip.BOTH);
490         StringTokenizer tok = new StringTokenizer(line,"-\n\r");
491         if (tok.hasMoreTokens()) {
492             String JavaDoc cmd2=tok.nextToken();
493             if (cmd2.equals("GETSET")) return doGetSet(sp,tok);
494         }
495         return null;
496     }
497
498     /**
499      * Handle a $MOD command
500      */

501     public String JavaDoc replace(scanpage sp, String JavaDoc cmds) {
502         StringTokenizer tok = new StringTokenizer(cmds,"-\n\r");
503         if (tok.hasMoreTokens()) {
504             String JavaDoc cmd=tok.nextToken();
505
506             if (cmd.equals("CLEARSET")) return doClearSet(sp,tok);
507             if (cmd.equals("ADDSET")) return doAddSet(sp,tok);
508             if (cmd.equals("PUTSET")) return doPutSet(sp,tok);
509             if (cmd.equals("DELSET")) return doDelSet(sp,tok);
510             if (cmd.equals("CONTAINSSET")) return getContainsSet(sp,tok);
511             if (cmd.equals("SETSTRING")) return getSetString(sp,tok);
512             if (cmd.equals("SETCOUNT")) return getSetCount(sp,tok);
513             if (cmd.equals("AVGSET")) return getAvgSet(sp,tok);
514
515             log.warn("replace(" + cmds + "): Unknown command(" + cmd + ")!");
516         }
517         return this.getClass().getName() +"replace(): ERROR: No command defined";
518         // michiel: I did not explore for which this return value is used.
519
// the function is public, so I don't like to change the return value.
520
}
521
522     /**
523      * Adds a sessionvariable with specified value
524      */

525     public String JavaDoc doAddSet(scanpage sp, StringTokenizer tok) {
526         sessionInfo session=getSession(sp,sp.sname);
527         if (session!=null) {
528             if (tok.hasMoreTokens()) {
529                 String JavaDoc key=tok.nextToken();
530                 if (tok.hasMoreTokens()) {
531                     String JavaDoc value=tok.nextToken();
532                     session.addSetValue(key,value);
533                 }
534             }
535         }
536         return "";
537     }
538
539     public String JavaDoc doPutSet(scanpage sp , StringTokenizer tok) {
540         sessionInfo session=getSession(sp,sp.sname);
541         if (session!=null) {
542             if (tok.hasMoreTokens()) {
543                 String JavaDoc key=tok.nextToken();
544                 if (tok.hasMoreTokens()) {
545                     String JavaDoc value=tok.nextToken();
546                     session.putSetValue(key,value);
547                 }
548             }
549         }
550         return "";
551     }
552
553     /**
554      * This methode clears a SESSION variable
555      */

556     public String JavaDoc doClearSet(scanpage sp, StringTokenizer tok) {
557         sessionInfo session=getSession(sp,sp.sname);
558         if (session!=null) {
559             if (tok.hasMoreTokens()) {
560                 String JavaDoc key=tok.nextToken();
561                     session.clearSet(key);
562             }
563         }
564         return "";
565     }
566
567     public String JavaDoc getAvgSet(scanpage sp,StringTokenizer tok) {
568         sessionInfo session=getSession(sp,sp.sname);
569         if (session!=null) {
570             if (tok.hasMoreTokens()) {
571                 String JavaDoc key=tok.nextToken();
572                 return session.getAvgSet(key);
573             }
574         }
575         return "";
576     }
577
578     public String JavaDoc doDelSet(scanpage sp, StringTokenizer tok) {
579         sessionInfo session=getSession(sp,sp.sname);
580         if (session!=null) {
581             if (tok.hasMoreTokens()) {
582                 String JavaDoc key=tok.nextToken();
583                 if (tok.hasMoreTokens()) {
584                     String JavaDoc value=tok.nextToken();
585                     session.delSetValue(key,value);
586                 }
587             }
588         }
589         return "";
590     }
591
592     /**
593      * Checks if a Session variable contains a certain value.
594      *
595      * @return "YES" if the session variable contains the specified value
596      * "NO" if the session variable doesn't contains the specified value
597      */

598     public String JavaDoc getContainsSet(scanpage sp, StringTokenizer tok) {
599         sessionInfo session=getSession(sp,sp.sname);
600         if (session!=null) {
601             if (tok.hasMoreTokens()) {
602                 String JavaDoc key=tok.nextToken();
603                 if (tok.hasMoreTokens()) {
604                     String JavaDoc value=tok.nextToken();
605                     return session.containsSetValue(key,value);
606                 }
607             }
608         }
609         return "NO";
610     }
611
612     public Vector doGetSet(scanpage sp, StringTokenizer tok) {
613         Vector results=new Vector();
614         String JavaDoc line=getSetString(sp,tok);
615         if(log.isDebugEnabled()) {
616             log.debug("doGetSet(): SESSION LINE="+line);
617         }
618         if (line!=null) {
619             StringTokenizer tok2 = new StringTokenizer(line,",\n\r");
620             while (tok2.hasMoreTokens()) {
621                 results.addElement(tok2.nextToken());
622             }
623         }
624         return results;
625     }
626
627     /**
628      * returns the values of a session variable comma separated
629      */

630     public String JavaDoc getSetString(scanpage sp, StringTokenizer tok) {
631         sessionInfo session=getSession(sp,sp.sname);
632         if (session!=null) {
633             if (tok.hasMoreTokens()) {
634                 String JavaDoc key=tok.nextToken();
635                 String JavaDoc tmp=session.getSetString(key);
636                 if (tmp!=null) return tmp;
637                 tmp=session.getValue(key);
638                 if (tmp!=null) return tmp;
639             }
640         }
641         return "";
642     }
643
644     /**
645      * Gives the number of values contained by a certain session variable
646      * @return the number of values contained by the session variable
647      */

648     public String JavaDoc getSetCount(scanpage sp, StringTokenizer tok) {
649         sessionInfo session=getSession(sp,sp.sname);
650         if (session!=null) {
651             if (tok.hasMoreTokens()) {
652                 String JavaDoc key=tok.nextToken();
653                 String JavaDoc tmp=session.getSetCount(key);
654                 if (tmp!=null) return tmp;
655             }
656         }
657         return "0";
658     }
659
660     public int getSize() {
661         return sessions.size();
662     }
663
664      public Hashtable state() {
665         state.put("Sessions",""+getSize());
666         return state;
667      }
668
669     /**
670      * Stores visiting info (counters) in a session
671      * @deprecated-now remove in 1.7, not used
672      */

673     void setVisitInfo(sessionInfo session) {
674         String JavaDoc counter=session.getValue("SESSIONCOUNT");
675         if (counter==null) {
676             session.setValue("SESSIONCOUNT","1");
677         } else {
678             try {
679                 int icounter=Integer.parseInt(counter);
680                 session.setValue("SESSIONCOUNT",""+(icounter+1));
681             } catch (Exception JavaDoc e) {
682                 session.setValue("SESSIONCOUNT","1");
683             }
684             int time=(int)(System.currentTimeMillis()/1000);
685             int day=(time/(3600*24));
686             String JavaDoc hday=session.getValue("LASTVISIT");
687             if (hday==null || !hday.equals(""+day)) {
688                 session.setValue("LASTVISIT",""+day);
689                 saveValue(session,"LASTVISIT");
690                 String JavaDoc visits=session.getValue("VISITCOUNT");
691                 if (visits==null || visits.equals("")) {
692                     session.setValue("FIRSTVISIT",""+day);
693                     saveValue(session,"FIRSTVISIT");
694                     session.setValue("VISITCOUNT","1");
695                     saveValue(session,"VISITCOUNT");
696                 } else {
697                     try {
698                         int val=Integer.parseInt(visits);
699                         session.setValue("VISITCOUNT",""+(val+1));
700                         saveValue(session,"VISITCOUNT");
701                     } catch(Exception JavaDoc e) {}
702                 }
703             }
704         }
705     }
706
707     /**
708      * the XML reader will correct the escaped characters again.
709      * but scan will not evaluate the tags.
710      * only &lt; has to be parsed to &amp;&lt;
711      */

712     public String JavaDoc xmlEscape (String JavaDoc s) {
713         StringBuffer JavaDoc out = new StringBuffer JavaDoc();
714         int l = s.length();
715         char c;
716         for (int i = 0; i < l; i++) {
717             c = s.charAt(i);
718             switch (c) {
719                 case '<':
720                     out.append("&lt;");
721                     break;
722                 case '>':
723                     out.append("&gt;");
724                     break;
725                 case '&':
726                     out.append("&amp;");
727                     break;
728                 default:
729                     out.append(c);
730             }
731         }
732         return out.toString();
733     }
734 }
735
Popular Tags