validator-rules.xml
001 <!DOCTYPE form-validation PUBLIC
002           "-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0//EN"
003           "http://jakarta.apache.org/commons/dtds/validator_1_0.dtd">
004 <!--
005 
006    This file contains the default Struts Validator pluggable validator
007    definitions.  It should be placed somewhere under /WEB-INF and
008    referenced in the struts-config.xml under the plug-in element
009    for the ValidatorPlugIn.
010 
011       <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
012         <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,
013                                                   /WEB-INF/validation.xml"/>
014       </plug-in>
015 
016    These are the default error messages associated with
017    each validator defined in this file.  They should be
018    added to your projects ApplicationResources.properties
019    file or you can associate new ones by modifying the
020    pluggable validators msg attributes in this file.
021 
022    # Struts Validator Error Messages
023    errors.required={0is required.
024    errors.minlength={0can not be less than {1characters.
025    errors.maxlength={0can not be greater than {1characters.
026    errors.invalid={0is invalid.
027 
028    errors.byte={0must be a byte.
029    errors.short={0must be a short.
030    errors.integer={0must be an integer.
031    errors.long={0must be a long.
032    errors.float={0must be a float.
033    errors.double={0must be a double.
034 
035    errors.date={0is not a date.
036    errors.range={0is not in the range {1through {2}.
037    errors.creditcard={0is an invalid credit card number.
038    errors.email={0is an invalid e-mail address.
039 
040 -->
041 
042 <form-validation>
043 
044    <global>
045      <validator name="twofields"
046            classname="com.bea.medrec.utils.StrutsValidator"
047               method="validateTwoFields"
048         methodParams="java.lang.Object,
049                       org.apache.commons.validator.ValidatorAction,
050                       org.apache.commons.validator.Field,
051                       org.apache.struts.action.ActionErrors,
052                       javax.servlet.http.HttpServletRequest"       
053                  msg="errors.twofields"/>
054 
055       <validator name="required"
056             classname="org.apache.struts.validator.FieldChecks"
057                method="validateRequired"
058          methodParams="java.lang.Object,
059                        org.apache.commons.validator.ValidatorAction,
060                        org.apache.commons.validator.Field,
061                        org.apache.struts.action.ActionErrors,
062                        javax.servlet.http.HttpServletRequest"
063                   msg="errors.required">
064 
065          <javascript><![CDATA[
066             function validateRequired(form) {
067                 var bValid = true;
068                 var focusField = null;
069                 var i = 0;
070                 var fields = new Array();
071                 oRequired = new required();
072                 for (x in oRequired) {
073                   var field = form[oRequired[x][0]];
074                   
075                     if (field.type == 'text' ||
076                         field.type == 'textarea' ||
077                         field.type == 'file' ||
078                         field.type == 'select-one' ||
079                         field.type == 'radio' ||
080                         field.type == 'password') {
081                         
082                         var value = '';
083             // get field's value
084             if (field.type == "select-one") {
085               var si = field.selectedIndex;
086               if (si >= 0) {
087                 value = field.options[si].value;
088               }
089             else {
090               value = field.value;
091             }
092                         
093                         if (value == '') {
094                         
095                           if (i == 0) {
096                               focusField = field;
097                           }
098                           fields[i++= oRequired[x][1];
099                           bValid = false;
100                         }
101                     }
102                 }
103                 if (fields.length > 0) {
104                    focusField.focus();
105                    alert(fields.join('\n'));
106                 }
107                 return bValid;
108             }]]>
109          </javascript>
110 
111       </validator>
112 
113       <validator name="requiredif"
114                  classname="org.apache.struts.validator.FieldChecks"
115                  method="validateRequiredIf"
116                  methodParams="java.lang.Object,
117                                org.apache.commons.validator.ValidatorAction,
118                                org.apache.commons.validator.Field,
119                                org.apache.struts.action.ActionErrors,
120                                org.apache.commons.validator.Validator,
121                                javax.servlet.http.HttpServletRequest"
122                  msg="errors.required">
123       </validator>
124 
125       <validator name="minlength"
126             classname="org.apache.struts.validator.FieldChecks"
127                method="validateMinLength"
128          methodParams="java.lang.Object,
129                        org.apache.commons.validator.ValidatorAction,
130                        org.apache.commons.validator.Field,
131                        org.apache.struts.action.ActionErrors,
132                        javax.servlet.http.HttpServletRequest"
133               depends=""
134                   msg="errors.minlength">
135 
136          <javascript><![CDATA[
137             function validateMinLength(form) {
138                 var bValid = true;
139                 var focusField = null;
140                 var i = 0;
141                 var fields = new Array();
142                 oMinLength = new minlength();
143                 for (x in oMinLength) {
144                     if (form[oMinLength[x][0]].type == 'text' ||
145                         form[oMinLength[x][0]].type == 'textarea') {
146                         var iMin = parseInt(oMinLength[x][2]("minlength"));
147                         if (form[oMinLength[x][0]].value.length < iMin) {
148                             if (i == 0) {
149                                 focusField = form[oMinLength[x][0]];
150                             }
151                             fields[i++= oMinLength[x][1];
152                             bValid = false;
153                         }
154                     }
155                 }
156                 if (fields.length > 0) {
157                    focusField.focus();
158                    alert(fields.join('\n'));
159                 }
160                 return bValid;
161             }]]>
162          </javascript>
163 
164       </validator>
165 
166 
167       <validator name="maxlength"
168             classname="org.apache.struts.validator.FieldChecks"
169                method="validateMaxLength"
170          methodParams="java.lang.Object,
171                        org.apache.commons.validator.ValidatorAction,
172                        org.apache.commons.validator.Field,
173                        org.apache.struts.action.ActionErrors,
174                        javax.servlet.http.HttpServletRequest"
175               depends=""
176                   msg="errors.maxlength">
177 
178          <javascript><![CDATA[
179             function validateMaxLength(form) {
180                 var bValid = true;
181                 var focusField = null;
182                 var i = 0;
183                 var fields = new Array();
184                 oMaxLength = new maxlength();
185                 for (x in oMaxLength) {
186                     if (form[oMaxLength[x][0]].type == 'text' ||
187                         form[oMaxLength[x][0]].type == 'textarea') {
188                         var iMax = parseInt(oMaxLength[x][2]("maxlength"));
189                         if (form[oMaxLength[x][0]].value.length > iMax) {
190                             if (i == 0) {
191                                 focusField = form[oMaxLength[x][0]];
192                             }
193                             fields[i++= oMaxLength[x][1];
194                             bValid = false;
195                         }
196                     }
197                 }
198                 if (fields.length > 0) {
199                    focusField.focus();
200                    alert(fields.join('\n'));
201                 }
202                 return bValid;
203             }]]>
204          </javascript>
205 
206       </validator>
207 
208 
209       <validator name="mask"
210             classname="org.apache.struts.validator.FieldChecks"
211                method="validateMask"
212          methodParams="java.lang.Object,
213                        org.apache.commons.validator.ValidatorAction,
214                        org.apache.commons.validator.Field,
215                        org.apache.struts.action.ActionErrors,
216                        javax.servlet.http.HttpServletRequest"
217               depends=""
218                   msg="errors.invalid">
219 
220          <javascript><![CDATA[
221             function validateMask(form) {
222                 var bValid = true;
223                 var focusField = null;
224                 var i = 0;
225                 var fields = new Array();
226                 oMasked = new mask();
227                 for (x in oMasked) {
228                     if ((form[oMasked[x][0]].type == 'text' ||
229                          form[oMasked[x][0]].type == 'textarea' ||
230                          form[oMasked[x][0]].type == 'password') &&
231                         (form[oMasked[x][0]].value.length > 0)) {
232                         if (!matchPattern(form[oMasked[x][0]].value, oMasked[x][2]("mask"))) {
233                             if (i == 0) {
234                                 focusField = form[oMasked[x][0]];
235                             }
236                             fields[i++= oMasked[x][1];
237                             bValid = false;
238                         }
239                     }
240                 }
241                 if (fields.length > 0) {
242                    focusField.focus();
243                    alert(fields.join('\n'));
244                 }
245                 return bValid;
246             }
247 
248             function matchPattern(value, mask) {
249                var bMatched = mask.exec(value);
250                if (!bMatched) {
251                    return false;
252                }
253                return true;
254             }]]>
255          </javascript>
256 
257       </validator>
258 
259 
260       <validator name="byte"
261             classname="org.apache.struts.validator.FieldChecks"
262                method="validateByte"
263          methodParams="java.lang.Object,
264                        org.apache.commons.validator.ValidatorAction,
265                        org.apache.commons.validator.Field,
266                        org.apache.struts.action.ActionErrors,
267                        javax.servlet.http.HttpServletRequest"
268               depends=""
269                   msg="errors.byte"
270        jsFunctionName="ByteValidations">
271 
272          <javascript><![CDATA[
273             function validateByte(form) {
274                 var bValid = true;
275                 var focusField = null;
276                 var i = 0;
277                 var fields = new Array();
278                 oByte = new ByteValidations();
279                 for (x in oByte) {
280                   var field = form[oByte[x][0]];
281                   
282                     if (field.type == 'text' ||
283                         field.type == 'textarea' ||
284                         field.type == 'select-one' ||
285             field.type == 'radio') {
286 
287             var value = '';
288             // get field's value
289             if (field.type == "select-one") {
290               var si = field.selectedIndex;
291               if (si >= 0) {
292                 value = field.options[si].value;
293               }
294             else {
295               value = field.value;
296             }
297                         
298                         if (value.length > 0) {
299 
300                           var iValue = parseInt(value);
301                           if (isNaN(iValue|| !(iValue >= -128 && iValue <= 127)) {
302                               if (i == 0) {
303                                   focusField = field;
304                               }
305                               fields[i++= oByte[x][1];
306                               bValid = false;
307                           }
308             }
309             
310                     }
311                 }
312                 if (fields.length > 0) {
313                    focusField.focus();
314                    alert(fields.join('\n'));
315                 }
316                 return bValid;
317             }]]>
318          </javascript>
319 
320       </validator>
321 
322 
323       <validator name="short"
324             classname="org.apache.struts.validator.FieldChecks"
325                method="validateShort"
326          methodParams="java.lang.Object,
327                        org.apache.commons.validator.ValidatorAction,
328                        org.apache.commons.validator.Field,
329                        org.apache.struts.action.ActionErrors,
330                        javax.servlet.http.HttpServletRequest"
331               depends=""
332                   msg="errors.short"
333        jsFunctionName="ShortValidations">
334 
335          <javascript><![CDATA[
336             function validateShort(form) {
337                 var bValid = true;
338                 var focusField = null;
339                 var i = 0;
340                 var fields = new Array();
341                 oShort = new ShortValidations();
342                 for (x in oShort) {
343                   var field = form[oShort[x][0]];
344                   
345                     if (field.type == 'text' ||
346                         field.type == 'textarea' ||
347                         field.type == 'select-one' ||
348                         field.type == 'radio') {
349                         
350                         var value = '';
351             // get field's value
352             if (field.type == "select-one") {
353               var si = field.selectedIndex;
354               if (si >= 0) {
355                 value = field.options[si].value;
356               }
357             else {
358               value = field.value;
359             }
360                         
361                         if (value.length > 0) {
362                         
363                           var iValue = parseInt(value);
364                           if (isNaN(iValue|| !(iValue >= -32768 && iValue <= 32767)) {
365                               if (i == 0) {
366                                   focusField = field;
367                               }
368                               fields[i++= oShort[x][1];
369                               bValid = false;
370                          }
371                        }
372                     }
373                 }
374                 if (fields.length > 0) {
375                    focusField.focus();
376                    alert(fields.join('\n'));
377                 }
378                 return bValid;
379             }]]>
380          </javascript>
381 
382       </validator>
383 
384 
385       <validator name="integer"
386             classname="org.apache.struts.validator.FieldChecks"
387                method="validateInteger"
388          methodParams="java.lang.Object,
389                        org.apache.commons.validator.ValidatorAction,
390                        org.apache.commons.validator.Field,
391                        org.apache.struts.action.ActionErrors,
392                        javax.servlet.http.HttpServletRequest"
393               depends=""
394                   msg="errors.integer"
395        jsFunctionName="IntegerValidations">
396 
397          <javascript><![CDATA[
398             function validateInteger(form) {
399                 var bValid = true;
400                 var focusField = null;
401                 var i = 0;
402                 var fields = new Array();
403                 oInteger = new IntegerValidations();
404                 for (x in oInteger) {
405                   var field = form[oInteger[x][0]];
406 
407                     if (field.type == 'text' ||
408                         field.type == 'textarea' ||
409                         field.type == 'select-one' ||
410                         field.type == 'radio') {
411                         
412                         var value = '';
413             // get field's value
414             if (field.type == "select-one") {
415               var si = field.selectedIndex;
416                 if (si >= 0) {
417                   value = field.options[si].value;
418                 }
419             else {
420               value = field.value;
421             }
422                         
423                         if (value.length > 0) {
424                         
425                             if (!isAllDigits(value)) {
426                                 bValid = false;
427                             else {
428                               var iValue = parseInt(value);
429                               if (isNaN(iValue|| !(iValue >= -2147483648 && iValue <= 2147483647)) {
430                                   if (i == 0) {
431                                       focusField = field;
432                                   }
433                                   fields[i++= oInteger[x][1];
434                                   bValid = false;
435                              }
436                            }
437                        }
438                     }
439                 }
440                 if (fields.length > 0) {
441                    focusField.focus();
442                    alert(fields.join('\n'));
443                 }
444                 return bValid;
445             }
446 
447             function isAllDigits(argvalue) {
448                 argvalue = argvalue.toString();
449                 var validChars = "0123456789";
450                 var startFrom = 0;
451                 if (argvalue.substring(02== "0x") {
452                    validChars = "0123456789abcdefABCDEF";
453                    startFrom = 2;
454                 else if (argvalue.charAt(0== "0") {
455                    validChars = "01234567";
456                    startFrom = 1;
457                 }
458                 for (var n = 0; n < argvalue.length; n++) {
459                     if (validChars.indexOf(argvalue.substring(n, n+1)) == -1return false;
460                 }
461                 return true;
462             }]]>
463          </javascript>
464 
465       </validator>
466 
467 
468       <validator name="long"
469             classname="org.apache.struts.validator.FieldChecks"
470                method="validateLong"
471          methodParams="java.lang.Object,
472                        org.apache.commons.validator.ValidatorAction,
473                        org.apache.commons.validator.Field,
474                        org.apache.struts.action.ActionErrors,
475                        javax.servlet.http.HttpServletRequest"
476               depends=""
477                   msg="errors.long"/>
478 
479 
480       <validator name="float"
481             classname="org.apache.struts.validator.FieldChecks"
482                method="validateFloat"
483          methodParams="java.lang.Object,
484                        org.apache.commons.validator.ValidatorAction,
485                        org.apache.commons.validator.Field,
486                        org.apache.struts.action.ActionErrors,
487                        javax.servlet.http.HttpServletRequest"
488               depends=""
489                   msg="errors.float"
490        jsFunctionName="FloatValidations">
491 
492          <javascript><![CDATA[
493             function validateFloat(form) {
494                 var bValid = true;
495                 var focusField = null;
496                 var i = 0;
497                 var fields = new Array();
498                 oFloat = new FloatValidations();
499                 for (x in oFloat) {
500                   var field = form[oFloat[x][0]];
501                   
502                     if (field.type == 'text' ||
503                         field.type == 'textarea' ||
504                         field.type == 'select-one' ||
505                         field.type == 'radio') {
506                         
507                       var value = '';
508             // get field's value
509             if (field.type == "select-one") {
510               var si = field.selectedIndex;
511               if (si >= 0) {
512                   value = field.options[si].value;
513               }
514             else {
515               value = field.value;
516             }
517                         
518                         if (value.length > 0) {
519                         
520                           var iValue = parseFloat(value);
521                           if (isNaN(iValue)) {
522                               if (i == 0) {
523                                   focusField = field;
524                               }
525                               fields[i++= oFloat[x][1];
526                               bValid = false;
527                           }
528                         }
529                     }
530                 }
531                 if (fields.length > 0) {
532                    focusField.focus();
533                    alert(fields.join('\n'));
534                 }
535                 return bValid;
536             }]]>
537          </javascript>
538 
539       </validator>
540 
541 
542       <validator name="double"
543             classname="org.apache.struts.validator.FieldChecks"
544                method="validateDouble"
545          methodParams="java.lang.Object,
546                        org.apache.commons.validator.ValidatorAction,
547                        org.apache.commons.validator.Field,
548                        org.apache.struts.action.ActionErrors,
549                        javax.servlet.http.HttpServletRequest"
550               depends=""
551                   msg="errors.double"/>
552 
553 
554       <validator name="date"
555             classname="org.apache.struts.validator.FieldChecks"
556                method="validateDate"
557          methodParams="java.lang.Object,
558                        org.apache.commons.validator.ValidatorAction,
559                        org.apache.commons.validator.Field,
560                        org.apache.struts.action.ActionErrors,
561                        javax.servlet.http.HttpServletRequest"
562               depends=""
563                   msg="errors.date"
564        jsFunctionName="DateValidations">
565 
566          <javascript><![CDATA[
567             function validateDate(form) {
568                var bValid = true;
569                var focusField = null;
570                var i = 0;
571                var fields = new Array();
572                oDate = new DateValidations();
573                for (x in oDate) {
574                    var value = form[oDate[x][0]].value;
575                    var datePattern = oDate[x][2]("datePatternStrict");
576                    if ((form[oDate[x][0]].type == 'text' ||
577                         form[oDate[x][0]].type == 'textarea') &&
578                        (value.length > 0&&
579                        (datePattern.length > 0)) {
580                      var MONTH = "MM";
581                      var DAY = "dd";
582                      var YEAR = "yyyy";
583                      var orderMonth = datePattern.indexOf(MONTH);
584                      var orderDay = datePattern.indexOf(DAY);
585                      var orderYear = datePattern.indexOf(YEAR);
586                      if ((orderDay < orderYear && orderDay > orderMonth)) {
587                          var iDelim1 = orderMonth + MONTH.length;
588                          var iDelim2 = orderDay + DAY.length;
589                          var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
590                          var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
591                          if (iDelim1 == orderDay && iDelim2 == orderYear) {
592                             dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
593                          else if (iDelim1 == orderDay) {
594                             dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
595                          else if (iDelim2 == orderYear) {
596                             dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
597                          else {
598                             dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
599                          }
600                          var matched = dateRegexp.exec(value);
601                          if(matched != null) {
602                             if (!isValidDate(matched[2], matched[1], matched[3])) {
603                                if (i == 0) {
604                                    focusField = form[oDate[x][0]];
605                                }
606                                fields[i++= oDate[x][1];
607                                bValid =  false;
608                             }
609                          else {
610                             if (i == 0) {
611                                 focusField = form[oDate[x][0]];
612                             }
613                             fields[i++= oDate[x][1];
614                             bValid =  false;
615                          }
616                      else if ((orderMonth < orderYear && orderMonth > orderDay)) {
617                          var iDelim1 = orderDay + DAY.length;
618                          var iDelim2 = orderMonth + MONTH.length;
619                          var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
620                          var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
621                          if (iDelim1 == orderMonth && iDelim2 == orderYear) {
622                              dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
623                          else if (iDelim1 == orderMonth) {
624                              dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
625                          else if (iDelim2 == orderYear) {
626                              dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
627                          else {
628                              dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
629                          }
630                          var matched = dateRegexp.exec(value);
631                          if(matched != null) {
632                              if (!isValidDate(matched[1], matched[2], matched[3])) {
633                                  if (i == 0) {
634                                      focusField = form[oDate[x][0]];
635                                  }
636                                  fields[i++= oDate[x][1];
637                                  bValid =  false;
638                               }
639                          else {
640                              if (i == 0) {
641                                  focusField = form[oDate[x][0]];
642                              }
643                              fields[i++= oDate[x][1];
644                              bValid =  false;
645                          }
646                      else if ((orderMonth > orderYear && orderMonth < orderDay)) {
647                          var iDelim1 = orderYear + YEAR.length;
648                          var iDelim2 = orderMonth + MONTH.length;
649                          var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
650                          var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
651                          if (iDelim1 == orderMonth && iDelim2 == orderDay) {
652                              dateRegexp = new RegExp("^(\\d{4})(\\d{2})(\\d{2})$");
653                          else if (iDelim1 == orderMonth) {
654                              dateRegexp = new RegExp("^(\\d{4})(\\d{2})[" + delim2 + "](\\d{2})$");
655                          else if (iDelim2 == orderDay) {
656                              dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})(\\d{2})$");
657                          else {
658                              dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{2})$");
659                          }
660                          var matched = dateRegexp.exec(value);
661                          if(matched != null) {
662                              if (!isValidDate(matched[3], matched[2], matched[1])) {
663                                  if (i == 0) {
664                                      focusField = form[oDate[x][0]];
665                                   }
666                                   fields[i++= oDate[x][1];
667                                   bValid =  false;
668                               }
669                           else {
670                               if (i == 0) {
671                                   focusField = form[oDate[x][0]];
672                               }
673                               fields[i++= oDate[x][1];
674                               bValid =  false;
675                           }
676                      else {
677                          if (i == 0) {
678                              focusField = form[oDate[x][0]];
679                          }
680                          fields[i++= oDate[x][1];
681                          bValid =  false;
682                      }
683                   }
684                }
685                if (fields.length > 0) {
686                   focusField.focus();
687                   alert(fields.join('\n'));
688                }
689                return bValid;
690             }
691 
692       function isValidDate(day, month, year) {
693           if (month < || month > 12) {
694                     return false;
695                 }
696                 if (day < || day > 31) {
697                     return false;
698                 }
699                 if ((month == || month == || month == || month == 11&&
700                     (day == 31)) {
701                     return false;
702                 }
703                 if (month == 2) {
704                     var leap = (year % == &&
705                                (year % 100 != || year % 400 == 0));
706                     if (day>29 || (day == 29 && !leap)) {
707                         return false;
708                     }
709                 }
710                 return true;
711             }]]>
712          </javascript>
713 
714       </validator>
715 
716 <!-- range is deprecated use intRange instead -->
717       <validator name="range"
718             classname="org.apache.struts.validator.FieldChecks"
719                method="validateIntRange"
720          methodParams="java.lang.Object,
721                        org.apache.commons.validator.ValidatorAction,
722                        org.apache.commons.validator.Field,
723                        org.apache.struts.action.ActionErrors,
724                        javax.servlet.http.HttpServletRequest"
725               depends="integer"
726                   msg="errors.range">
727 
728          <javascript><![CDATA[
729             function validateRange(form) {
730                 return validateIntRange(form);
731             }]]>
732          </javascript>
733 
734       </validator>
735 
736       <validator name="intRange"
737             classname="org.apache.struts.validator.FieldChecks"
738                method="validateIntRange"
739          methodParams="java.lang.Object,
740                        org.apache.commons.validator.ValidatorAction,
741                        org.apache.commons.validator.Field,
742                        org.apache.struts.action.ActionErrors,
743                        javax.servlet.http.HttpServletRequest"
744               depends="integer"
745                   msg="errors.range">
746 
747          <javascript><![CDATA[
748             function validateIntRange(form) {
749                 var bValid = true;
750                 var focusField = null;
751                 var i = 0;
752                 var fields = new Array();
753                 oRange = new intRange();
754                 for (x in oRange) {
755                     if ((form[oRange[x][0]].type == 'text' ||
756                          form[oRange[x][0]].type == 'textarea') &&
757                         (form[oRange[x][0]].value.length > 0)) {
758                         var iMin = parseInt(oRange[x][2]("min"));
759                         var iMax = parseInt(oRange[x][2]("max"));
760                         var iValue = parseInt(form[oRange[x][0]].value);
761                         if (!(iValue >= iMin && iValue <= iMax)) {
762                             if (i == 0) {
763                                 focusField = form[oRange[x][0]];
764                             }
765                             fields[i++= oRange[x][1];
766                             bValid = false;
767                         }
768                     }
769                 }
770                 if (fields.length > 0) {
771                     focusField.focus();
772                     alert(fields.join('\n'));
773                 }
774                 return bValid;
775             }]]>
776          </javascript>
777 
778       </validator>
779 
780       <validator name="floatRange"
781             classname="org.apache.struts.validator.FieldChecks"
782                method="validateFloatRange"
783          methodParams="java.lang.Object,
784                        org.apache.commons.validator.ValidatorAction,
785                        org.apache.commons.validator.Field,
786                        org.apache.struts.action.ActionErrors,
787                        javax.servlet.http.HttpServletRequest"
788               depends="float"
789                   msg="errors.range">
790 
791          <javascript><![CDATA[
792             function validateFloatRange(form) {
793                 var bValid = true;
794                 var focusField = null;
795                 var i = 0;
796                 var fields = new Array();
797                 oRange = new floatRange();
798                 for (x in oRange) {
799                     if ((form[oRange[x][0]].type == 'text' ||
800                          form[oRange[x][0]].type == 'textarea') &&
801                         (form[oRange[x][0]].value.length > 0)) {
802                         var fMin = parseFloat(oRange[x][2]("min"));
803                         var fMax = parseFloat(oRange[x][2]("max"));
804                         var fValue = parseFloat(form[oRange[x][0]].value);
805                         if (!(fValue >= fMin && fValue <= fMax)) {
806                             if (i == 0) {
807                                 focusField = form[oRange[x][0]];
808                             }
809                             fields[i++= oRange[x][1];
810                             bValid = false;
811                         }
812                     }
813                 }
814                 if (fields.length > 0) {
815                     focusField.focus();
816                     alert(fields.join('\n'));
817                 }
818                 return bValid;
819             }]]>
820          </javascript>
821 
822       </validator>
823 
824       <validator name="creditCard"
825             classname="org.apache.struts.validator.FieldChecks"
826                method="validateCreditCard"
827          methodParams="java.lang.Object,
828                        org.apache.commons.validator.ValidatorAction,
829                        org.apache.commons.validator.Field,
830                        org.apache.struts.action.ActionErrors,
831                        javax.servlet.http.HttpServletRequest"
832               depends=""
833                   msg="errors.creditcard">
834 
835          <javascript><![CDATA[
836             function validateCreditCard(form) {
837                 var bValid = true;
838                 var focusField = null;
839                 var i = 0;
840                 var fields = new Array();
841                 oCreditCard = new creditCard();
842                 for (x in oCreditCard) {
843                     if ((form[oCreditCard[x][0]].type == 'text' ||
844                          form[oCreditCard[x][0]].type == 'textarea') &&
845                         (form[oCreditCard[x][0]].value.length > 0)) {
846                         if (!luhnCheck(form[oCreditCard[x][0]].value)) {
847                             if (i == 0) {
848                                 focusField = form[oCreditCard[x][0]];
849                             }
850                             fields[i++= oCreditCard[x][1];
851                             bValid = false;
852                         }
853                     }
854                 }
855                 if (fields.length > 0) {
856                     focusField.focus();
857                     alert(fields.join('\n'));
858                 }
859                 return bValid;
860             }
861 
862             /**
863              * Reference: http://www.ling.nwu.edu/~sburke/pub/luhn_lib.pl
864              */
865             function luhnCheck(cardNumber) {
866                 if (isLuhnNum(cardNumber)) {
867                     var no_digit = cardNumber.length;
868                     var oddoeven = no_digit & 1;
869                     var sum = 0;
870                     for (var count = 0; count < no_digit; count++) {
871                         var digit = parseInt(cardNumber.charAt(count));
872                         if (!((count & 1^ oddoeven)) {
873                             digit *= 2;
874                             if (digit > 9digit -= 9;
875                         };
876                         sum += digit;
877                     };
878                     if (sum == 0return false;
879                     if (sum % 10 == 0return true;
880                 };
881                 return false;
882             }
883 
884             function isLuhnNum(argvalue) {
885                 argvalue = argvalue.toString();
886                 if (argvalue.length == 0) {
887                     return false;
888                 }
889                 for (var n = 0; n < argvalue.length; n++) {
890                     if ((argvalue.substring(n, n+1"0"||
891                         (argvalue.substring(n,n+1"9")) {
892                         return false;
893                     }
894                 }
895                 return true;
896             }]]>
897          </javascript>
898 
899       </validator>
900 
901 
902       <validator name="email"
903             classname="org.apache.struts.validator.FieldChecks"
904                method="validateEmail"
905          methodParams="java.lang.Object,
906                        org.apache.commons.validator.ValidatorAction,
907                        org.apache.commons.validator.Field,
908                        org.apache.struts.action.ActionErrors,
909                        javax.servlet.http.HttpServletRequest"
910               depends=""
911                   msg="errors.email">
912 
913          <javascript><![CDATA[
914             function validateEmail(form) {
915                 var bValid = true;
916                 var focusField = null;
917                 var i = 0;
918                 var fields = new Array();
919                 oEmail = new email();
920                 for (x in oEmail) {
921                     if ((form[oEmail[x][0]].type == 'text' ||
922                          form[oEmail[x][0]].type == 'textarea') &&
923                         (form[oEmail[x][0]].value.length > 0)) {
924                         if (!checkEmail(form[oEmail[x][0]].value)) {
925                             if (i == 0) {
926                                 focusField = form[oEmail[x][0]];
927                             }
928                             fields[i++= oEmail[x][1];
929                             bValid = false;
930                         }
931                     }
932                 }
933                 if (fields.length > 0) {
934                     focusField.focus();
935                     alert(fields.join('\n'));
936                 }
937                 return bValid;
938             }
939 
940             /**
941              * Reference: Sandeep V. Tamhankar (stamhankar@hotmail.com),
942              * http://javascript.internet.com
943              */
944             function checkEmail(emailStr) {
945                if (emailStr.length == 0) {
946                    return true;
947                }
948                var emailPat=/^(.+)@(.+)$/;
949                var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]";
950                var validChars="\[^\\s" + specialChars + "\]";
951                var quotedUser="(\"[^\"]*\")";
952                var ipDomainPat=/^(\d{1,3})[.](\d{1,3})[.](\d{1,3})[.](\d{1,3})$/;
953                var atom=validChars + '+';
954                var word="(" + atom + "|" + quotedUser + ")";
955                var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
956                var domainPat=new RegExp("^" + atom + "(\\." + atom + ")*$");
957                var matchArray=emailStr.match(emailPat);
958                if (matchArray == null) {
959                    return false;
960                }
961                var user=matchArray[1];
962                var domain=matchArray[2];
963                if (user.match(userPat== null) {
964                    return false;
965                }
966                var IPArray = domain.match(ipDomainPat);
967                if (IPArray != null) {
968                    for (var i = 1; i <= 4; i++) {
969                       if (IPArray[i255) {
970                          return false;
971                       }
972                    }
973                    return true;
974                }
975                var domainArray=domain.match(domainPat);
976                if (domainArray == null) {
977                    return false;
978                }
979                var atomPat=new RegExp(atom,"g");
980                var domArr=domain.match(atomPat);
981                var len=domArr.length;
982                if ((domArr[domArr.length-1].length < 2||
983                    (domArr[domArr.length-1].length > 3)) {
984                    return false;
985                }
986                if (len < 2) {
987                    return false;
988                }
989                return true;
990             }]]>
991          </javascript>
992 
993       </validator>
994 
995    </global>
996 
997 </form-validation>