Coverage Report

Coverage Report - org.kuali.student.contract.model.validation.ConstraintValidator

Classes in this File

0/55

0/36

 /*
  * Copyright 2009 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.contract.model.validation;
 
 import org.kuali.student.contract.model.Constraint;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
 /**
  * This validates a constraint.
  * @author nwright
  */
 public class ConstraintValidator implements ModelValidator
 {
 
  private Constraint cons;
 
  public ConstraintValidator (Constraint cons)
  {
   this.cons = cons;
  }
 
  private Collection errors;
 
  @Override
  public Collection<String> validate ()
  {
   this.errors = new ArrayList ();
   validateMinMaxLength ();
   validateMinMaxOccurs ();
   validateMinMaxValue ();
   return this.errors;
  }
 
  private void validateMinMaxLength ()
  {
   if ( ! cons.getMinLength ().equals (""))
   {
    int min = parseIntError (cons.getMinLength (), "minLength");
    if (min < 0)
    {
     this.addError ("minLength is less than zero");
    }
    if ( ! cons.getMaxLength ().equals (""))
    {
     int max = parseIntError (cons.getMaxLength (), "maxLength");
     if (min < 0)
     {
      this.addError ("maxLength is less than zero");
     }
 
     if (min > max)
     {
      addError ("minLength exceeds the maxLength");
     }
    }
   }
  }
 
  private void validateMinMaxOccurs ()
  {
   if ( ! cons.getMinOccurs ().equals (""))
   {
    int min = parseIntError (cons.getMinOccurs (), "minOccurs");
    if (min < 0)
    {
     this.addError ("minOccurs is less than zero");
    }
    if ( ! cons.getMaxOccurs ().equals (""))
    {
     int max = parseIntError (cons.getMaxOccurs (), "maxOccurs");
     if (max < 0)
     {
      this.addError ("maxOccurs is less than zero");
     }
     if (min > max)
     {
      addError ("minOccurs exceeds the maxOccurs");
     }
    }
   }
  }
 
  private void validateMinMaxValue ()
  {
   if ( ! cons.getMinValue ().equals (""))
   {
    int min = parseIntError (cons.getMinValue (), "minValue");
    if (min < 0)
    {
     this.addError ("minValue is less than zero");
    }
    if ( ! cons.getMaxValue ().equals (""))
    {
     int max = parseIntError (cons.getMaxValue (), "maxValue");
     if (max < 0)
     {
      this.addError ("maxOccurs is less than zero");
     }
     if (min > max)
     {
      addError ("minOccurs exceeds the maxOccurs");
     }
    }
   }
  }
 
  private int parseIntError (String value, String field)
  {
   if (value.equals (""))
   {
    return 0;
   }
   try
   {
    int val = Integer.parseInt (value);
    return val;
   }
   catch (NumberFormatException ex)
   {
    addError (field + " is [" + value + "] not an integer");
    return 0;
   }
  }
 
  private void addError (String msg)
  {
   String id = cons.getId ();
   if (id.equals (""))
   {
    id = cons.getKey ();
   }
   String error = "Error in constraint " + id + ": " + msg;
   if ( ! errors.contains (error))
   {
    errors.add (error);
   }
  }
 
 }

1		/*
2		* Copyright 2009 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.osedu.org/licenses/ECL-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.student.contract.model.validation;
17
18		import org.kuali.student.contract.model.Constraint;
19
20		import java.util.ArrayList;
21		import java.util.Collection;
22		import java.util.List;
23
24		/**
25		* This validates a constraint.
26		* @author nwright
27		*/
28		public class ConstraintValidator implements ModelValidator
29		{
30
31		private Constraint cons;
32
33		public ConstraintValidator (Constraint cons)
34	0	{
35	0	this.cons = cons;
36	0	}
37
38		private Collection errors;
39
40		@Override
41		public Collection<String> validate ()
42		{
43	0	this.errors = new ArrayList ();
44	0	validateMinMaxLength ();
45	0	validateMinMaxOccurs ();
46	0	validateMinMaxValue ();
47	0	return this.errors;
48		}
49
50		private void validateMinMaxLength ()
51		{
52	0	if ( ! cons.getMinLength ().equals (""))
53		{
54	0	int min = parseIntError (cons.getMinLength (), "minLength");
55	0	if (min < 0)
56		{
57	0	this.addError ("minLength is less than zero");
58		}
59	0	if ( ! cons.getMaxLength ().equals (""))
60		{
61	0	int max = parseIntError (cons.getMaxLength (), "maxLength");
62	0	if (min < 0)
63		{
64	0	this.addError ("maxLength is less than zero");
65		}
66
67	0	if (min > max)
68		{
69	0	addError ("minLength exceeds the maxLength");
70		}
71		}
72		}
73	0	}
74
75		private void validateMinMaxOccurs ()
76		{
77	0	if ( ! cons.getMinOccurs ().equals (""))
78		{
79	0	int min = parseIntError (cons.getMinOccurs (), "minOccurs");
80	0	if (min < 0)
81		{
82	0	this.addError ("minOccurs is less than zero");
83		}
84	0	if ( ! cons.getMaxOccurs ().equals (""))
85		{
86	0	int max = parseIntError (cons.getMaxOccurs (), "maxOccurs");
87	0	if (max < 0)
88		{
89	0	this.addError ("maxOccurs is less than zero");
90		}
91	0	if (min > max)
92		{
93	0	addError ("minOccurs exceeds the maxOccurs");
94		}
95		}
96		}
97	0	}
98
99		private void validateMinMaxValue ()
100		{
101	0	if ( ! cons.getMinValue ().equals (""))
102		{
103	0	int min = parseIntError (cons.getMinValue (), "minValue");
104	0	if (min < 0)
105		{
106	0	this.addError ("minValue is less than zero");
107		}
108	0	if ( ! cons.getMaxValue ().equals (""))
109		{
110	0	int max = parseIntError (cons.getMaxValue (), "maxValue");
111	0	if (max < 0)
112		{
113	0	this.addError ("maxOccurs is less than zero");
114		}
115	0	if (min > max)
116		{
117	0	addError ("minOccurs exceeds the maxOccurs");
118		}
119		}
120		}
121	0	}
122
123		private int parseIntError (String value, String field)
124		{
125	0	if (value.equals (""))
126		{
127	0	return 0;
128		}
129		try
130		{
131	0	int val = Integer.parseInt (value);
132	0	return val;
133		}
134	0	catch (NumberFormatException ex)
135		{
136	0	addError (field + " is [" + value + "] not an integer");
137	0	return 0;
138		}
139		}
140
141		private void addError (String msg)
142		{
143	0	String id = cons.getId ();
144	0	if (id.equals (""))
145		{
146	0	id = cons.getKey ();
147		}
148	0	String error = "Error in constraint " + id + ": " + msg;
149	0	if ( ! errors.contains (error))
150		{
151	0	errors.add (error);
152		}
153	0	}
154
155		}