Coverage Report

Coverage Report - org.kuali.rice.krad.datadictionary.validation.constraint.AllowCharacterConstraint

Classes in this File

Line Coverage

Branch Coverage

Complexity

AllowCharacterConstraint

31%

72/230

26%

57/214

2.845

 /**
  * Copyright 2005-2011 The Kuali Foundation
  *
  * Licensed under the Educational Community License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.opensource.org/licenses/ecl2.php
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.kuali.rice.krad.datadictionary.validation.constraint;
 
 import org.kuali.rice.core.api.config.property.ConfigurationService;
 import org.kuali.rice.krad.service.KRADServiceLocator;
 import org.kuali.rice.krad.uif.UifConstants;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * Parent abstract class that allows additional characters to be allowed in child constraint
  * character sets, see AlphaNumericPatternConstraint, among others for example.
  *
  * By setting an allow flag to true you are allowing that character as a valid character in the set.
  * AllowAll set to true will allow all characters which have a flag to be allowed in the set.
  *
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public abstract class AllowCharacterConstraint extends ValidCharactersPatternConstraint {
     protected boolean allowWhitespace = false;
     protected boolean omitNewline = false;
     protected boolean allowUnderscore = false;
     protected boolean allowPeriod = false;
     protected boolean allowParenthesis = false;
     protected boolean allowDollar = false;
     protected boolean allowForwardSlash = false;
     protected boolean allowDoubleQuote = false;
     protected boolean allowApostrophe = false;
     protected boolean allowComma = false;
     protected boolean allowColon = false;
     protected boolean allowSemiColon = false;
     protected boolean allowQuestionMark = false;
     protected boolean allowExclaimation = false;
     protected boolean allowDash = false;
     protected boolean allowPlus = false;
     protected boolean allowEquals = false;
     protected boolean allowAsterisk = false;
     protected boolean allowAtSign = false;
     protected boolean allowPercent = false;
     protected boolean allowPound = false;
     protected boolean allowGreaterThan = false;
     protected boolean allowLessThan = false;
     protected boolean allowBrackets = false;
     protected boolean allowAmpersand = false;
     protected boolean allowCurlyBraces = false;
     protected boolean allowBackslash = false;
     protected boolean allowAll = false;
 
     /**
      * @return the allowWhitespace
      */
     public boolean isAllowWhitespace() {
         return this.allowWhitespace;
     }
 
     /**
      * @param allowWhitespace the allowWhitespace to set
      */
     public void setAllowWhitespace(boolean allowWhitespace) {
         this.allowWhitespace = allowWhitespace;
     }
 
     /**
      * @return the allowUnderscore
      */
     public boolean isAllowUnderscore() {
         return this.allowUnderscore;
     }
 
     /**
      * @param allowUnderscore the allowUnderscore to set
      */
     public void setAllowUnderscore(boolean allowUnderscore) {
         this.allowUnderscore = allowUnderscore;
     }
 
     /**
      * @return the allowPeriod
      */
     public boolean isAllowPeriod() {
         return this.allowPeriod;
     }
 
     /**
      * @param allowPeriod the allowPeriod to set
      */
     public void setAllowPeriod(boolean allowPeriod) {
         this.allowPeriod = allowPeriod;
     }
 
     /**
      * @return the allowParenthesis
      */
     public boolean isAllowParenthesis() {
         return this.allowParenthesis;
     }
 
     /**
      * @param allowParenthesis the allowParenthesis to set
      */
     public void setAllowParenthesis(boolean allowParenthesis) {
         this.allowParenthesis = allowParenthesis;
     }
 
     /**
      * @return the allowDollar
      */
     public boolean isAllowDollar() {
         return this.allowDollar;
     }
 
     /**
      * @param allowDollar the allowDollar to set
      */
     public void setAllowDollar(boolean allowDollar) {
         this.allowDollar = allowDollar;
     }
 
     /**
      * @return the allowForwardSlash
      */
     public boolean isAllowForwardSlash() {
         return this.allowForwardSlash;
     }
 
     /**
      * @param allowForwardSlash the allowForwardSlash to set
      */
     public void setAllowForwardSlash(boolean allowForwardSlash) {
         this.allowForwardSlash = allowForwardSlash;
     }
 
     /**
      * @return the allowDoubleQuote
      */
     public boolean isAllowDoubleQuote() {
         return this.allowDoubleQuote;
     }
 
     /**
      * @param allowDoubleQuote the allowDoubleQuote to set
      */
     public void setAllowDoubleQuote(boolean allowDoubleQuote) {
         this.allowDoubleQuote = allowDoubleQuote;
     }
 
     /**
      * @return the allowApostrophe
      */
     public boolean isAllowApostrophe() {
         return this.allowApostrophe;
     }
 
     /**
      * @param allowApostrophe the allowApostrophe to set
      */
     public void setAllowApostrophe(boolean allowApostrophe) {
         this.allowApostrophe = allowApostrophe;
     }
 
     /**
      * @return the allowComma
      */
     public boolean isAllowComma() {
         return this.allowComma;
     }
 
     /**
      * @param allowComma the allowComma to set
      */
     public void setAllowComma(boolean allowComma) {
         this.allowComma = allowComma;
     }
 
     /**
      * @return the allowColon
      */
     public boolean isAllowColon() {
         return this.allowColon;
     }
 
     /**
      * @param allowColon the allowColon to set
      */
     public void setAllowColon(boolean allowColon) {
         this.allowColon = allowColon;
     }
 
     /**
      * @return the allowSemiColon
      */
     public boolean isAllowSemiColon() {
         return this.allowSemiColon;
     }
 
     /**
      * @param allowSemiColon the allowSemiColon to set
      */
     public void setAllowSemiColon(boolean allowSemiColon) {
         this.allowSemiColon = allowSemiColon;
     }
 
     /**
      * @return the allowQuestionMark
      */
     public boolean isAllowQuestionMark() {
         return this.allowQuestionMark;
     }
 
     /**
      * @param allowQuestionMark the allowQuestionMark to set
      */
     public void setAllowQuestionMark(boolean allowQuestionMark) {
         this.allowQuestionMark = allowQuestionMark;
     }
 
     /**
      * @return the allowExclaimation
      */
     public boolean isAllowExclaimation() {
         return this.allowExclaimation;
     }
 
     /**
      * @param allowExclaimation the allowExclaimation to set
      */
     public void setAllowExclaimation(boolean allowExclaimation) {
         this.allowExclaimation = allowExclaimation;
     }
 
     /**
      * @return the allowDash
      */
     public boolean isAllowDash() {
         return this.allowDash;
     }
 
     /**
      * @param allowDash the allowDash to set
      */
     public void setAllowDash(boolean allowDash) {
         this.allowDash = allowDash;
     }
 
     /**
      * @return the allowPlus
      */
     public boolean isAllowPlus() {
         return this.allowPlus;
     }
 
     /**
      * @param allowPlus the allowPlus to set
      */
     public void setAllowPlus(boolean allowPlus) {
         this.allowPlus = allowPlus;
     }
 
     /**
      * @return the allowEquals
      */
     public boolean isAllowEquals() {
         return this.allowEquals;
     }
 
     /**
      * @param allowEquals the allowEquals to set
      */
     public void setAllowEquals(boolean allowEquals) {
         this.allowEquals = allowEquals;
     }
 
     /**
      * @return the allowAsterisk
      */
     public boolean isAllowAsterisk() {
         return this.allowAsterisk;
     }
 
     /**
      * @param allowAsterisk the allowAsterisk to set
      */
     public void setAllowAsterisk(boolean allowAsterisk) {
         this.allowAsterisk = allowAsterisk;
     }
 
     /**
      * @return the allowAtSign
      */
     public boolean isAllowAtSign() {
         return this.allowAtSign;
     }
 
     /**
      * @param allowAtSign the allowAtSign to set
      */
     public void setAllowAtSign(boolean allowAtSign) {
         this.allowAtSign = allowAtSign;
     }
 
     /**
      * @return the allowPercent
      */
     public boolean isAllowPercent() {
         return this.allowPercent;
     }
 
     /**
      * @param allowPercent the allowPercent to set
      */
     public void setAllowPercent(boolean allowPercent) {
         this.allowPercent = allowPercent;
     }
 
     /**
      * @return the allowPound
      */
     public boolean isAllowPound() {
         return this.allowPound;
     }
 
     /**
      * @param allowPound the allowPound to set
      */
     public void setAllowPound(boolean allowPound) {
         this.allowPound = allowPound;
     }
 
     public boolean isAllowGreaterThan() {
         return allowGreaterThan;
     }
 
     public void setAllowGreaterThan(boolean allowGreaterThan) {
         this.allowGreaterThan = allowGreaterThan;
     }
 
     public boolean isAllowLessThan() {
         return allowLessThan;
     }
 
     public void setAllowLessThan(boolean allowLessThan) {
         this.allowLessThan = allowLessThan;
     }
 
     public boolean isAllowBrackets() {
         return allowBrackets;
     }
 
     public void setAllowBrackets(boolean allowBrackets) {
         this.allowBrackets = allowBrackets;
     }
 
     public boolean isAllowAmpersand() {
         return allowAmpersand;
     }
 
     public void setAllowAmpersand(boolean allowAmpersand) {
         this.allowAmpersand = allowAmpersand;
     }
 
     public boolean isAllowCurlyBraces() {
         return allowCurlyBraces;
     }
 
     public void setAllowCurlyBraces(boolean allowCurlyBraces) {
         this.allowCurlyBraces = allowCurlyBraces;
     }
 
     public boolean isAllowBackslash() {
         return allowBackslash;
     }
 
     public void setAllowBackslash(boolean allowBackslash) {
         this.allowBackslash = allowBackslash;
     }
 
     /**
      * If true, this constraint will allow all symbols that have flags for them. Equivalent to
      * setting each flag to true separately.
      *
      * @return the allowAll
      */
     public boolean isAllowAll() {
         return this.allowAll;
     }
 
     /**
      * @param allowAll the allowAll to set
      */
     public void setAllowAll(boolean allowAll) {
         this.allowAll = allowAll;
     }
 
     public boolean isOmitNewline() {
         return omitNewline;
     }
 
     /**
      * When set to true, omit new line characters from the set of valid characters.  This flag
      * will only have an effect if the allowWhitespace flag is true, otherwise all whitespace
      * including new lines characters are omitted.
      *
      * @param omitNewline
      */
     public void setOmitNewline(boolean omitNewline) {
         this.omitNewline = omitNewline;
     }
 
     /**
      * This method returns the allowed set of characters allowed by this constraint, based on the
      * flags set. This string is intended to be placed within the or set of a regex, ie between the
      * [ ] symbols
      *
      * @return
      */
     protected String getAllowedCharacterRegex() {
         StringBuilder regexString = new StringBuilder("");
         if (allowWhitespace || allowAll) {
             regexString.append("\\t\\v\\040");
             if (!omitNewline) {
                 regexString.append("\\f\\r\\n");
             }
         }
         if (allowUnderscore || allowAll) {
             regexString.append("_");
         }
         if (allowPeriod || allowAll) {
             regexString.append(".");
         }
         if (allowParenthesis || allowAll) {
             regexString.append("(");
             regexString.append(")");
         }
         if (allowDollar || allowAll) {
             regexString.append("$");
         }
         if (allowForwardSlash || allowAll) {
             regexString.append("/");
         }
         if (allowDoubleQuote || allowAll) {
             regexString.append("\\\"");
         }
         if (allowApostrophe || allowAll) {
             regexString.append("'");
         }
         if (allowComma || allowAll) {
             regexString.append(",");
         }
         if (allowColon || allowAll) {
             regexString.append(":");
         }
         if (allowSemiColon || allowAll) {
             regexString.append(";");
         }
         if (allowQuestionMark || allowAll) {
             regexString.append("?");
         }
         if (allowExclaimation || allowAll) {
             regexString.append("!");
         }
         if (allowDash || allowAll) {
             regexString.append("\\-");
         }
         if (allowPlus || allowAll) {
             regexString.append("+");
         }
         if (allowEquals || allowAll) {
             regexString.append("=");
         }
         if (allowAsterisk || allowAll) {
             regexString.append("*");
         }
         if (allowAtSign || allowAll) {
             regexString.append("@");
         }
         if (allowPercent || allowAll) {
             regexString.append("%");
         }
         if (allowPound || allowAll) {
             regexString.append("#");
         }
         if (allowLessThan || allowAll) {
             regexString.append("\\074");
         }
         if (allowGreaterThan || allowAll) {
             regexString.append("\\076");
         }
         if (allowAmpersand || allowAll) {
             regexString.append("\\046");
         }
         if (allowBackslash || allowAll) {
             regexString.append("\\134");
         }
         if (allowCurlyBraces || allowAll) {
             regexString.append("\\173\\175");
         }
         if (allowBrackets || allowAll) {
             regexString.append("\\133\\135");
         }
         return regexString.toString();
     }
 
     /**
      * Generates a comma separated string of the allowed set of characters, for the {0} parameter to
      * be used within its validation message
      *
      * @return the validationMessageParams
      */
     public List<String> getValidationMessageParams() {
         if (validationMessageParams == null) {
             validationMessageParams = new ArrayList<String>();
             ConfigurationService configService = KRADServiceLocator.getKualiConfigurationService();
             StringBuilder paramString = new StringBuilder("");
 
             if (allowWhitespace || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "whitespace"));
                 if (!omitNewline) {
                     paramString.append(", " + configService.getPropertyValueAsString(
                             UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "newline"));
                 }
             }
             if (allowUnderscore || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "underscore"));
             }
             if (allowPeriod || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "period"));
             }
             if (allowParenthesis || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "parenthesis"));
             }
             if (allowDollar || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "dollar"));
             }
             if (allowForwardSlash || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "forwardSlash"));
             }
             if (allowDoubleQuote || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "doubleQuote"));
             }
             if (allowApostrophe || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "apostrophe"));
             }
             if (allowComma || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "comma"));
             }
             if (allowColon || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "colon"));
             }
             if (allowSemiColon || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "semiColon"));
             }
             if (allowQuestionMark || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "questionMark"));
             }
             if (allowExclaimation || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "exclaimation"));
             }
             if (allowDash || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "dash"));
             }
             if (allowPlus || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "plus"));
             }
             if (allowEquals || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "equals"));
             }
             if (allowAsterisk || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "asterisk"));
             }
             if (allowAtSign || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "atSign"));
             }
             if (allowPercent || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "percent"));
             }
             if (allowPound || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "pound"));
             }
             if (allowLessThan || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "lessThan"));
             }
             if (allowGreaterThan || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "greaterThan"));
             }
             if (allowAmpersand || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "ampersand"));
             }
             if (allowBackslash || allowAll) {
                paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "backslash"));
             }
             if (allowCurlyBraces || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "curlyBraces"));
             }
             if (allowBrackets || allowAll) {
                 paramString.append(", " + configService.getPropertyValueAsString(
                         UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "brackets"));
             }
 
             validationMessageParams.add(paramString.toString());
         }
         return this.validationMessageParams;
     }
 
 }

