Coverage Report

Coverage Report - org.kuali.rice.krad.datadictionary.AttributeDefinition

Classes in this File

Line Coverage

Branch Coverage

Complexity

AttributeDefinition

16%

19/112

0/28

1.368

 /*
  * Copyright 2005-2008 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;
 
 import org.apache.commons.lang.ClassUtils;
 import org.apache.commons.lang.StringUtils;
 import org.apache.log4j.Logger;
 import org.kuali.rice.core.api.uif.DataType;
 import org.kuali.rice.core.api.util.ClassLoaderUtils;
 import org.kuali.rice.core.web.format.Formatter;
 import org.kuali.rice.krad.datadictionary.control.ControlDefinition;
 import org.kuali.rice.krad.datadictionary.exception.AttributeValidationException;
 import org.kuali.rice.krad.datadictionary.exception.ClassValidationException;
 import org.kuali.rice.krad.datadictionary.validation.ValidationPattern;
 import org.kuali.rice.krad.datadictionary.validation.capability.CaseConstrainable;
 import org.kuali.rice.krad.datadictionary.validation.capability.Formatable;
 import org.kuali.rice.krad.datadictionary.validation.capability.HierarchicallyConstrainable;
 import org.kuali.rice.krad.datadictionary.validation.capability.LengthConstrainable;
 import org.kuali.rice.krad.datadictionary.validation.capability.MustOccurConstrainable;
 import org.kuali.rice.krad.datadictionary.validation.capability.PrerequisiteConstrainable;
 import org.kuali.rice.krad.datadictionary.validation.capability.RangeConstrainable;
 import org.kuali.rice.krad.datadictionary.validation.capability.ValidCharactersConstrainable;
 import org.kuali.rice.krad.datadictionary.validation.constraint.CaseConstraint;
 import org.kuali.rice.krad.datadictionary.validation.constraint.LookupConstraint;
 import org.kuali.rice.krad.datadictionary.validation.constraint.MustOccurConstraint;
 import org.kuali.rice.krad.datadictionary.validation.constraint.PrerequisiteConstraint;
 import org.kuali.rice.krad.datadictionary.validation.constraint.ValidCharactersConstraint;
 import org.kuali.rice.krad.keyvalues.KeyValuesFinder;
 import org.kuali.rice.krad.uif.control.Control;
 import org.kuali.rice.krad.util.ObjectUtils;
 
 import java.util.List;
 
 /**
  * A single attribute definition in the DataDictionary, which contains
  * information relating to the display, validation, and general maintenance of a
  * specific attribute of an entry.
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public class AttributeDefinition extends AttributeDefinitionBase implements CaseConstrainable, PrerequisiteConstrainable, Formatable, HierarchicallyConstrainable, MustOccurConstrainable, LengthConstrainable, RangeConstrainable, ValidCharactersConstrainable {
         private static final long serialVersionUID = -2490613377818442742L;
 
         protected Boolean forceUppercase = Boolean.FALSE;
         
         protected DataType dataType;
         
         protected Integer minLength;
         protected Integer maxLength;
         protected Boolean unique;
 
         protected String exclusiveMin;
         protected String inclusiveMax;
 
         @Deprecated 
         protected ValidationPattern validationPattern;
 
         protected ControlDefinition control;
 
         // TODO: rename to control once ControlDefinition is removed
         protected Control controlField;
 
         protected String formatterClass;
 
         protected AttributeSecurity attributeSecurity;
         
         protected Boolean dynamic;
         
         // KS-style constraints 
         protected String customValidatorClass;
         protected ValidCharactersConstraint validCharactersConstraint;        
     protected CaseConstraint caseConstraint;
     protected List<PrerequisiteConstraint> dependencyConstraints;
         protected List<MustOccurConstraint> mustOccurConstraints;
         protected LookupConstraint lookupDefinition;// If the user wants to match
                 // against two searches, that search must be defined as  well
         protected String lookupContextPath;
         
         //TODO: This may not be required since we now use ComplexAttributeDefinition
         protected String childEntryName;
         
         private KeyValuesFinder optionsFinder;
 
         protected String alternateDisplayAttributeName;
     protected String additionalDisplayAttributeName;
     
 
         public AttributeDefinition() {
                 // Empty
         }
 
         /**
          * forceUppercase = convert user entry to uppercase and always display
          * database value as uppercase.
          */
         public void setForceUppercase(Boolean forceUppercase) {
                 this.forceUppercase = forceUppercase;
         }
 
         public Boolean getForceUppercase() {
                 return this.forceUppercase;
         }
 
         @Override
         public Integer getMaxLength() {
                 return maxLength;
         }
 
         /**
          * The maxLength element determines the maximum size of the field for data
          * entry edit purposes and for display purposes.
          */
         public void setMaxLength(Integer maxLength) {
                 this.maxLength = maxLength;
         }
 
         @Override
         public String getExclusiveMin() {
                 return exclusiveMin;
         }
 
         /**
          * The exclusiveMin element determines the minimum allowable value for data
          * entry editing purposes. Value can be an integer or decimal value such as
          * -.001 or 99.
          */
         public void setExclusiveMin(String exclusiveMin) {
                 this.exclusiveMin = exclusiveMin;
         }
 
         /**
          * The inclusiveMax element determines the maximum allowable value for data
          * entry editing purposes. Value can be an integer or decimal value such as
          * -.001 or 99.
          * 
          * JSTL: This field is mapped into the field named "exclusiveMax".
          */
         @Override
         public String getInclusiveMax() {
                 return inclusiveMax;
         }
 
         /**
          * The inclusiveMax element determines the maximum allowable value for data
          * entry editing purposes. Value can be an integer or decimal value such as
          * -.001 or 99.
          * 
          * JSTL: This field is mapped into the field named "exclusiveMax".
          */
         public void setInclusiveMax(String inclusiveMax) {
                 this.inclusiveMax = inclusiveMax;
         }
 
         /**
          * @return true if a validationPattern has been set
          */
         public boolean hasValidationPattern() {
                 return (validationPattern != null);
         }
 
         public ValidationPattern getValidationPattern() {
                 return this.validationPattern;
         }
 
         /**
          * The validationPattern element defines the allowable character-level or
          * field-level values for an attribute.
          * 
          * JSTL: validationPattern is a Map which is accessed using a key of
          * "validationPattern". Each entry may contain some of the keys listed
          * below. The keys that may be present for a given attribute are dependent
          * upon the type of validationPattern.
          * 
          * maxLength (String) exactLength type allowWhitespace allowUnderscore
          * allowPeriod validChars precision scale allowNegative
          * 
          * The allowable keys (in addition to type) for each type are: Type****
          * ***Keys*** alphanumeric exactLength maxLength allowWhitespace
          * allowUnderscore allowPeriod
          * 
          * alpha exactLength maxLength allowWhitespace
          * 
          * anyCharacter exactLength maxLength allowWhitespace
          * 
          * charset validChars
          * 
          * numeric exactLength maxLength
          * 
          * fixedPoint allowNegative precision scale
          * 
          * floatingPoint allowNegative
          * 
          * date n/a emailAddress n/a javaClass n/a month n/a phoneNumber n/a
          * timestamp n/a year n/a zipcode n/a
          * 
          * Note: maxLength and exactLength are mutually exclusive. If one is
          * entered, the other may not be entered.
          * 
          * Note: See ApplicationResources.properties for exact regex patterns. e.g.
          * validationPatternRegex.date for regex used in date validation.
          */
         public void setValidationPattern(ValidationPattern validationPattern) {
                 this.validationPattern = validationPattern;
                 
                 // FIXME: JLR - need to recreate this functionality using the ValidCharsConstraint logic
         }
 
 
         /**
          * @return control
          */
         public ControlDefinition getControl() {
                 return control;
         }
 
         /**
          * The control element defines the manner in which an attribute is displayed
          * and the manner in which the attribute value is entered.
          * 
          * JSTL: control is a Map representing an HTML control. It is accessed using
          * a key of "control". The table below shows the types of entries associated
          * with each type of control.
          * 
          ** Control Type** **Key** **Value** checkbox checkbox boolean String
          * 
          * hidden hidden boolean String
          * 
          * radio radio boolean String valuesFinder valuesFinder class name
          * dataObjectClass String keyAttribute String labelAttribute String
          * includeKeyInLabel boolean String
          * 
          * select select boolean String valuesFinder valuesFinder class name
          * dataObjectClass String keyAttribute String labelAttribute String
          * includeBlankRow boolean String includeKeyInLabel boolean String
          * 
          * apcSelect apcSelect boolean String paramNamespace String
          * parameterDetailType String parameterName String
          * 
          * text text boolean String size String
          * 
          * textarea textarea boolean String rows cols
          * 
          * currency currency boolean String size String formattedMaxLength String
          * 
          * kualiUser kualiUser boolean String universalIdAttributeName String
          * userIdAttributeName String personNameAttributeName String
          * 
          * lookupHidden lookupHidden boolean String
          * 
          * lookupReadonly lookupReadonly boolean String
          * 
          * @param control
          * @throws IllegalArgumentException
          *             if the given control is null
          */
         public void setControl(ControlDefinition control) {
                 if (control == null) {
                         throw new IllegalArgumentException("invalid (null) control");
                 }
                 this.control = control;
         }
 
         public boolean hasFormatterClass() {
                 return (formatterClass != null);
         }
 
         @Override
         public String getFormatterClass() {
                 return formatterClass;
         }
 
         /**
          * The formatterClass element is used when custom formatting is required for
          * display of the field value. This field specifies the name of the java
          * class to be used for the formatting. About 15 different classes are
          * available including BooleanFormatter, CurrencyFormatter, DateFormatter,
          * etc.
          */
         public void setFormatterClass(String formatterClass) {
                 if (formatterClass == null) {
                         throw new IllegalArgumentException("invalid (null) formatterClass");
                 }
                 this.formatterClass = formatterClass;
         }
 
         /**
          * Directly validate simple fields, call completeValidation on Definition
          * fields.
          * 
          * @see org.kuali.rice.krad.datadictionary.DataDictionaryEntry#completeValidation()
          */
         @Override
         public void completeValidation(Class<?> rootObjectClass, Class<?> otherObjectClass) {
                 try {
                         if (!DataDictionary.isPropertyOf(rootObjectClass, getName())) {
                                 throw new AttributeValidationException("property '" + getName() + "' is not a property of class '"
                                                 + rootObjectClass.getName() + "' (" + "" + ")");
                         }
 
                         //TODO currently requiring a control or controlField, but this should not be case (AttrField should probably do the check)
                         if (getControl() == null && getControlField() == null) {
                                 throw new AttributeValidationException("property '" + getName() + "' in class '"
                                                 + rootObjectClass.getName() + " does not have a control defined");
                         }
                         
                         if(getControl() != null) {
                             getControl().completeValidation(rootObjectClass, otherObjectClass);
                         }
 
                         if (attributeSecurity != null) {
                                 attributeSecurity.completeValidation(rootObjectClass, otherObjectClass);
                         }
 
                         if (validationPattern != null) {
                                 validationPattern.completeValidation();
                         }
 
                         if (formatterClass != null) {
                                 try {
                                         Class formatterClassObject = ClassUtils.getClass(ClassLoaderUtils.getDefaultClassLoader(),
                                                         getFormatterClass());
                                         if (!Formatter.class.isAssignableFrom(formatterClassObject)) {
                                                 throw new ClassValidationException("formatterClass is not a valid instance of "
                                                                 + Formatter.class.getName() + " instead was: " + formatterClassObject.getName());
                                         }
                                 }
                                 catch (ClassNotFoundException e) {
                                         throw new ClassValidationException("formatterClass could not be found: " + getFormatterClass(), e);
                                 }
                         }
                 }
                 catch (RuntimeException ex) {
                         Logger.getLogger(getClass()).error(
                                         "Unable to validate attribute " + rootObjectClass + "." + getName() + ": " + ex.getMessage(), ex);
                         throw ex;
                 }
         }
 
         /**
          * @see java.lang.Object#toString()
          */
         @Override
         public String toString() {
                 return "AttributeDefinition for attribute " + getName();
         }
 
         /**
          * @return the attributeSecurity
          */
         public AttributeSecurity getAttributeSecurity() {
                 return this.attributeSecurity;
         }
 
         /**
          * @param attributeSecurity
          *            the attributeSecurity to set
          */
         public void setAttributeSecurity(AttributeSecurity attributeSecurity) {
                 this.attributeSecurity = attributeSecurity;
         }
 
         public boolean hasAttributeSecurity() {
                 return (attributeSecurity != null);
         }
 
         /**
          * This overridden method ...
          * 
          * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
          */
         @Override
         public void afterPropertiesSet() throws Exception {
                 if (StringUtils.isEmpty(name)) {
                         throw new RuntimeException("blank name for bean: " + id);
                 }
         }
 
         /**
          * @return the unique
          */
         public Boolean getUnique() {
                 return this.unique;
         }
 
         /**
          * @param unique
          *            the unique to set
          */
         public void setUnique(Boolean unique) {
                 this.unique = unique;
         }
 
         /**
          * Default <code>Control</code> to use when the attribute is to be rendered
          * for the UI. Used by the UIF when a control is not defined for an
          * <code>AttributeField</code>
          * 
          * @return Control instance
          */
         public Control getControlField() {
                 return this.controlField;
         }
 
         /**
          * Setter for the default control
          * 
          * @param controlField
          */
         public void setControlField(Control controlField) {
                 this.controlField = controlField;
         }
 
         /**
          * @return the minLength
          */
         public Integer getMinLength() {
                 return this.minLength;
         }
 
         /**
          * @param minLength the minLength to set
          */
         public void setMinLength(Integer minLength) {
                 this.minLength = minLength;
         }
 
         /**
          * @return the dataType
          */
         @Override
         public DataType getDataType() {
                 return this.dataType;
         }
 
         /**
          * @param dataType the dataType to set
          */
         public void setDataType(DataType dataType) {
                 this.dataType = dataType;
         }
         
         public void setDataType(String dataType) {
                 this.dataType = DataType.valueOf(dataType);
         }
 
         /**
          * @return the customValidatorClass
          */
         public String getCustomValidatorClass() {
                 return this.customValidatorClass;
         }
 
         /**
          * @param customValidatorClass the customValidatorClass to set
          */
         public void setCustomValidatorClass(String customValidatorClass) {
                 this.customValidatorClass = customValidatorClass;
         }
 
         /**
          * @return the validChars
          */
         @Override
         public ValidCharactersConstraint getValidCharactersConstraint() {
                 return this.validCharactersConstraint;
         }
 
         /**
          * @param validCharactersConstraint the validChars to set
          */
         public void setValidCharactersConstraint(ValidCharactersConstraint validCharactersConstraint) {
                 this.validCharactersConstraint = validCharactersConstraint;
         }
 
         /**
          * @return the caseConstraint
          */
         @Override
         public CaseConstraint getCaseConstraint() {
                 return this.caseConstraint;
         }
 
         /**
          * @param caseConstraint the caseConstraint to set
          */
         public void setCaseConstraint(CaseConstraint caseConstraint) {
                 this.caseConstraint = caseConstraint;
         }
 
         /**
          * @return the requireConstraint
          */
         @Override
         public List<PrerequisiteConstraint> getPrerequisiteConstraints() {
                 return this.dependencyConstraints;
         }
 
         /**
          * @param dependencyConstraints the requireConstraint to set
          */
         public void setPrerequisiteConstraints(List<PrerequisiteConstraint> dependencyConstraints) {
                 this.dependencyConstraints = dependencyConstraints;
         }
 
         /**
          * @return the occursConstraint
          */
         @Override
         public List<MustOccurConstraint> getMustOccurConstraints() {
                 return this.mustOccurConstraints;
         }
 
         /**
          * @param mustOccurConstraints the occursConstraint to set
          */
         public void setMustOccurConstraints(List<MustOccurConstraint> mustOccurConstraints) {
                 this.mustOccurConstraints = mustOccurConstraints;
         }
 
         /**
          * @return the lookupDefinition
          */
         public LookupConstraint getLookupDefinition() {
                 return this.lookupDefinition;
         }
 
         /**
          * @param lookupDefinition the lookupDefinition to set
          */
         public void setLookupDefinition(LookupConstraint lookupDefinition) {
                 this.lookupDefinition = lookupDefinition;
         }
 
         /**
          * @return the lookupContextPath
          */
         public String getLookupContextPath() {
                 return this.lookupContextPath;
         }
 
         /**
          * @param lookupContextPath the lookupContextPath to set
          */
         public void setLookupContextPath(String lookupContextPath) {
                 this.lookupContextPath = lookupContextPath;
         }
 
         /**
          * @return the childEntryName
          */
         public String getChildEntryName() {
                 return this.childEntryName;
         }
 
         /**
          * @param childEntryName the childEntryName to set
          */
         public void setChildEntryName(String childEntryName) {
                 this.childEntryName = childEntryName;
         }
 
         /**
          * @return the constraintMessage
          */
         public String getConstraint() {
                 return this.constraint;
         }
 
         /**
          * @param constraintMessage the constraintMessage to set
          */
         public void setConstraint(String constraint) {
                 this.constraint = constraint;
         }
         
     /**
      * Instance of <code>KeyValluesFinder</code> that should be invoked to
      * provide a List of values the field can have. Generally used to provide
      * the options for a multi-value control or to validate the submitted field
      * value
      * 
      * @return KeyValuesFinder instance
      */
     public KeyValuesFinder getOptionsFinder() {
         return this.optionsFinder;
     }
 
     /**
      * Setter for the field's KeyValuesFinder instance
      * 
      * @param optionsFinder
      */
     public void setOptionsFinder(KeyValuesFinder optionsFinder) {
         this.optionsFinder = optionsFinder;
     }
     
     /**
      * Setter that takes in the class name for the options finder and creates a
      * new instance to use as the finder for the attribute field
      * 
      * @param optionsFinderClass
      */
     public void setOptionsFinderClass(Class<? extends KeyValuesFinder> optionsFinderClass) {
         this.optionsFinder = ObjectUtils.newInstance(optionsFinderClass);
     }
         
         public void setAdditionalDisplayAttributeName(String additionalDisplayAttributeName) {
                 this.additionalDisplayAttributeName = additionalDisplayAttributeName;
         }
         
         public String getAdditionalDisplayAttributeName() {
                 return this.additionalDisplayAttributeName;
         }
 
         public void setAlternateDisplayAttributeName(String alternateDisplayAttributeName) {
                 this.alternateDisplayAttributeName = alternateDisplayAttributeName;
         }
         
         public String getAlternateDisplayAttributeName() {
                 return this.alternateDisplayAttributeName;
         }
 
 }

