Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

AttributeDefinition

0/90

0/32

1.65

 /*
  * 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.kns.datadictionary;
 
 import java.math.BigDecimal;
 
 import org.apache.commons.lang.ClassUtils;
 import org.apache.commons.lang.StringUtils;
 import org.apache.log4j.Logger;
 import org.kuali.rice.core.util.ClassLoaderUtils;
 import org.kuali.rice.core.web.format.Formatter;
 import org.kuali.rice.kns.datadictionary.control.ControlDefinition;
 import org.kuali.rice.kns.datadictionary.exception.AttributeValidationException;
 import org.kuali.rice.kns.datadictionary.exception.ClassValidationException;
 import org.kuali.rice.kns.datadictionary.validation.ValidationPattern;
 import org.springframework.beans.factory.InitializingBean;
 
 
 /**
  * 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.
  * 
  * 
  */
 public class AttributeDefinition extends DataDictionaryDefinitionBase implements InitializingBean {
     private static final long serialVersionUID = -2490613377818442742L;
 
         protected Boolean forceUppercase = Boolean.FALSE;
 
     protected String name;
     protected String label;
     protected String shortLabel;
     protected String displayLabelAttribute;
 
     protected Integer maxLength;
     protected Boolean unique;
     
     protected BigDecimal exclusiveMin;
     protected BigDecimal inclusiveMax;
 
     protected ValidationPattern validationPattern;
     protected Boolean required = Boolean.FALSE;
 
     protected ControlDefinition control;
 
     protected String summary;
     protected String description;
 
     protected String formatterClass;
 
     protected AttributeSecurity attributeSecurity;
 
     public AttributeDefinition() {}
 
 
     /**
         * 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;
     }
 
     public String getName() {
         return name;
     }
 
     /*
      * name = name of attribute
      */
     public void setName(String name) {
         if (StringUtils.isBlank(name)) {
             throw new IllegalArgumentException("invalid (blank) name");
         }
         this.name = name;
     }
 
     public String getLabel() {
         return label;
     }
 
     /**
                     The label element is the field or collection name that will be shown on inquiry and
                     maintenance screens.
                     This will be overridden by presence of displayLabelAttribute element.
      */
     public void setLabel(String label) {
         if (StringUtils.isBlank(label)) {
             throw new IllegalArgumentException("invalid (blank) label");
         }
         this.label = label;
     }
 
     /**
      * @return the shortLabel, or the label if no shortLabel has been set
      */
     public String getShortLabel() {
         return (shortLabel != null) ? shortLabel : getLabel();
     }
 
     /**
      * @return the shortLabel directly, without substituting in the label
      */
     protected String getDirectShortLabel() {
         return shortLabel;
     }
 
     /**
                     The shortLabel element is the field or collection name that will be used
                     in applications when a shorter name (than the label element) is required.
                     This will be overridden by presence of displayLabelAttribute element.
      */
     public void setShortLabel(String shortLabel) {
         if (StringUtils.isBlank(shortLabel)) {
             throw new IllegalArgumentException("invalid (blank) shortLabel");
         }
         this.shortLabel = shortLabel;
     }
 
     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;
     }
 
     public BigDecimal 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(BigDecimal 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".
      */
     public BigDecimal 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(BigDecimal 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;
     }
 
 
     /**
                     The required element allows values of "true" or "false".
                     A value of "true" indicates that a value must be entered for this
                     business object when creating or editing a new business object.
      */
     public void setRequired(Boolean required) {
         this.required = required;
     }
 
     public Boolean isRequired() {
         return this.required;
     }
 
 
     /**
      * @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
                                         businessObjectClass String
                                         keyAttribute        String
                                         labelAttribute      String
                                         includeKeyInLabel   boolean String
 
                     select              select              boolean String
                                         valuesFinder        valuesFinder class name
                                         businessObjectClass String
                                         keyAttribute        String
                                         labelAttribute      String
                                         includeBlankRow                boolean String
                                         includeKeyInLabel   boolean 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 String getSummary() {
         return summary;
     }
 
     /**
                       The summary element is used to provide a short description of the
                       attribute or collection.  This is designed to be used for help purposes.
      */
     public void setSummary(String summary) {
         this.summary = summary;
     }
 
     public String getDescription() {
         return description;
     }
 
     /**
      *                       The description element is used to provide a long description of the
                       attribute or collection.  This is designed to be used for help purposes.
      */
     public void setDescription(String description) {
         this.description = description;
     }
 
     public boolean hasFormatterClass() {
         return (formatterClass != null);
     }
 
     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.kns.datadictionary.DataDictionaryEntry#completeValidation()
      */
     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() + "' (" + "" + ")");
             }
     
             if ( getControl() == null ) {
                 throw new AttributeValidationException( "property '" + getName() + "' in class '" + rootObjectClass.getName() + " does not have a control defined" );
             }
             
             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();
     }
 
 
     public String getDisplayLabelAttribute() {
         return displayLabelAttribute;
     }
 
 
     /**
                     The displayLabelAttribute element is used to indicate that the
                     label and short label should be obtained from another attribute.
 
                     The label element and short label element defined for this attribute
                     will be overridden.  Instead, the label and short label values
                     will be obtained by referencing the corresponding values from the
                     attribute indicated by this element.
      */
     public void setDisplayLabelAttribute(String displayLabelAttribute) {
         this.displayLabelAttribute = displayLabelAttribute;
     }
 
 
         /**
          * @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()
      */
     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;
         }
 }

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.kns.datadictionary;
18
19		import java.math.BigDecimal;
20
21		import org.apache.commons.lang.ClassUtils;
22		import org.apache.commons.lang.StringUtils;
23		import org.apache.log4j.Logger;
24		import org.kuali.rice.core.util.ClassLoaderUtils;
25		import org.kuali.rice.core.web.format.Formatter;
26		import org.kuali.rice.kns.datadictionary.control.ControlDefinition;
27		import org.kuali.rice.kns.datadictionary.exception.AttributeValidationException;
28		import org.kuali.rice.kns.datadictionary.exception.ClassValidationException;
29		import org.kuali.rice.kns.datadictionary.validation.ValidationPattern;
30		import org.springframework.beans.factory.InitializingBean;
31
32
33		/**
34		* A single attribute definition in the DataDictionary, which contains information relating to the display, validation, and general
35		* maintenance of a specific attribute of an entry.
36		*
37		*
38		*/
39		public class AttributeDefinition extends DataDictionaryDefinitionBase implements InitializingBean {
40		private static final long serialVersionUID = -2490613377818442742L;
41
42	0	protected Boolean forceUppercase = Boolean.FALSE;
43
44		protected String name;
45		protected String label;
46		protected String shortLabel;
47		protected String displayLabelAttribute;
48
49		protected Integer maxLength;
50		protected Boolean unique;
51
52		protected BigDecimal exclusiveMin;
53		protected BigDecimal inclusiveMax;
54
55		protected ValidationPattern validationPattern;
56	0	protected Boolean required = Boolean.FALSE;
57
58		protected ControlDefinition control;
59
60		protected String summary;
61		protected String description;
62
63		protected String formatterClass;
64
65		protected AttributeSecurity attributeSecurity;
66
67	0	public AttributeDefinition() {}
68
69
70		/**
71		* forceUppercase = convert user entry to uppercase and always display
72		database value as uppercase.
73		*/
74		public void setForceUppercase(Boolean forceUppercase) {
75	0	this.forceUppercase = forceUppercase;
76	0	}
77
78		public Boolean getForceUppercase() {
79	0	return this.forceUppercase;
80		}
81
82		public String getName() {
83	0	return name;
84		}
85
86		/*
87		* name = name of attribute
88		*/
89		public void setName(String name) {
90	0	if (StringUtils.isBlank(name)) {
91	0	throw new IllegalArgumentException("invalid (blank) name");
92		}
93	0	this.name = name;
94	0	}
95
96		public String getLabel() {
97	0	return label;
98		}
99
100		/**
101		The label element is the field or collection name that will be shown on inquiry and
102		maintenance screens.
103		This will be overridden by presence of displayLabelAttribute element.
104		*/
105		public void setLabel(String label) {
106	0	if (StringUtils.isBlank(label)) {
107	0	throw new IllegalArgumentException("invalid (blank) label");
108		}
109	0	this.label = label;
110	0	}
111
112		/**
113		* @return the shortLabel, or the label if no shortLabel has been set
114		*/
115		public String getShortLabel() {
116	0	return (shortLabel != null) ? shortLabel : getLabel();
117		}
118
119		/**
120		* @return the shortLabel directly, without substituting in the label
121		*/
122		protected String getDirectShortLabel() {
123	0	return shortLabel;
124		}
125
126		/**
127		The shortLabel element is the field or collection name that will be used
128		in applications when a shorter name (than the label element) is required.
129		This will be overridden by presence of displayLabelAttribute element.
130		*/
131		public void setShortLabel(String shortLabel) {
132	0	if (StringUtils.isBlank(shortLabel)) {
133	0	throw new IllegalArgumentException("invalid (blank) shortLabel");
134		}
135	0	this.shortLabel = shortLabel;
136	0	}
137
138		public Integer getMaxLength() {
139	0	return maxLength;
140		}
141
142		/**
143		The maxLength element determines the maximum size of the field
144		for data entry edit purposes and for display purposes.
145		*/
146		public void setMaxLength(Integer maxLength) {
147	0	this.maxLength = maxLength;
148	0	}
149
150		public BigDecimal getExclusiveMin() {
151	0	return exclusiveMin;
152		}
153
154		/**
155		The exclusiveMin element determines the minimum allowable value
156		for data entry editing purposes. Value can be an integer or decimal
157		value such as -.001 or 99.
158		*/
159		public void setExclusiveMin(BigDecimal exclusiveMin) {
160	0	this.exclusiveMin = exclusiveMin;
161	0	}
162
163		/**
164		The inclusiveMax element determines the maximum allowable value
165		for data entry editing purposes. Value can be an integer or decimal
166		value such as -.001 or 99.
167
168		JSTL: This field is mapped into the field named "exclusiveMax".
169		*/
170		public BigDecimal getInclusiveMax() {
171	0	return inclusiveMax;
172		}
173
174		/**
175		The inclusiveMax element determines the maximum allowable value
176		for data entry editing purposes. Value can be an integer or decimal
177		value such as -.001 or 99.
178
179		JSTL: This field is mapped into the field named "exclusiveMax".
180		*/
181		public void setInclusiveMax(BigDecimal inclusiveMax) {
182	0	this.inclusiveMax = inclusiveMax;
183	0	}
184
185		/**
186		* @return true if a validationPattern has been set
187		*/
188		public boolean hasValidationPattern() {
189	0	return (validationPattern != null);
190		}
191
192		public ValidationPattern getValidationPattern() {
193	0	return this.validationPattern;
194		}
195
196		/**
197		The validationPattern element defines the allowable character-level
198		or field-level values for an attribute.
199
200		JSTL: validationPattern is a Map which is accessed using a key
201		of "validationPattern". Each entry may contain some of the keys
202		listed below. The keys that may be present for a given attribute
203		are dependent upon the type of validationPattern.
204
205		* maxLength (String)
206		* exactLength
207		* type
208		* allowWhitespace
209		* allowUnderscore
210		* allowPeriod
211		* validChars
212		* precision
213		* scale
214		* allowNegative
215
216		The allowable keys (in addition to type) for each type are:
217		**Type Keys**
218		alphanumeric exactLength
219		maxLength
220		allowWhitespace
221		allowUnderscore
222		allowPeriod
223
224		alpha exactLength
225		maxLength
226		allowWhitespace
227
228		anyCharacter exactLength
229		maxLength
230		allowWhitespace
231
232		charset validChars
233
234		numeric exactLength
235		maxLength
236
237		fixedPoint allowNegative
238		precision
239		scale
240
241		floatingPoint allowNegative
242
243		date n/a
244		emailAddress n/a
245		javaClass n/a
246		month n/a
247		phoneNumber n/a
248		timestamp n/a
249		year n/a
250		zipcode n/a
251
252		Note: maxLength and exactLength are mutually exclusive.
253		If one is entered, the other may not be entered.
254
255		Note: See ApplicationResources.properties for
256		exact regex patterns.
257		e.g. validationPatternRegex.date for regex used in date validation.
258		*/
259		public void setValidationPattern(ValidationPattern validationPattern) {
260	0	this.validationPattern = validationPattern;
261	0	}
262
263
264		/**
265		The required element allows values of "true" or "false".
266		A value of "true" indicates that a value must be entered for this
267		business object when creating or editing a new business object.
268		*/
269		public void setRequired(Boolean required) {
270	0	this.required = required;
271	0	}
272
273		public Boolean isRequired() {
274	0	return this.required;
275		}
276
277
278		/**
279		* @return control
280		*/
281		public ControlDefinition getControl() {
282	0	return control;
283		}
284
285		/**
286		* The control element defines the manner in which an attribute is
287		displayed and the manner in which the attribute value is entered.
288
289		JSTL: control is a Map representing an HTML control. It is accessed
290		using a key of "control". The table below shows the types of entries
291		associated with each type of control.
292
293		Control Type Key Value
294		checkbox checkbox boolean String
295
296		hidden hidden boolean String
297
298		radio radio boolean String
299		valuesFinder valuesFinder class name
300		businessObjectClass String
301		keyAttribute String
302		labelAttribute String
303		includeKeyInLabel boolean String
304
305		select select boolean String
306		valuesFinder valuesFinder class name
307		businessObjectClass String
308		keyAttribute String
309		labelAttribute String
310		includeBlankRow boolean String
311		includeKeyInLabel boolean String
312
313		text text boolean String
314		size String
315
316		textarea textarea boolean String
317		rows
318		cols
319
320		currency currency boolean String
321		size String
322		formattedMaxLength String
323
324		kualiUser kualiUser boolean String
325		universalIdAttributeName String
326		userIdAttributeName String
327		personNameAttributeName String
328
329		lookupHidden lookupHidden boolean String
330
331		lookupReadonly lookupReadonly boolean String
332
333		* @param control
334		* @throws IllegalArgumentException if the given control is null
335		*/
336		public void setControl(ControlDefinition control) {
337	0	if (control == null) {
338	0	throw new IllegalArgumentException("invalid (null) control");
339		}
340	0	this.control = control;
341	0	}
342
343		public String getSummary() {
344	0	return summary;
345		}
346
347		/**
348		The summary element is used to provide a short description of the
349		attribute or collection. This is designed to be used for help purposes.
350		*/
351		public void setSummary(String summary) {
352	0	this.summary = summary;
353	0	}
354
355		public String getDescription() {
356	0	return description;
357		}
358
359		/**
360		* The description element is used to provide a long description of the
361		attribute or collection. This is designed to be used for help purposes.
362		*/
363		public void setDescription(String description) {
364	0	this.description = description;
365	0	}
366
367		public boolean hasFormatterClass() {
368	0	return (formatterClass != null);
369		}
370
371		public String getFormatterClass() {
372	0	return formatterClass;
373		}
374
375		/**
376		The formatterClass element is used when custom formatting is
377		required for display of the field value. This field specifies
378		the name of the java class to be used for the formatting. About
379		15 different classes are available including BooleanFormatter,
380		CurrencyFormatter, DateFormatter, etc.
381		*/
382		public void setFormatterClass(String formatterClass) {
383	0	if (formatterClass == null) {
384	0	throw new IllegalArgumentException("invalid (null) formatterClass");
385		}
386	0	this.formatterClass = formatterClass;
387	0	}
388
389		/**
390		* Directly validate simple fields, call completeValidation on Definition fields.
391		*
392		* @see org.kuali.rice.kns.datadictionary.DataDictionaryEntry#completeValidation()
393		*/
394		public void completeValidation(Class rootObjectClass, Class otherObjectClass) {
395		try {
396	0	if (!DataDictionary.isPropertyOf(rootObjectClass, getName())) {
397	0	throw new AttributeValidationException("property '" + getName() + "' is not a property of class '" + rootObjectClass.getName() + "' (" + "" + ")");
398		}
399
400	0	if ( getControl() == null ) {
401	0	throw new AttributeValidationException( "property '" + getName() + "' in class '" + rootObjectClass.getName() + " does not have a control defined" );
402		}
403
404	0	getControl().completeValidation(rootObjectClass, otherObjectClass);
405
406	0	if(attributeSecurity != null){
407	0	attributeSecurity.completeValidation(rootObjectClass, otherObjectClass);
408		}
409
410	0	if (validationPattern != null) {
411	0	validationPattern.completeValidation();
412		}
413
414	0	if (formatterClass != null) {
415		try {
416	0	Class formatterClassObject = ClassUtils.getClass(ClassLoaderUtils.getDefaultClassLoader(), getFormatterClass());
417	0	if (!Formatter.class.isAssignableFrom(formatterClassObject)) {
418	0	throw new ClassValidationException("formatterClass is not a valid instance of " + Formatter.class.getName() + " instead was: " + formatterClassObject.getName());
419		}
420	0	} catch (ClassNotFoundException e) {
421	0	throw new ClassValidationException("formatterClass could not be found: " + getFormatterClass(), e);
422	0	}
423		}
424	0	} catch ( RuntimeException ex ) {
425	0	Logger.getLogger(getClass()).error("Unable to validate attribute " + rootObjectClass + "." + getName() + ": " + ex.getMessage(), ex );
426	0	throw ex;
427	0	}
428	0	}
429
430
431		/**
432		* @see java.lang.Object#toString()
433		*/
434		@Override
435		public String toString() {
436	0	return "AttributeDefinition for attribute " + getName();
437		}
438
439
440		public String getDisplayLabelAttribute() {
441	0	return displayLabelAttribute;
442		}
443
444
445		/**
446		The displayLabelAttribute element is used to indicate that the
447		label and short label should be obtained from another attribute.
448
449		The label element and short label element defined for this attribute
450		will be overridden. Instead, the label and short label values
451		will be obtained by referencing the corresponding values from the
452		attribute indicated by this element.
453		*/
454		public void setDisplayLabelAttribute(String displayLabelAttribute) {
455	0	this.displayLabelAttribute = displayLabelAttribute;
456	0	}
457
458
459		/**
460		* @return the attributeSecurity
461		*/
462		public AttributeSecurity getAttributeSecurity() {
463	0	return this.attributeSecurity;
464		}
465
466
467		/**
468		* @param attributeSecurity the attributeSecurity to set
469		*/
470		public void setAttributeSecurity(AttributeSecurity attributeSecurity) {
471	0	this.attributeSecurity = attributeSecurity;
472	0	}
473
474		public boolean hasAttributeSecurity() {
475	0	return (attributeSecurity != null);
476		}
477
478
479		/**
480		* This overridden method ...
481		*
482		* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
483		*/
484		public void afterPropertiesSet() throws Exception {
485	0	if ( StringUtils.isEmpty(name) ) {
486	0	throw new RuntimeException( "blank name for bean: " + id );
487		}
488
489	0	}
490
491
492		/**
493		* @return the unique
494		*/
495		public Boolean getUnique() {
496	0	return this.unique;
497		}
498
499
500		/**
501		* @param unique the unique to set
502		*/
503		public void setUnique(Boolean unique) {
504	0	this.unique = unique;
505	0	}
506		}