1		/**
2		* Copyright 2005-2011 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.krad.datadictionary.validation.constraint;
17
18		import org.kuali.rice.core.api.config.property.ConfigurationService;
19		import org.kuali.rice.krad.service.KRADServiceLocator;
20		import org.kuali.rice.krad.uif.UifConstants;
21
22		import java.util.ArrayList;
23		import java.util.List;
24
25		/**
26		* Parent abstract class that allows additional characters to be allowed in child constraint
27		* character sets, see AlphaNumericPatternConstraint, among others for example.
28		*
29		* By setting an allow flag to true you are allowing that character as a valid character in the set.
30		* AllowAll set to true will allow all characters which have a flag to be allowed in the set.
31		*
32		* @author Kuali Rice Team (rice.collab@kuali.org)
33		*/
34	30	public abstract class AllowCharacterConstraint extends ValidCharactersPatternConstraint {
35	30	protected boolean allowWhitespace = false;
36	30	protected boolean omitNewline = false;
37	30	protected boolean allowUnderscore = false;
38	30	protected boolean allowPeriod = false;
39	30	protected boolean allowParenthesis = false;
40	30	protected boolean allowDollar = false;
41	30	protected boolean allowForwardSlash = false;
42	30	protected boolean allowDoubleQuote = false;
43	30	protected boolean allowApostrophe = false;
44	30	protected boolean allowComma = false;
45	30	protected boolean allowColon = false;
46	30	protected boolean allowSemiColon = false;
47	30	protected boolean allowQuestionMark = false;
48	30	protected boolean allowExclaimation = false;
49	30	protected boolean allowDash = false;
50	30	protected boolean allowPlus = false;
51	30	protected boolean allowEquals = false;
52	30	protected boolean allowAsterisk = false;
53	30	protected boolean allowAtSign = false;
54	30	protected boolean allowPercent = false;
55	30	protected boolean allowPound = false;
56	30	protected boolean allowGreaterThan = false;
57	30	protected boolean allowLessThan = false;
58	30	protected boolean allowBrackets = false;
59	30	protected boolean allowAmpersand = false;
60	30	protected boolean allowCurlyBraces = false;
61	30	protected boolean allowBackslash = false;
62	30	protected boolean allowAll = false;
63
64		/**
65		* @return the allowWhitespace
66		*/
67		public boolean isAllowWhitespace() {
68	0	return this.allowWhitespace;
69		}
70
71		/**
72		* @param allowWhitespace the allowWhitespace to set
73		*/
74		public void setAllowWhitespace(boolean allowWhitespace) {
75	17	this.allowWhitespace = allowWhitespace;
76	17	}
77
78		/**
79		* @return the allowUnderscore
80		*/
81		public boolean isAllowUnderscore() {
82	0	return this.allowUnderscore;
83		}
84
85		/**
86		* @param allowUnderscore the allowUnderscore to set
87		*/
88		public void setAllowUnderscore(boolean allowUnderscore) {
89	6	this.allowUnderscore = allowUnderscore;
90	6	}
91
92		/**
93		* @return the allowPeriod
94		*/
95		public boolean isAllowPeriod() {
96	0	return this.allowPeriod;
97		}
98
99		/**
100		* @param allowPeriod the allowPeriod to set
101		*/
102		public void setAllowPeriod(boolean allowPeriod) {
103	6	this.allowPeriod = allowPeriod;
104	6	}
105
106		/**
107		* @return the allowParenthesis
108		*/
109		public boolean isAllowParenthesis() {
110	0	return this.allowParenthesis;
111		}
112
113		/**
114		* @param allowParenthesis the allowParenthesis to set
115		*/
116		public void setAllowParenthesis(boolean allowParenthesis) {
117	6	this.allowParenthesis = allowParenthesis;
118	6	}
119
120		/**
121		* @return the allowDollar
122		*/
123		public boolean isAllowDollar() {
124	0	return this.allowDollar;
125		}
126
127		/**
128		* @param allowDollar the allowDollar to set
129		*/
130		public void setAllowDollar(boolean allowDollar) {
131	0	this.allowDollar = allowDollar;
132	0	}
133
134		/**
135		* @return the allowForwardSlash
136		*/
137		public boolean isAllowForwardSlash() {
138	0	return this.allowForwardSlash;
139		}
140
141		/**
142		* @param allowForwardSlash the allowForwardSlash to set
143		*/
144		public void setAllowForwardSlash(boolean allowForwardSlash) {
145	0	this.allowForwardSlash = allowForwardSlash;
146	0	}
147
148		/**
149		* @return the allowDoubleQuote
150		*/
151		public boolean isAllowDoubleQuote() {
152	0	return this.allowDoubleQuote;
153		}
154
155		/**
156		* @param allowDoubleQuote the allowDoubleQuote to set
157		*/
158		public void setAllowDoubleQuote(boolean allowDoubleQuote) {
159	0	this.allowDoubleQuote = allowDoubleQuote;
160	0	}
161
162		/**
163		* @return the allowApostrophe
164		*/
165		public boolean isAllowApostrophe() {
166	0	return this.allowApostrophe;
167		}
168
169		/**
170		* @param allowApostrophe the allowApostrophe to set
171		*/
172		public void setAllowApostrophe(boolean allowApostrophe) {
173	0	this.allowApostrophe = allowApostrophe;
174	0	}
175
176		/**
177		* @return the allowComma
178		*/
179		public boolean isAllowComma() {
180	0	return this.allowComma;
181		}
182
183		/**
184		* @param allowComma the allowComma to set
185		*/
186		public void setAllowComma(boolean allowComma) {
187	0	this.allowComma = allowComma;
188	0	}
189
190		/**
191		* @return the allowColon
192		*/
193		public boolean isAllowColon() {
194	0	return this.allowColon;
195		}
196
197		/**
198		* @param allowColon the allowColon to set
199		*/
200		public void setAllowColon(boolean allowColon) {
201	0	this.allowColon = allowColon;
202	0	}
203
204		/**
205		* @return the allowSemiColon
206		*/
207		public boolean isAllowSemiColon() {
208	0	return this.allowSemiColon;
209		}
210
211		/**
212		* @param allowSemiColon the allowSemiColon to set
213		*/
214		public void setAllowSemiColon(boolean allowSemiColon) {
215	0	this.allowSemiColon = allowSemiColon;
216	0	}
217
218		/**
219		* @return the allowQuestionMark
220		*/
221		public boolean isAllowQuestionMark() {
222	0	return this.allowQuestionMark;
223		}
224
225		/**
226		* @param allowQuestionMark the allowQuestionMark to set
227		*/
228		public void setAllowQuestionMark(boolean allowQuestionMark) {
229	0	this.allowQuestionMark = allowQuestionMark;
230	0	}
231
232		/**
233		* @return the allowExclaimation
234		*/
235		public boolean isAllowExclaimation() {
236	0	return this.allowExclaimation;
237		}
238
239		/**
240		* @param allowExclaimation the allowExclaimation to set
241		*/
242		public void setAllowExclaimation(boolean allowExclaimation) {
243	0	this.allowExclaimation = allowExclaimation;
244	0	}
245
246		/**
247		* @return the allowDash
248		*/
249		public boolean isAllowDash() {
250	0	return this.allowDash;
251		}
252
253		/**
254		* @param allowDash the allowDash to set
255		*/
256		public void setAllowDash(boolean allowDash) {
257	0	this.allowDash = allowDash;
258	0	}
259
260		/**
261		* @return the allowPlus
262		*/
263		public boolean isAllowPlus() {
264	0	return this.allowPlus;
265		}
266
267		/**
268		* @param allowPlus the allowPlus to set
269		*/
270		public void setAllowPlus(boolean allowPlus) {
271	0	this.allowPlus = allowPlus;
272	0	}
273
274		/**
275		* @return the allowEquals
276		*/
277		public boolean isAllowEquals() {
278	0	return this.allowEquals;
279		}
280
281		/**
282		* @param allowEquals the allowEquals to set
283		*/
284		public void setAllowEquals(boolean allowEquals) {
285	0	this.allowEquals = allowEquals;
286	0	}
287
288		/**
289		* @return the allowAsterisk
290		*/
291		public boolean isAllowAsterisk() {
292	0	return this.allowAsterisk;
293		}
294
295		/**
296		* @param allowAsterisk the allowAsterisk to set
297		*/
298		public void setAllowAsterisk(boolean allowAsterisk) {
299	0	this.allowAsterisk = allowAsterisk;
300	0	}
301
302		/**
303		* @return the allowAtSign
304		*/
305		public boolean isAllowAtSign() {
306	0	return this.allowAtSign;
307		}
308
309		/**
310		* @param allowAtSign the allowAtSign to set
311		*/
312		public void setAllowAtSign(boolean allowAtSign) {
313	0	this.allowAtSign = allowAtSign;
314	0	}
315
316		/**
317		* @return the allowPercent
318		*/
319		public boolean isAllowPercent() {
320	0	return this.allowPercent;
321		}
322
323		/**
324		* @param allowPercent the allowPercent to set
325		*/
326		public void setAllowPercent(boolean allowPercent) {
327	0	this.allowPercent = allowPercent;
328	0	}
329
330		/**
331		* @return the allowPound
332		*/
333		public boolean isAllowPound() {
334	0	return this.allowPound;
335		}
336
337		/**
338		* @param allowPound the allowPound to set
339		*/
340		public void setAllowPound(boolean allowPound) {
341	0	this.allowPound = allowPound;
342	0	}
343
344		public boolean isAllowGreaterThan() {
345	0	return allowGreaterThan;
346		}
347
348		public void setAllowGreaterThan(boolean allowGreaterThan) {
349	0	this.allowGreaterThan = allowGreaterThan;
350	0	}
351
352		public boolean isAllowLessThan() {
353	0	return allowLessThan;
354		}
355
356		public void setAllowLessThan(boolean allowLessThan) {
357	0	this.allowLessThan = allowLessThan;
358	0	}
359
360		public boolean isAllowBrackets() {
361	0	return allowBrackets;
362		}
363
364		public void setAllowBrackets(boolean allowBrackets) {
365	0	this.allowBrackets = allowBrackets;
366	0	}
367
368		public boolean isAllowAmpersand() {
369	0	return allowAmpersand;
370		}
371
372		public void setAllowAmpersand(boolean allowAmpersand) {
373	0	this.allowAmpersand = allowAmpersand;
374	0	}
375
376		public boolean isAllowCurlyBraces() {
377	0	return allowCurlyBraces;
378		}
379
380		public void setAllowCurlyBraces(boolean allowCurlyBraces) {
381	0	this.allowCurlyBraces = allowCurlyBraces;
382	0	}
383
384		public boolean isAllowBackslash() {
385	0	return allowBackslash;
386		}
387
388		public void setAllowBackslash(boolean allowBackslash) {
389	0	this.allowBackslash = allowBackslash;
390	0	}
391
392		/**
393		* If true, this constraint will allow all symbols that have flags for them. Equivalent to
394		* setting each flag to true separately.
395		*
396		* @return the allowAll
397		*/
398		public boolean isAllowAll() {
399	0	return this.allowAll;
400		}
401
402		/**
403		* @param allowAll the allowAll to set
404		*/
405		public void setAllowAll(boolean allowAll) {
406	0	this.allowAll = allowAll;
407	0	}
408
409		public boolean isOmitNewline() {
410	0	return omitNewline;
411		}
412
413		/**
414		* When set to true, omit new line characters from the set of valid characters. This flag
415		* will only have an effect if the allowWhitespace flag is true, otherwise all whitespace
416		* including new lines characters are omitted.
417		*
418		* @param omitNewline
419		*/
420		public void setOmitNewline(boolean omitNewline) {
421	0	this.omitNewline = omitNewline;
422	0	}
423
424		/**
425		* This method returns the allowed set of characters allowed by this constraint, based on the
426		* flags set. This string is intended to be placed within the or set of a regex, ie between the
427		* [ ] symbols
428		*
429		* @return
430		*/
431		protected String getAllowedCharacterRegex() {
432	13	StringBuilder regexString = new StringBuilder("");
433	13	if (allowWhitespace \|\| allowAll) {
434	7	regexString.append("\\t\\v\\040");
435	7	if (!omitNewline) {
436	7	regexString.append("\\f\\r\\n");
437		}
438		}
439	13	if (allowUnderscore \|\| allowAll) {
440	2	regexString.append("_");
441		}
442	13	if (allowPeriod \|\| allowAll) {
443	2	regexString.append(".");
444		}
445	13	if (allowParenthesis \|\| allowAll) {
446	2	regexString.append("(");
447	2	regexString.append(")");
448		}
449	13	if (allowDollar \|\| allowAll) {
450	0	regexString.append("$");
451		}
452	13	if (allowForwardSlash \|\| allowAll) {
453	0	regexString.append("/");
454		}
455	13	if (allowDoubleQuote \|\| allowAll) {
456	0	regexString.append("\\\"");
457		}
458	13	if (allowApostrophe \|\| allowAll) {
459	0	regexString.append("'");
460		}
461	13	if (allowComma \|\| allowAll) {
462	0	regexString.append(",");
463		}
464	13	if (allowColon \|\| allowAll) {
465	0	regexString.append(":");
466		}
467	13	if (allowSemiColon \|\| allowAll) {
468	0	regexString.append(";");
469		}
470	13	if (allowQuestionMark \|\| allowAll) {
471	0	regexString.append("?");
472		}
473	13	if (allowExclaimation \|\| allowAll) {
474	0	regexString.append("!");
475		}
476	13	if (allowDash \|\| allowAll) {
477	0	regexString.append("\\-");
478		}
479	13	if (allowPlus \|\| allowAll) {
480	0	regexString.append("+");
481		}
482	13	if (allowEquals \|\| allowAll) {
483	0	regexString.append("=");
484		}
485	13	if (allowAsterisk \|\| allowAll) {
486	0	regexString.append("*");
487		}
488	13	if (allowAtSign \|\| allowAll) {
489	0	regexString.append("@");
490		}
491	13	if (allowPercent \|\| allowAll) {
492	0	regexString.append("%");
493		}
494	13	if (allowPound \|\| allowAll) {
495	0	regexString.append("#");
496		}
497	13	if (allowLessThan \|\| allowAll) {
498	0	regexString.append("\\074");
499		}
500	13	if (allowGreaterThan \|\| allowAll) {
501	0	regexString.append("\\076");
502		}
503	13	if (allowAmpersand \|\| allowAll) {
504	0	regexString.append("\\046");
505		}
506	13	if (allowBackslash \|\| allowAll) {
507	0	regexString.append("\\134");
508		}
509	13	if (allowCurlyBraces \|\| allowAll) {
510	0	regexString.append("\\173\\175");
511		}
512	13	if (allowBrackets \|\| allowAll) {
513	0	regexString.append("\\133\\135");
514		}
515	13	return regexString.toString();
516		}
517
518		/**
519		* Generates a comma separated string of the allowed set of characters, for the {0} parameter to
520		* be used within its validation message
521		*
522		* @return the validationMessageParams
523		*/
524		public List<String> getValidationMessageParams() {
525	0	if (validationMessageParams == null) {
526	0	validationMessageParams = new ArrayList<String>();
527	0	ConfigurationService configService = KRADServiceLocator.getKualiConfigurationService();
528	0	StringBuilder paramString = new StringBuilder("");
529
530	0	if (allowWhitespace \|\| allowAll) {
531	0	paramString.append(", " + configService.getPropertyValueAsString(
532		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "whitespace"));
533	0	if (!omitNewline) {
534	0	paramString.append(", " + configService.getPropertyValueAsString(
535		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "newline"));
536		}
537		}
538	0	if (allowUnderscore \|\| allowAll) {
539	0	paramString.append(", " + configService.getPropertyValueAsString(
540		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "underscore"));
541		}
542	0	if (allowPeriod \|\| allowAll) {
543	0	paramString.append(", " + configService.getPropertyValueAsString(
544		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "period"));
545		}
546	0	if (allowParenthesis \|\| allowAll) {
547	0	paramString.append(", " + configService.getPropertyValueAsString(
548		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "parenthesis"));
549		}
550	0	if (allowDollar \|\| allowAll) {
551	0	paramString.append(", " + configService.getPropertyValueAsString(
552		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "dollar"));
553		}
554	0	if (allowForwardSlash \|\| allowAll) {
555	0	paramString.append(", " + configService.getPropertyValueAsString(
556		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "forwardSlash"));
557		}
558	0	if (allowDoubleQuote \|\| allowAll) {
559	0	paramString.append(", " + configService.getPropertyValueAsString(
560		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "doubleQuote"));
561		}
562	0	if (allowApostrophe \|\| allowAll) {
563	0	paramString.append(", " + configService.getPropertyValueAsString(
564		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "apostrophe"));
565		}
566	0	if (allowComma \|\| allowAll) {
567	0	paramString.append(", " + configService.getPropertyValueAsString(
568		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "comma"));
569		}
570	0	if (allowColon \|\| allowAll) {
571	0	paramString.append(", " + configService.getPropertyValueAsString(
572		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "colon"));
573		}
574	0	if (allowSemiColon \|\| allowAll) {
575	0	paramString.append(", " + configService.getPropertyValueAsString(
576		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "semiColon"));
577		}
578	0	if (allowQuestionMark \|\| allowAll) {
579	0	paramString.append(", " + configService.getPropertyValueAsString(
580		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "questionMark"));
581		}
582	0	if (allowExclaimation \|\| allowAll) {
583	0	paramString.append(", " + configService.getPropertyValueAsString(
584		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "exclaimation"));
585		}
586	0	if (allowDash \|\| allowAll) {
587	0	paramString.append(", " + configService.getPropertyValueAsString(
588		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "dash"));
589		}
590	0	if (allowPlus \|\| allowAll) {
591	0	paramString.append(", " + configService.getPropertyValueAsString(
592		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "plus"));
593		}
594	0	if (allowEquals \|\| allowAll) {
595	0	paramString.append(", " + configService.getPropertyValueAsString(
596		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "equals"));
597		}
598	0	if (allowAsterisk \|\| allowAll) {
599	0	paramString.append(", " + configService.getPropertyValueAsString(
600		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "asterisk"));
601		}
602	0	if (allowAtSign \|\| allowAll) {
603	0	paramString.append(", " + configService.getPropertyValueAsString(
604		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "atSign"));
605		}
606	0	if (allowPercent \|\| allowAll) {
607	0	paramString.append(", " + configService.getPropertyValueAsString(
608		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "percent"));
609		}
610	0	if (allowPound \|\| allowAll) {
611	0	paramString.append(", " + configService.getPropertyValueAsString(
612		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "pound"));
613		}
614	0	if (allowLessThan \|\| allowAll) {
615	0	paramString.append(", " + configService.getPropertyValueAsString(
616		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "lessThan"));
617		}
618	0	if (allowGreaterThan \|\| allowAll) {
619	0	paramString.append(", " + configService.getPropertyValueAsString(
620		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "greaterThan"));
621		}
622	0	if (allowAmpersand \|\| allowAll) {
623	0	paramString.append(", " + configService.getPropertyValueAsString(
624		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "ampersand"));
625		}
626	0	if (allowBackslash \|\| allowAll) {
627	0	paramString.append(", " + configService.getPropertyValueAsString(
628		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "backslash"));
629		}
630	0	if (allowCurlyBraces \|\| allowAll) {
631	0	paramString.append(", " + configService.getPropertyValueAsString(
632		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "curlyBraces"));
633		}
634	0	if (allowBrackets \|\| allowAll) {
635	0	paramString.append(", " + configService.getPropertyValueAsString(
636		UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "brackets"));
637		}
638
639	0	validationMessageParams.add(paramString.toString());
640		}
641	0	return this.validationMessageParams;
642		}
643
644		}