001 // Copyright (c) 2001 Hursh Jain (http://www.mollypages.org) 002 // The Molly framework is freely distributable under the terms of an 003 // MIT-style license. For details, see the molly pages web site at: 004 // http://www.mollypages.org/. Use, modify, have fun ! 005 006 package fc.web.simpleforms; 007 008 import javax.servlet.*; 009 import javax.servlet.http.*; 010 import java.io.*; 011 import java.util.*; 012 import java.util.regex.*; 013 014 import fc.jdbc.*; 015 import fc.io.*; 016 import fc.util.*; 017 018 /** 019 Utility methods for common validation needs. 020 021 @author hursh jain 022 **/ 023 public final class Valid 024 { 025 final static boolean dbg = false; //internal debugging 026 static boolean trim = true; 027 private static final String intOnlyRE_str = "\\s*\\d*\\s*"; 028 private static final Pattern intOnlyRE = Pattern.compile(intOnlyRE_str); 029 private static final String isFloatOnlyRE_str = "\\s*-?\\d*\\.?\\d*\\s*"; 030 private static final Pattern isFloatOnlyRE = Pattern.compile(isFloatOnlyRE_str); 031 032 /** 033 If set to <tt>true</tt>, methods in this class will trim the string 034 entered by the user before attempting to run further validation on it, 035 else strings will not be trimmed automatically. Defaults to 036 <tt>true</tt>. 037 */ 038 public static void setTrimSpaces(boolean val) 039 { 040 trim = val; 041 } 042 043 /** 044 Ensures that the string is composed of only an digits [0-9] with 045 optional leading/trailing blanks. (floating point/real numbers are 046 not allowed because they contain a ".") 047 */ 048 public static boolean isIntegerOnly(String str) 049 { 050 if (str == null) 051 return false; 052 053 if (trim) { 054 str = str.trim(); 055 } 056 057 return intOnlyRE.matcher(str).matches(); 058 } 059 060 /** 061 Ensures that the string is composed of only floating point 062 numbers (digits [0-9] and maybe a "."), with optional 063 leading/trailing blanks. Negative numbers (with a leading "-") 064 are also allowed. 065 */ 066 public static boolean isFloatOnly(String str) 067 { 068 if (str == null) 069 return false; 070 071 if (trim) { 072 str = str.trim(); 073 } 074 075 return isFloatOnlyRE.matcher(str).matches(); 076 } 077 078 079 public static boolean isEmpty(String str) 080 { 081 if (str == null) { 082 return false; 083 } 084 085 if (trim) { 086 str = str.trim(); 087 } 088 089 if (str.length() == 0) { 090 return true; 091 } 092 093 return false; 094 } 095 096 /** 097 Returns <tt>true</tt> is the specified string is not <tt>null</tt> <b>and</b> 098 not empty (<tt>""</tt>). 099 */ 100 public static boolean isNotEmpty(String str) 101 { 102 if (str == null) { 103 return false; 104 } 105 106 if (trim) { 107 str = str.trim(); 108 } 109 110 if (str.length() == 0) { 111 return false; 112 } 113 114 return true; 115 } 116 117 /** 118 Returns true if the string is non-empty and it's length 119 is between the specified min and max lengths (both inclusive). 120 */ 121 public static boolean length(String str, final int min, final int max) 122 { 123 if (str == null) { 124 return false; 125 } 126 127 if (trim) { 128 str = str.trim(); 129 } 130 131 final int len = str.length(); 132 if (len < min || len > max) { 133 return false; 134 } 135 136 return true; 137 } 138 139 /** 140 Returns <tt>true</tt> if the specified string only contains the 141 allowed characters. If the string contains any other characters 142 that are not allowed, returns <tt>false</tt> 143 */ 144 public static boolean isAllowed(String str, final String allowedChars) 145 { 146 if (str == null) 147 return false; 148 149 if (trim) { 150 str = str.trim(); 151 } 152 153 for (int n = 0; n < str.length(); n++) 154 { 155 char c = str.charAt(n); 156 boolean found = false; 157 for (int k = 0; k < allowedChars.length(); k++) 158 { 159 char mchar = allowedChars.charAt(k); 160 if (c == mchar) { 161 found = true; 162 } 163 } 164 if (! found) { 165 return false; 166 } 167 } 168 169 return true; 170 } 171 172 /** 173 Returns <tt>true</tt> if the specified string has no unallowed 174 characters. If the string contains any unallowed characters, returns 175 <tt>false</tt> 176 */ 177 public static boolean isNotAllowed(String str, final String unallowedChars) 178 { 179 if (str == null) 180 return false; 181 182 if (trim) { 183 str = str.trim(); 184 } 185 186 for (int n = 0; n < str.length(); n++) 187 { 188 char c = str.charAt(n); 189 boolean passed = true; 190 for (int k = 0; k < unallowedChars.length(); k++) 191 { 192 char mchar = unallowedChars.charAt(k); 193 if (c == mchar) { 194 passed = false; 195 } 196 } 197 if (! passed) { 198 return false; 199 } 200 } 201 202 return true; 203 } 204 205 public static void main (String args[]) 206 { 207 p("Valid.isIntegerOnly(\" 3243 \")", Valid.isIntegerOnly(" 3243 "), true ); //trim 208 p("Valid.isIntegerOnly(\" 3243. \")", Valid.isIntegerOnly(" 3243. "), false ); 209 210 p( "Valid.isFloatOnly(\" 3243. \")", Valid.isFloatOnly(" 3243. "), true ); 211 p( "Valid.isFloatOnly(\" -3243. \")", Valid.isFloatOnly(" -3243. "), true ); 212 p( "Valid.isFloatOnly(\" -3243.003 \")", Valid.isFloatOnly(" -3243.003 "), true ); 213 p( "Valid.isFloatOnly(\".3243.0\")", Valid.isFloatOnly(".3243.0"), false ); 214 p( "Valid.isFloatOnly(\"-32dd43.003\")", Valid.isFloatOnly("-32dd43.003"), false ); 215 216 p( "Valid.isEmpty(\" \")", Valid.isEmpty(" "), true); //if trim 217 p( "Valid.isEmpty(\"\")", Valid.isEmpty(""), true); 218 219 p( "Valid.length(\" abc \", 1, 3)", Valid.length(" abc ", 1, 3), true ); //trim 220 Valid.setTrimSpaces(false); 221 p( "Valid.length(\" abc \", 1, 3)", Valid.length(" abc ", 1, 3), false ); 222 Valid.setTrimSpaces(true); 223 224 p( "Valid.isAllowed\"abc\", \"abc\")", Valid.isAllowed("abc", "abc"), true ); 225 p( "Valid.isAllowed(\"abc\", \"abcdef\")", Valid.isAllowed("abc", "abcdef"), true ); 226 p( "Valid.isAllowed(\"abc\", \"ab\")", Valid.isAllowed("abc", "ab"), false ); 227 p( "Valid.isAllowed(\"abc\", \"\")", Valid.isAllowed("abc", ""), false ); 228 229 p( "Valid.isNotAllowed(\"abc\", \"4\")", Valid.isNotAllowed("abc", "4"), true ); 230 p( "Valid.isNotAllowed(\"abc\", \"#!@9\")", Valid.isNotAllowed("abc", "#!@9"), true ); 231 p( "Valid.isNotAllowed(\"abc4\", \"\")", Valid.isNotAllowed("abc4", ""), true ); 232 p( "Valid.isNotAllowed(\"abc4\", \"a\")", Valid.isNotAllowed("abc4", "a"), false ); 233 234 if (_badcount == 0) 235 System.out.println("All internal tests were successful.."); 236 else 237 System.out.println(_badcount + " tests failed.."); 238 } 239 240 private static int _badcount = 0; 241 private static void p(String s, boolean a, boolean b) 242 { 243 if (a != b) { 244 _badcount++; 245 System.out.println("FAILED: " + s); 246 } 247 } 248 } //~class Valid