Coverage Report

Coverage Report - org.kuali.student.common.assembly.data.MetadataInterrogator

Classes in this File

Line Coverage

Branch Coverage

Complexity

MetadataInterrogator

0/194

0/190

4.485

MetadataInterrogator$ConstraintIds

0/6

N/A

4.485

 /**
  * Copyright 2010 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.osedu.org/licenses/ECL-2.0
  *
  * 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.student.common.assembly.data;
 
 import java.util.Date;
 import java.util.List;
 
 import org.kuali.student.common.validator.DateParser;
 
 /**
  * 
  * @author nwright
  */
 public class MetadataInterrogator {
 
         public enum ConstraintIds {
                 MULTI_LINE_TEXT("multi.line.text"), RICH_TEXT("rich.text");
                 private final String id;
 
                 private ConstraintIds(final String id) {
                         this.id = id;
                 }
 
                 public String getId() {
                         return this.id;
                 }
         }
 
         private Metadata meta;
 
         public MetadataInterrogator(Metadata meta) {
                 this.meta = meta;
         }
 
         /**
          * Returns true if the metadata contains the specified constraint
          */
         public boolean hasConstraint(String id) {
                 return hasConstraint(meta, id);
         }
 
 
         /**
          * checks if is required
          * 
          * @return true if any minOccurs > 1
          */
         public boolean isRequired() {
                 return isRequired(meta);
         }
 
         /**
          * get the largest min occurs value
          * 
          * @return null if none specified
          */
         public Integer getLargestMinOccurs() {
                 return getLargestMinOccurs(meta);
         }
 
         /**
          * checks if this field is a repeating field
          * 
          * @return true if the smallest maxOccurs is > 1
          */
         public boolean isRepeating() {
                 return isRepeating(meta);
         }
 
         /**
          * checks if this field is a repeating field
          * 
          * @return true if the smallest maxOccurs is > 1
          */
         public Integer getSmallestMaxOccurs() {
                 return getSmallestMaxOccurs(meta);
         }
 
         /**
          * get the largest min occurs value
          * 
          * @return null if none specified
          */
         public Integer getLargestMinLength() {
                 return getLargestMinLength(meta);
         }
 
         public Integer getSmallestMaxLength() {
                 return getSmallestMaxLength(meta);
         }
 
         public boolean isMultilined() {
                 return isMultilined(meta);
         }
 
         
         /**
          * Returns true if the metadata contains the specified constraint
          */
         public static boolean hasConstraint(Metadata meta, ConstraintIds id) {
                 return hasConstraint(meta, id.getId());
         }
         /**
          * Returns true if the metadata contains the specified constraint
          */
         public static boolean hasConstraint(Metadata meta, String id) {
                 boolean result = false;
                 if (meta != null && meta.getConstraints() != null) {
                         result = containsConstraint(meta.getConstraints(), id);
                 }
                 return result;
         }
 
         private static boolean containsConstraint(List<ConstraintMetadata> constraints,
                         String id) {
                 boolean result = false;
                 if (constraints != null) {
                         for (ConstraintMetadata con : constraints) {
                                 if ((con.getId() != null && con.getId().equals(id))
                                                 || containsConstraint(con.getChildConstraints(), id)) {
                                         result = true;
                                         break;
                                 }
                         }
                 }
                 return result;
         }
 
         /**
          * checks if is required
          * 
          * @return true if any minOccurs > 1
          */
         public static boolean isRequired(Metadata meta) {
                 if (meta == null) {
                         return false;
                 }
                 Integer largestMinOccurs = getLargestMinOccurs(meta);
                 // no min occurs specified so not required
                 if (largestMinOccurs == null) {
                         return false;
                 }
                 if (largestMinOccurs >= 1) {
                         return true;
                 }
                 return false;
         }
 
         /**
          * Use to determine if the field is required for the next state.
          * 
          * @param meta
          * @return
          */
         public static boolean isRequiredForNextState(Metadata meta){
                 boolean required = false;
                 
                 if(meta == null){
                         return false;
                 }
                 //This flag is only set when using the new dictionary, in which case there should
                 //never be more than one constraint.
                 if (meta.getConstraints() != null && meta.getConstraints().size() == 1){
                         ConstraintMetadata constraint =  meta.getConstraints().get(0);
                         required = constraint.isRequiredForNextState();
                 }
                 
                 return required;
         }
         
         /**
          * Use to determine if the field is required for the next state.
          * 
          * @param meta
          * @return
          */
         public static String getNextState(Metadata meta){
                 String state = null;
                 
                 if(meta == null){
                         return state;
                 }
                 //This flag is only set when using the new dictionary, in which case there should
                 //never be more than one constraint.
                 if (meta.getConstraints() != null && meta.getConstraints().size() == 1){
                         ConstraintMetadata constraint =  meta.getConstraints().get(0);
                         state = constraint.getNextState();
                 }
                 
                 return state;
         }
         
         /**
          * get the largest min occurs value
          * 
          * @return null if none specified
          */
         public static Integer getLargestMinOccurs(Metadata meta) {
                 if (meta == null) {
                         return null;
                 }
                 Integer largestMinOccurs = null;
                 // TODO: worry aboutg special validators
                 // TODO: worry about how this applies to non-strings?
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         if (cons.getMinOccurs() != null) {
                                 if (largestMinOccurs == null) {
                                         largestMinOccurs = cons.getMinOccurs();
                                 } else if (cons.getMinOccurs() > largestMinOccurs) {
                                         largestMinOccurs = cons.getMinOccurs();
                                 }
                         }
                 }
                 return largestMinOccurs;
         }
 
         /**
          * checks if this field is a repeating field
          * 
          * @return true if the smallest maxOccurs is > 1
          */
         public static boolean isRepeating(Metadata meta) {
                 if (meta == null) {
                         return false;
                 }
                 Integer smallestMaxOccurs = getSmallestMaxOccurs(meta);
                 if (hasRepeatingConstraint(meta) ||
                                 (smallestMaxOccurs != null && smallestMaxOccurs > 1)) {
                         return true;
                 }
                 return false;
         }
         
         private static boolean hasRepeatingConstraint(Metadata meta) {
                 boolean isRepeating = false;
 
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         if ("repeating".equals(cons.getId())){
                                 isRepeating = true;
                         }
                 }
                 return isRepeating;
         }
 
         /**
          * Returns the smallest max occurs
          * 
          * @return 
          * 
          * Returns the smallest of all maxOccurs, if maxOccurs defined in constraints. 
          * Returns -1, indicating unbounded repeating field, if repeating constraint defined & maxOccurs not defined. 
          * Returns null, indicating that this is a non-repeating field.
          */
         public static Integer getSmallestMaxOccurs(Metadata meta) {
                 if (meta == null) {
                         return null;
                 }
                 Integer smallestMaxOccurs = null;
                 boolean isRepeating = false;
 
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         if ("repeating".equals(cons.getId())){
                                 isRepeating = true;
                         }
                         if (cons.getMaxOccurs() != null) {
                                 if (smallestMaxOccurs == null) {
                                         smallestMaxOccurs = cons.getMaxOccurs();
                                 } else if (cons.getMaxOccurs() < smallestMaxOccurs) {
                                         smallestMaxOccurs = cons.getMaxOccurs();
                                 }
                         }
                 }
                 
                 if (isRepeating && smallestMaxOccurs == null){
                         smallestMaxOccurs = -1;
                 }
                 
                 return smallestMaxOccurs;
         }
 
         /**
          * get the largest min occurs value
          * 
          * @return null if none specified
          */
         public static Integer getLargestMinLength(Metadata meta) {
                 if (meta == null) {
                         return null;
                 }
                 Integer largestMinLength = null;
                 // TODO: worry aboutg special validators
                 // TODO: worry about how this applies to non-strings?
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         if (cons.getMinLength() != null) {
                                 if (largestMinLength == null) {
                                         largestMinLength = cons.getMinLength();
                                 } else if (cons.getMinLength() > largestMinLength) {
                                         largestMinLength = cons.getMinLength();
                                 }
                         }
                 }
                 return largestMinLength;
         }
 
         public static Integer getSmallestMaxLength(Metadata meta) {
                 if (meta == null) {
                         return null;
                 }
                 Integer smallestMaxLength = null;
                 // TODO: worry aboutg special validators
                 // TODO: worry about how this applies to non-strings?
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         if (cons.getMaxLength() != null) {
                                 if (smallestMaxLength == null) {
                                         smallestMaxLength = cons.getMaxLength();
                                 } else if (cons.getMaxLength() < smallestMaxLength) {
                                         smallestMaxLength = cons.getMaxLength();
                                 }
                         }
                 }
                 return smallestMaxLength;
         }
 
         public static boolean isMultilined(Metadata meta) {
                 if (meta == null) {
                         return false;
                 }
                 // TODO: worry about hard coding ids
                 boolean result = (hasConstraint(meta, "rich.text") || hasConstraint(meta, "multi.line.text")) 
                         && !(hasConstraint(meta, "single.line.text") || hasConstraint(meta, "code") || hasConstraint(meta, "no.linefeeds"));
                 
                 // TODO: Worry about hard coding the cut-off point
                 if (!result) {
                         Integer maxLength = getSmallestMaxLength(meta);
                         if (maxLength != null) {
                                 if (maxLength > 150) {
                                         result = true;
                                 }
                         }
                 }
                 return result;
         }
 
         
         public static Long getLargestMinValue(Metadata meta) {
                 if (meta == null) {
                         return null;
                 }
                 Long result = null;
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         Long min = tryParseLong(cons.getMinValue());
                         if (min != null) {
                                 if (result == null || min > result) {
                                         result = min;
                                 }
                         }
                 }
                 return result;
         }
 
         public static Long getSmallestMaxValue(Metadata meta) {
                 if (meta == null) {
                         return null;
                 }
                 Long result = null;
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         Long max = tryParseLong(cons.getMaxValue());
                         if (max != null) {
                                 if (result == null || max < result) {
                                         result = max;
                                 }
                         }
                 }
                 return result;
         }
 
         
         public static Double getLargestMinValueDouble(Metadata meta) {
                 if (meta == null) {
                         return null;
                 }
                 Double result = null;
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         Double min = tryParseDouble(cons.getMinValue());
                         if (min != null) {
                                 if (result == null || min > result) {
                                         result = min;
                                 }
                         }
                 }
                 return result;
         }
 
         public static Double getSmallestMaxValueDouble(Metadata meta) {
                 if (meta == null) {
                         return null;
                 }
                 Double result = null;
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         Double max = tryParseDouble(cons.getMaxValue());
                         if (max != null) {
                                 if (result == null || max < result) {
                                         result = max;
                                 }
                         }
                 }
                 return result;
         }
 
         public static Date getLargestMinValueDate(Metadata meta, DateParser parser, Object dataValue) {
                 if (meta == null) {
                         return null;
                 }
                 Date result = null;
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         Date min = tryParseDate(cons.getMinValue(), parser);
                         if (min != null) {
                                 if (result == null || min.getTime() > result.getTime()) {
                                         result = min;
                                 }
                         }
                 }
                 if (dataValue != null && dataValue instanceof Date){
                         if (result == null || (((Date)dataValue).getTime() > result.getTime())){
                                 result = (Date)dataValue;
                         }
                 }
                 return result;
         }
 
         public static Date getSmallestMaxValueDate(Metadata meta, DateParser parser, Object dataValue) {
                 if (meta == null) {
                         return null;
                 }
                 Date result = null;
                 for (ConstraintMetadata cons : meta.getConstraints()) {
                         Date max = tryParseDate(cons.getMaxValue(), parser);
                         if (max != null) {
                                 if (result == null || max.getTime() < result.getTime()) {
                                         result = max;
                                 }
                         }
                 }
                 if (dataValue != null && dataValue instanceof Date){
                         if (result==null || (((Date)dataValue).getTime() < result.getTime())){
                                 result = (Date)dataValue;
                         }
                 }
                 return result;
         }
         
         private static Long tryParseLong(String s) {
                 Long result = null;
                 
                 if (s != null) {
                         try {
                                 result = Long.valueOf(s);
                         } catch (Exception e) {
                                 // do nothing
                         }
                 }
                 
                 return result;
         }
         
         private static Double tryParseDouble(String s) {
                 Double result = null;
                 
                 if (s != null) {
                         try {
                                 result = Double.valueOf(s);
                         } catch (Exception e) {
                                 // do nothing
                         }
                 }
                 
                 return result;
         }
         
         private static Date tryParseDate(String s, DateParser parser) {
                 Date result = null;
                 
                 if (s != null) {
                         try {
                                 result = parser.parseDate(s);
                         } catch (Exception e) {
                                 // do nothing
                         }
                 }
                 
                 return result;
         }
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.common.assembly.data;
17
18		import java.util.Date;
19		import java.util.List;
20
21		import org.kuali.student.common.validator.DateParser;
22
23		/**
24		*
25		* @author nwright
26		*/
27		public class MetadataInterrogator {
28
29	0	public enum ConstraintIds {
30	0	MULTI_LINE_TEXT("multi.line.text"), RICH_TEXT("rich.text");
31		private final String id;
32
33	0	private ConstraintIds(final String id) {
34	0	this.id = id;
35	0	}
36
37		public String getId() {
38	0	return this.id;
39		}
40		}
41
42		private Metadata meta;
43
44	0	public MetadataInterrogator(Metadata meta) {
45	0	this.meta = meta;
46	0	}
47
48		/**
49		* Returns true if the metadata contains the specified constraint
50		*/
51		public boolean hasConstraint(String id) {
52	0	return hasConstraint(meta, id);
53		}
54
55
56		/**
57		* checks if is required
58		*
59		* @return true if any minOccurs > 1
60		*/
61		public boolean isRequired() {
62	0	return isRequired(meta);
63		}
64
65		/**
66		* get the largest min occurs value
67		*
68		* @return null if none specified
69		*/
70		public Integer getLargestMinOccurs() {
71	0	return getLargestMinOccurs(meta);
72		}
73
74		/**
75		* checks if this field is a repeating field
76		*
77		* @return true if the smallest maxOccurs is > 1
78		*/
79		public boolean isRepeating() {
80	0	return isRepeating(meta);
81		}
82
83		/**
84		* checks if this field is a repeating field
85		*
86		* @return true if the smallest maxOccurs is > 1
87		*/
88		public Integer getSmallestMaxOccurs() {
89	0	return getSmallestMaxOccurs(meta);
90		}
91
92		/**
93		* get the largest min occurs value
94		*
95		* @return null if none specified
96		*/
97		public Integer getLargestMinLength() {
98	0	return getLargestMinLength(meta);
99		}
100
101		public Integer getSmallestMaxLength() {
102	0	return getSmallestMaxLength(meta);
103		}
104
105		public boolean isMultilined() {
106	0	return isMultilined(meta);
107		}
108
109
110		/**
111		* Returns true if the metadata contains the specified constraint
112		*/
113		public static boolean hasConstraint(Metadata meta, ConstraintIds id) {
114	0	return hasConstraint(meta, id.getId());
115		}
116		/**
117		* Returns true if the metadata contains the specified constraint
118		*/
119		public static boolean hasConstraint(Metadata meta, String id) {
120	0	boolean result = false;
121	0	if (meta != null && meta.getConstraints() != null) {
122	0	result = containsConstraint(meta.getConstraints(), id);
123		}
124	0	return result;
125		}
126
127		private static boolean containsConstraint(List<ConstraintMetadata> constraints,
128		String id) {
129	0	boolean result = false;
130	0	if (constraints != null) {
131	0	for (ConstraintMetadata con : constraints) {
132	0	if ((con.getId() != null && con.getId().equals(id))
133		\|\| containsConstraint(con.getChildConstraints(), id)) {
134	0	result = true;
135	0	break;
136		}
137		}
138		}
139	0	return result;
140		}
141
142		/**
143		* checks if is required
144		*
145		* @return true if any minOccurs > 1
146		*/
147		public static boolean isRequired(Metadata meta) {
148	0	if (meta == null) {
149	0	return false;
150		}
151	0	Integer largestMinOccurs = getLargestMinOccurs(meta);
152		// no min occurs specified so not required
153	0	if (largestMinOccurs == null) {
154	0	return false;
155		}
156	0	if (largestMinOccurs >= 1) {
157	0	return true;
158		}
159	0	return false;
160		}
161
162		/**
163		* Use to determine if the field is required for the next state.
164		*
165		* @param meta
166		* @return
167		*/
168		public static boolean isRequiredForNextState(Metadata meta){
169	0	boolean required = false;
170
171	0	if(meta == null){
172	0	return false;
173		}
174		//This flag is only set when using the new dictionary, in which case there should
175		//never be more than one constraint.
176	0	if (meta.getConstraints() != null && meta.getConstraints().size() == 1){
177	0	ConstraintMetadata constraint = meta.getConstraints().get(0);
178	0	required = constraint.isRequiredForNextState();
179		}
180
181	0	return required;
182		}
183
184		/**
185		* Use to determine if the field is required for the next state.
186		*
187		* @param meta
188		* @return
189		*/
190		public static String getNextState(Metadata meta){
191	0	String state = null;
192
193	0	if(meta == null){
194	0	return state;
195		}
196		//This flag is only set when using the new dictionary, in which case there should
197		//never be more than one constraint.
198	0	if (meta.getConstraints() != null && meta.getConstraints().size() == 1){
199	0	ConstraintMetadata constraint = meta.getConstraints().get(0);
200	0	state = constraint.getNextState();
201		}
202
203	0	return state;
204		}
205
206		/**
207		* get the largest min occurs value
208		*
209		* @return null if none specified
210		*/
211		public static Integer getLargestMinOccurs(Metadata meta) {
212	0	if (meta == null) {
213	0	return null;
214		}
215	0	Integer largestMinOccurs = null;
216		// TODO: worry aboutg special validators
217		// TODO: worry about how this applies to non-strings?
218	0	for (ConstraintMetadata cons : meta.getConstraints()) {
219	0	if (cons.getMinOccurs() != null) {
220	0	if (largestMinOccurs == null) {
221	0	largestMinOccurs = cons.getMinOccurs();
222	0	} else if (cons.getMinOccurs() > largestMinOccurs) {
223	0	largestMinOccurs = cons.getMinOccurs();
224		}
225		}
226		}
227	0	return largestMinOccurs;
228		}
229
230		/**
231		* checks if this field is a repeating field
232		*
233		* @return true if the smallest maxOccurs is > 1
234		*/
235		public static boolean isRepeating(Metadata meta) {
236	0	if (meta == null) {
237	0	return false;
238		}
239	0	Integer smallestMaxOccurs = getSmallestMaxOccurs(meta);
240	0	if (hasRepeatingConstraint(meta) \|\|
241		(smallestMaxOccurs != null && smallestMaxOccurs > 1)) {
242	0	return true;
243		}
244	0	return false;
245		}
246
247		private static boolean hasRepeatingConstraint(Metadata meta) {
248	0	boolean isRepeating = false;
249
250	0	for (ConstraintMetadata cons : meta.getConstraints()) {
251	0	if ("repeating".equals(cons.getId())){
252	0	isRepeating = true;
253		}
254		}
255	0	return isRepeating;
256		}
257
258		/**
259		* Returns the smallest max occurs
260		*
261		* @return
262		*
263		* Returns the smallest of all maxOccurs, if maxOccurs defined in constraints.
264		* Returns -1, indicating unbounded repeating field, if repeating constraint defined & maxOccurs not defined.
265		* Returns null, indicating that this is a non-repeating field.
266		*/
267		public static Integer getSmallestMaxOccurs(Metadata meta) {
268	0	if (meta == null) {
269	0	return null;
270		}
271	0	Integer smallestMaxOccurs = null;
272	0	boolean isRepeating = false;
273
274	0	for (ConstraintMetadata cons : meta.getConstraints()) {
275	0	if ("repeating".equals(cons.getId())){
276	0	isRepeating = true;
277		}
278	0	if (cons.getMaxOccurs() != null) {
279	0	if (smallestMaxOccurs == null) {
280	0	smallestMaxOccurs = cons.getMaxOccurs();
281	0	} else if (cons.getMaxOccurs() < smallestMaxOccurs) {
282	0	smallestMaxOccurs = cons.getMaxOccurs();
283		}
284		}
285		}
286
287	0	if (isRepeating && smallestMaxOccurs == null){
288	0	smallestMaxOccurs = -1;
289		}
290
291	0	return smallestMaxOccurs;
292		}
293
294		/**
295		* get the largest min occurs value
296		*
297		* @return null if none specified
298		*/
299		public static Integer getLargestMinLength(Metadata meta) {
300	0	if (meta == null) {
301	0	return null;
302		}
303	0	Integer largestMinLength = null;
304		// TODO: worry aboutg special validators
305		// TODO: worry about how this applies to non-strings?
306	0	for (ConstraintMetadata cons : meta.getConstraints()) {
307	0	if (cons.getMinLength() != null) {
308	0	if (largestMinLength == null) {
309	0	largestMinLength = cons.getMinLength();
310	0	} else if (cons.getMinLength() > largestMinLength) {
311	0	largestMinLength = cons.getMinLength();
312		}
313		}
314		}
315	0	return largestMinLength;
316		}
317
318		public static Integer getSmallestMaxLength(Metadata meta) {
319	0	if (meta == null) {
320	0	return null;
321		}
322	0	Integer smallestMaxLength = null;
323		// TODO: worry aboutg special validators
324		// TODO: worry about how this applies to non-strings?
325	0	for (ConstraintMetadata cons : meta.getConstraints()) {
326	0	if (cons.getMaxLength() != null) {
327	0	if (smallestMaxLength == null) {
328	0	smallestMaxLength = cons.getMaxLength();
329	0	} else if (cons.getMaxLength() < smallestMaxLength) {
330	0	smallestMaxLength = cons.getMaxLength();
331		}
332		}
333		}
334	0	return smallestMaxLength;
335		}
336
337		public static boolean isMultilined(Metadata meta) {
338	0	if (meta == null) {
339	0	return false;
340		}
341		// TODO: worry about hard coding ids
342	0	boolean result = (hasConstraint(meta, "rich.text") \|\| hasConstraint(meta, "multi.line.text"))
343		&& !(hasConstraint(meta, "single.line.text") \|\| hasConstraint(meta, "code") \|\| hasConstraint(meta, "no.linefeeds"));
344
345		// TODO: Worry about hard coding the cut-off point
346	0	if (!result) {
347	0	Integer maxLength = getSmallestMaxLength(meta);
348	0	if (maxLength != null) {
349	0	if (maxLength > 150) {
350	0	result = true;
351		}
352		}
353		}
354	0	return result;
355		}
356
357
358		public static Long getLargestMinValue(Metadata meta) {
359	0	if (meta == null) {
360	0	return null;
361		}
362	0	Long result = null;
363	0	for (ConstraintMetadata cons : meta.getConstraints()) {
364	0	Long min = tryParseLong(cons.getMinValue());
365	0	if (min != null) {
366	0	if (result == null \|\| min > result) {
367	0	result = min;
368		}
369		}
370	0	}
371	0	return result;
372		}
373
374		public static Long getSmallestMaxValue(Metadata meta) {
375	0	if (meta == null) {
376	0	return null;
377		}
378	0	Long result = null;
379	0	for (ConstraintMetadata cons : meta.getConstraints()) {
380	0	Long max = tryParseLong(cons.getMaxValue());
381	0	if (max != null) {
382	0	if (result == null \|\| max < result) {
383	0	result = max;
384		}
385		}
386	0	}
387	0	return result;
388		}
389
390
391		public static Double getLargestMinValueDouble(Metadata meta) {
392	0	if (meta == null) {
393	0	return null;
394		}
395	0	Double result = null;
396	0	for (ConstraintMetadata cons : meta.getConstraints()) {
397	0	Double min = tryParseDouble(cons.getMinValue());
398	0	if (min != null) {
399	0	if (result == null \|\| min > result) {
400	0	result = min;
401		}
402		}
403	0	}
404	0	return result;
405		}
406
407		public static Double getSmallestMaxValueDouble(Metadata meta) {
408	0	if (meta == null) {
409	0	return null;
410		}
411	0	Double result = null;
412	0	for (ConstraintMetadata cons : meta.getConstraints()) {
413	0	Double max = tryParseDouble(cons.getMaxValue());
414	0	if (max != null) {
415	0	if (result == null \|\| max < result) {
416	0	result = max;
417		}
418		}
419	0	}
420	0	return result;
421		}
422
423		public static Date getLargestMinValueDate(Metadata meta, DateParser parser, Object dataValue) {
424	0	if (meta == null) {
425	0	return null;
426		}
427	0	Date result = null;
428	0	for (ConstraintMetadata cons : meta.getConstraints()) {
429	0	Date min = tryParseDate(cons.getMinValue(), parser);
430	0	if (min != null) {
431	0	if (result == null \|\| min.getTime() > result.getTime()) {
432	0	result = min;
433		}
434		}
435	0	}
436	0	if (dataValue != null && dataValue instanceof Date){
437	0	if (result == null \|\| (((Date)dataValue).getTime() > result.getTime())){
438	0	result = (Date)dataValue;
439		}
440		}
441	0	return result;
442		}
443
444		public static Date getSmallestMaxValueDate(Metadata meta, DateParser parser, Object dataValue) {
445	0	if (meta == null) {
446	0	return null;
447		}
448	0	Date result = null;
449	0	for (ConstraintMetadata cons : meta.getConstraints()) {
450	0	Date max = tryParseDate(cons.getMaxValue(), parser);
451	0	if (max != null) {
452	0	if (result == null \|\| max.getTime() < result.getTime()) {
453	0	result = max;
454		}
455		}
456	0	}
457	0	if (dataValue != null && dataValue instanceof Date){
458	0	if (result==null \|\| (((Date)dataValue).getTime() < result.getTime())){
459	0	result = (Date)dataValue;
460		}
461		}
462	0	return result;
463		}
464
465		private static Long tryParseLong(String s) {
466	0	Long result = null;
467
468	0	if (s != null) {
469		try {
470	0	result = Long.valueOf(s);
471	0	} catch (Exception e) {
472		// do nothing
473	0	}
474		}
475
476	0	return result;
477		}
478
479		private static Double tryParseDouble(String s) {
480	0	Double result = null;
481
482	0	if (s != null) {
483		try {
484	0	result = Double.valueOf(s);
485	0	} catch (Exception e) {
486		// do nothing
487	0	}
488		}
489
490	0	return result;
491		}
492
493		private static Date tryParseDate(String s, DateParser parser) {
494	0	Date result = null;
495
496	0	if (s != null) {
497		try {
498	0	result = parser.parseDate(s);
499	0	} catch (Exception e) {
500		// do nothing
501	0	}
502		}
503
504	0	return result;
505		}
506		}