1		/*
2		* Copyright 2005-2008 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
17		package org.kuali.rice.krad.datadictionary;
18
19		import org.apache.commons.lang.ClassUtils;
20		import org.apache.commons.lang.StringUtils;
21		import org.apache.log4j.Logger;
22		import org.kuali.rice.core.api.uif.DataType;
23		import org.kuali.rice.core.api.util.ClassLoaderUtils;
24		import org.kuali.rice.core.web.format.Formatter;
25		import org.kuali.rice.krad.datadictionary.control.ControlDefinition;
26		import org.kuali.rice.krad.datadictionary.exception.AttributeValidationException;
27		import org.kuali.rice.krad.datadictionary.exception.ClassValidationException;
28		import org.kuali.rice.krad.datadictionary.validation.ValidationPattern;
29		import org.kuali.rice.krad.datadictionary.validation.capability.CaseConstrainable;
30		import org.kuali.rice.krad.datadictionary.validation.capability.Formatable;
31		import org.kuali.rice.krad.datadictionary.validation.capability.HierarchicallyConstrainable;
32		import org.kuali.rice.krad.datadictionary.validation.capability.LengthConstrainable;
33		import org.kuali.rice.krad.datadictionary.validation.capability.MustOccurConstrainable;
34		import org.kuali.rice.krad.datadictionary.validation.capability.PrerequisiteConstrainable;
35		import org.kuali.rice.krad.datadictionary.validation.capability.RangeConstrainable;
36		import org.kuali.rice.krad.datadictionary.validation.capability.ValidCharactersConstrainable;
37		import org.kuali.rice.krad.datadictionary.validation.constraint.CaseConstraint;
38		import org.kuali.rice.krad.datadictionary.validation.constraint.LookupConstraint;
39		import org.kuali.rice.krad.datadictionary.validation.constraint.MustOccurConstraint;
40		import org.kuali.rice.krad.datadictionary.validation.constraint.PrerequisiteConstraint;
41		import org.kuali.rice.krad.datadictionary.validation.constraint.ValidCharactersConstraint;
42		import org.kuali.rice.krad.keyvalues.KeyValuesFinder;
43		import org.kuali.rice.krad.uif.control.Control;
44		import org.kuali.rice.krad.util.ObjectUtils;
45
46		import java.util.List;
47
48		/**
49		* A single attribute definition in the DataDictionary, which contains
50		* information relating to the display, validation, and general maintenance of a
51		* specific attribute of an entry.
52		*
53		* @author Kuali Rice Team (rice.collab@kuali.org)
54		*/
55		public class AttributeDefinition extends AttributeDefinitionBase implements CaseConstrainable, PrerequisiteConstrainable, Formatable, HierarchicallyConstrainable, MustOccurConstrainable, LengthConstrainable, RangeConstrainable, ValidCharactersConstrainable {
56		private static final long serialVersionUID = -2490613377818442742L;
57
58	257	protected Boolean forceUppercase = Boolean.FALSE;
59
60		protected DataType dataType;
61
62		protected Integer minLength;
63		protected Integer maxLength;
64		protected Boolean unique;
65
66		protected String exclusiveMin;
67		protected String inclusiveMax;
68
69		@Deprecated
70		protected ValidationPattern validationPattern;
71
72		protected ControlDefinition control;
73
74		// TODO: rename to control once ControlDefinition is removed
75		protected Control controlField;
76
77		protected String formatterClass;
78
79		protected AttributeSecurity attributeSecurity;
80
81		protected Boolean dynamic;
82
83		// KS-style constraints
84		protected String customValidatorClass;
85		protected ValidCharactersConstraint validCharactersConstraint;
86		protected CaseConstraint caseConstraint;
87		protected List<PrerequisiteConstraint> dependencyConstraints;
88		protected List<MustOccurConstraint> mustOccurConstraints;
89		protected LookupConstraint lookupDefinition;// If the user wants to match
90		// against two searches, that search must be defined as well
91		protected String lookupContextPath;
92
93		//TODO: This may not be required since we now use ComplexAttributeDefinition
94		protected String childEntryName;
95
96		private KeyValuesFinder optionsFinder;
97
98		protected String alternateDisplayAttributeName;
99		protected String additionalDisplayAttributeName;
100
101
102	257	public AttributeDefinition() {
103		// Empty
104	257	}
105
106		/**
107		* forceUppercase = convert user entry to uppercase and always display
108		* database value as uppercase.
109		*/
110		public void setForceUppercase(Boolean forceUppercase) {
111	0	this.forceUppercase = forceUppercase;
112	0	}
113
114		public Boolean getForceUppercase() {
115	0	return this.forceUppercase;
116		}
117
118		@Override
119		public Integer getMaxLength() {
120	0	return maxLength;
121		}
122
123		/**
124		* The maxLength element determines the maximum size of the field for data
125		* entry edit purposes and for display purposes.
126		*/
127		public void setMaxLength(Integer maxLength) {
128	0	this.maxLength = maxLength;
129	0	}
130
131		@Override
132		public String getExclusiveMin() {
133	6	return exclusiveMin;
134		}
135
136		/**
137		* The exclusiveMin element determines the minimum allowable value for data
138		* entry editing purposes. Value can be an integer or decimal value such as
139		* -.001 or 99.
140		*/
141		public void setExclusiveMin(String exclusiveMin) {
142	11	this.exclusiveMin = exclusiveMin;
143	11	}
144
145		/**
146		* The inclusiveMax element determines the maximum allowable value for data
147		* entry editing purposes. Value can be an integer or decimal value such as
148		* -.001 or 99.
149		*
150		* JSTL: This field is mapped into the field named "exclusiveMax".
151		*/
152		@Override
153		public String getInclusiveMax() {
154	6	return inclusiveMax;
155		}
156
157		/**
158		* The inclusiveMax element determines the maximum allowable value for data
159		* entry editing purposes. Value can be an integer or decimal value such as
160		* -.001 or 99.
161		*
162		* JSTL: This field is mapped into the field named "exclusiveMax".
163		*/
164		public void setInclusiveMax(String inclusiveMax) {
165	11	this.inclusiveMax = inclusiveMax;
166	11	}
167
168		/**
169		* @return true if a validationPattern has been set
170		*/
171		public boolean hasValidationPattern() {
172	0	return (validationPattern != null);
173		}
174
175		public ValidationPattern getValidationPattern() {
176	0	return this.validationPattern;
177		}
178
179		/**
180		* The validationPattern element defines the allowable character-level or
181		* field-level values for an attribute.
182		*
183		* JSTL: validationPattern is a Map which is accessed using a key of
184		* "validationPattern". Each entry may contain some of the keys listed
185		* below. The keys that may be present for a given attribute are dependent
186		* upon the type of validationPattern.
187		*
188		* maxLength (String) exactLength type allowWhitespace allowUnderscore
189		* allowPeriod validChars precision scale allowNegative
190		*
191		* The allowable keys (in addition to type) for each type are: Type****
192		* *Keys* alphanumeric exactLength maxLength allowWhitespace
193		* allowUnderscore allowPeriod
194		*
195		* alpha exactLength maxLength allowWhitespace
196		*
197		* anyCharacter exactLength maxLength allowWhitespace
198		*
199		* charset validChars
200		*
201		* numeric exactLength maxLength
202		*
203		* fixedPoint allowNegative precision scale
204		*
205		* floatingPoint allowNegative
206		*
207		* date n/a emailAddress n/a javaClass n/a month n/a phoneNumber n/a
208		* timestamp n/a year n/a zipcode n/a
209		*
210		* Note: maxLength and exactLength are mutually exclusive. If one is
211		* entered, the other may not be entered.
212		*
213		* Note: See ApplicationResources.properties for exact regex patterns. e.g.
214		* validationPatternRegex.date for regex used in date validation.
215		*/
216		public void setValidationPattern(ValidationPattern validationPattern) {
217	0	this.validationPattern = validationPattern;
218
219		// FIXME: JLR - need to recreate this functionality using the ValidCharsConstraint logic
220	0	}
221
222
223		/**
224		* @return control
225		*/
226		public ControlDefinition getControl() {
227	0	return control;
228		}
229
230		/**
231		* The control element defines the manner in which an attribute is displayed
232		* and the manner in which the attribute value is entered.
233		*
234		* JSTL: control is a Map representing an HTML control. It is accessed using
235		* a key of "control". The table below shows the types of entries associated
236		* with each type of control.
237		*
238		Control Type Key Value checkbox checkbox boolean String
239		*
240		* hidden hidden boolean String
241		*
242		* radio radio boolean String valuesFinder valuesFinder class name
243		* dataObjectClass String keyAttribute String labelAttribute String
244		* includeKeyInLabel boolean String
245		*
246		* select select boolean String valuesFinder valuesFinder class name
247		* dataObjectClass String keyAttribute String labelAttribute String
248		* includeBlankRow boolean String includeKeyInLabel boolean String
249		*
250		* apcSelect apcSelect boolean String paramNamespace String
251		* parameterDetailType String parameterName String
252		*
253		* text text boolean String size String
254		*
255		* textarea textarea boolean String rows cols
256		*
257		* currency currency boolean String size String formattedMaxLength String
258		*
259		* kualiUser kualiUser boolean String universalIdAttributeName String
260		* userIdAttributeName String personNameAttributeName String
261		*
262		* lookupHidden lookupHidden boolean String
263		*
264		* lookupReadonly lookupReadonly boolean String
265		*
266		* @param control
267		* @throws IllegalArgumentException
268		* if the given control is null
269		*/
270		public void setControl(ControlDefinition control) {
271	0	if (control == null) {
272	0	throw new IllegalArgumentException("invalid (null) control");
273		}
274	0	this.control = control;
275	0	}
276
277		public boolean hasFormatterClass() {
278	0	return (formatterClass != null);
279		}
280
281		@Override
282		public String getFormatterClass() {
283	16	return formatterClass;
284		}
285
286		/**
287		* The formatterClass element is used when custom formatting is required for
288		* display of the field value. This field specifies the name of the java
289		* class to be used for the formatting. About 15 different classes are
290		* available including BooleanFormatter, CurrencyFormatter, DateFormatter,
291		* etc.
292		*/
293		public void setFormatterClass(String formatterClass) {
294	0	if (formatterClass == null) {
295	0	throw new IllegalArgumentException("invalid (null) formatterClass");
296		}
297	0	this.formatterClass = formatterClass;
298	0	}
299
300		/**
301		* Directly validate simple fields, call completeValidation on Definition
302		* fields.
303		*
304		* @see org.kuali.rice.krad.datadictionary.DataDictionaryEntry#completeValidation()
305		*/
306		@Override
307		public void completeValidation(Class<?> rootObjectClass, Class<?> otherObjectClass) {
308		try {
309	0	if (!DataDictionary.isPropertyOf(rootObjectClass, getName())) {
310	0	throw new AttributeValidationException("property '" + getName() + "' is not a property of class '"
311		+ rootObjectClass.getName() + "' (" + "" + ")");
312		}
313
314		//TODO currently requiring a control or controlField, but this should not be case (AttrField should probably do the check)
315	0	if (getControl() == null && getControlField() == null) {
316	0	throw new AttributeValidationException("property '" + getName() + "' in class '"
317		+ rootObjectClass.getName() + " does not have a control defined");
318		}
319
320	0	if(getControl() != null) {
321	0	getControl().completeValidation(rootObjectClass, otherObjectClass);
322		}
323
324	0	if (attributeSecurity != null) {
325	0	attributeSecurity.completeValidation(rootObjectClass, otherObjectClass);
326		}
327
328	0	if (validationPattern != null) {
329	0	validationPattern.completeValidation();
330		}
331
332	0	if (formatterClass != null) {
333		try {
334	0	Class formatterClassObject = ClassUtils.getClass(ClassLoaderUtils.getDefaultClassLoader(),
335		getFormatterClass());
336	0	if (!Formatter.class.isAssignableFrom(formatterClassObject)) {
337	0	throw new ClassValidationException("formatterClass is not a valid instance of "
338		+ Formatter.class.getName() + " instead was: " + formatterClassObject.getName());
339		}
340		}
341	0	catch (ClassNotFoundException e) {
342	0	throw new ClassValidationException("formatterClass could not be found: " + getFormatterClass(), e);
343	0	}
344		}
345		}
346	0	catch (RuntimeException ex) {
347	0	Logger.getLogger(getClass()).error(
348		"Unable to validate attribute " + rootObjectClass + "." + getName() + ": " + ex.getMessage(), ex);
349	0	throw ex;
350	0	}
351	0	}
352
353		/**
354		* @see java.lang.Object#toString()
355		*/
356		@Override
357		public String toString() {
358	0	return "AttributeDefinition for attribute " + getName();
359		}
360
361		/**
362		* @return the attributeSecurity
363		*/
364		public AttributeSecurity getAttributeSecurity() {
365	0	return this.attributeSecurity;
366		}
367
368		/**
369		* @param attributeSecurity
370		* the attributeSecurity to set
371		*/
372		public void setAttributeSecurity(AttributeSecurity attributeSecurity) {
373	0	this.attributeSecurity = attributeSecurity;
374	0	}
375
376		public boolean hasAttributeSecurity() {
377	0	return (attributeSecurity != null);
378		}
379
380		/**
381		* This overridden method ...
382		*
383		* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
384		*/
385		@Override
386		public void afterPropertiesSet() throws Exception {
387	0	if (StringUtils.isEmpty(name)) {
388	0	throw new RuntimeException("blank name for bean: " + id);
389		}
390	0	}
391
392		/**
393		* @return the unique
394		*/
395		public Boolean getUnique() {
396	0	return this.unique;
397		}
398
399		/**
400		* @param unique
401		* the unique to set
402		*/
403		public void setUnique(Boolean unique) {
404	0	this.unique = unique;
405	0	}
406
407		/**
408		* Default <code>Control</code> to use when the attribute is to be rendered
409		* for the UI. Used by the UIF when a control is not defined for an
410		* <code>AttributeField</code>
411		*
412		* @return Control instance
413		*/
414		public Control getControlField() {
415	0	return this.controlField;
416		}
417
418		/**
419		* Setter for the default control
420		*
421		* @param controlField
422		*/
423		public void setControlField(Control controlField) {
424	0	this.controlField = controlField;
425	0	}
426
427		/**
428		* @return the minLength
429		*/
430		public Integer getMinLength() {
431	0	return this.minLength;
432		}
433
434		/**
435		* @param minLength the minLength to set
436		*/
437		public void setMinLength(Integer minLength) {
438	0	this.minLength = minLength;
439	0	}
440
441		/**
442		* @return the dataType
443		*/
444		@Override
445		public DataType getDataType() {
446	8	return this.dataType;
447		}
448
449		/**
450		* @param dataType the dataType to set
451		*/
452		public void setDataType(DataType dataType) {
453	11	this.dataType = dataType;
454	11	}
455
456		public void setDataType(String dataType) {
457	0	this.dataType = DataType.valueOf(dataType);
458	0	}
459
460		/**
461		* @return the customValidatorClass
462		*/
463		public String getCustomValidatorClass() {
464	0	return this.customValidatorClass;
465		}
466
467		/**
468		* @param customValidatorClass the customValidatorClass to set
469		*/
470		public void setCustomValidatorClass(String customValidatorClass) {
471	0	this.customValidatorClass = customValidatorClass;
472	0	}
473
474		/**
475		* @return the validChars
476		*/
477		@Override
478		public ValidCharactersConstraint getValidCharactersConstraint() {
479	0	return this.validCharactersConstraint;
480		}
481
482		/**
483		* @param validCharactersConstraint the validChars to set
484		*/
485		public void setValidCharactersConstraint(ValidCharactersConstraint validCharactersConstraint) {
486	109	this.validCharactersConstraint = validCharactersConstraint;
487	109	}
488
489		/**
490		* @return the caseConstraint
491		*/
492		@Override
493		public CaseConstraint getCaseConstraint() {
494	0	return this.caseConstraint;
495		}
496
497		/**
498		* @param caseConstraint the caseConstraint to set
499		*/
500		public void setCaseConstraint(CaseConstraint caseConstraint) {
501	5	this.caseConstraint = caseConstraint;
502	5	}
503
504		/**
505		* @return the requireConstraint
506		*/
507		@Override
508		public List<PrerequisiteConstraint> getPrerequisiteConstraints() {
509	0	return this.dependencyConstraints;
510		}
511
512		/**
513		* @param dependencyConstraints the requireConstraint to set
514		*/
515		public void setPrerequisiteConstraints(List<PrerequisiteConstraint> dependencyConstraints) {
516	5	this.dependencyConstraints = dependencyConstraints;
517	5	}
518
519		/**
520		* @return the occursConstraint
521		*/
522		@Override
523		public List<MustOccurConstraint> getMustOccurConstraints() {
524	0	return this.mustOccurConstraints;
525		}
526
527		/**
528		* @param mustOccurConstraints the occursConstraint to set
529		*/
530		public void setMustOccurConstraints(List<MustOccurConstraint> mustOccurConstraints) {
531	0	this.mustOccurConstraints = mustOccurConstraints;
532	0	}
533
534		/**
535		* @return the lookupDefinition
536		*/
537		public LookupConstraint getLookupDefinition() {
538	0	return this.lookupDefinition;
539		}
540
541		/**
542		* @param lookupDefinition the lookupDefinition to set
543		*/
544		public void setLookupDefinition(LookupConstraint lookupDefinition) {
545	0	this.lookupDefinition = lookupDefinition;
546	0	}
547
548		/**
549		* @return the lookupContextPath
550		*/
551		public String getLookupContextPath() {
552	0	return this.lookupContextPath;
553		}
554
555		/**
556		* @param lookupContextPath the lookupContextPath to set
557		*/
558		public void setLookupContextPath(String lookupContextPath) {
559	0	this.lookupContextPath = lookupContextPath;
560	0	}
561
562		/**
563		* @return the childEntryName
564		*/
565		public String getChildEntryName() {
566	0	return this.childEntryName;
567		}
568
569		/**
570		* @param childEntryName the childEntryName to set
571		*/
572		public void setChildEntryName(String childEntryName) {
573	0	this.childEntryName = childEntryName;
574	0	}
575
576		/**
577		* @return the constraintMessage
578		*/
579		public String getConstraint() {
580	0	return this.constraint;
581		}
582
583		/**
584		* @param constraintMessage the constraintMessage to set
585		*/
586		public void setConstraint(String constraint) {
587	0	this.constraint = constraint;
588	0	}
589
590		/**
591		* Instance of <code>KeyValluesFinder</code> that should be invoked to
592		* provide a List of values the field can have. Generally used to provide
593		* the options for a multi-value control or to validate the submitted field
594		* value
595		*
596		* @return KeyValuesFinder instance
597		*/
598		public KeyValuesFinder getOptionsFinder() {
599	0	return this.optionsFinder;
600		}
601
602		/**
603		* Setter for the field's KeyValuesFinder instance
604		*
605		* @param optionsFinder
606		*/
607		public void setOptionsFinder(KeyValuesFinder optionsFinder) {
608	0	this.optionsFinder = optionsFinder;
609	0	}
610
611		/**
612		* Setter that takes in the class name for the options finder and creates a
613		* new instance to use as the finder for the attribute field
614		*
615		* @param optionsFinderClass
616		*/
617		public void setOptionsFinderClass(Class<? extends KeyValuesFinder> optionsFinderClass) {
618	0	this.optionsFinder = ObjectUtils.newInstance(optionsFinderClass);
619	0	}
620
621		public void setAdditionalDisplayAttributeName(String additionalDisplayAttributeName) {
622	0	this.additionalDisplayAttributeName = additionalDisplayAttributeName;
623	0	}
624
625		public String getAdditionalDisplayAttributeName() {
626	0	return this.additionalDisplayAttributeName;
627		}
628
629		public void setAlternateDisplayAttributeName(String alternateDisplayAttributeName) {
630	0	this.alternateDisplayAttributeName = alternateDisplayAttributeName;
631	0	}
632
633		public String getAlternateDisplayAttributeName() {
634	0	return this.alternateDisplayAttributeName;
635		}
636
637		}