Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

SearchTypeValidator

0/38

0/24

3.6

 /*
  * 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.DictionaryModel;
 import org.kuali.student.contract.model.SearchModel;
 import org.kuali.student.contract.model.SearchType;
 import org.kuali.student.contract.model.Service;
 import org.kuali.student.contract.model.util.ModelFinder;
 
 import java.util.ArrayList;
 import java.util.Collection;
 
 /**
  * This validates a single searchTypeinoary entry
  * @author nwright
  */
 public class SearchTypeValidator implements ModelValidator
 {
 
  private SearchType searchType;
 private SearchModel model;
 
  public SearchTypeValidator (SearchType searchType, SearchModel model)
  {
   this.searchType = searchType;
   this.model = model;
  }
 
  private Collection errors;
 
  @Override
  public Collection<String> validate ()
  {
   errors = new ArrayList ();
   basicValidation ();
   if (searchType.getImplementation () == null)
   {
    addError ("JPQL implementation is required");
   }
   if (searchType.getSearchCriteria () == null)
   {
    addError ("Criteria is required");
   }
   ModelValidator validator =
    new SearchCriteriaValidator (searchType.getSearchCriteria (), searchType);
   errors.addAll (validator.validate ());
   if (searchType.getSearchResult () == null)
   {
    addError ("Results is required");
   }
   validator =
    new SearchResultValidator (searchType.getSearchResult (), searchType);
   errors.addAll (validator.validate ());
   return errors;
  }
 
  private void basicValidation ()
  {
   if (searchType.getKey ().equals (""))
   {
    addError ("search type key is required");
   }
   if ( ! searchType.getType ().equals ("Search"))
   {
    addError ("'Type' column in the search type must be 'Search'");
   }
   if (searchType.getName ().equals (""))
   {
    addError ("Name is required");
   }
   if (searchType.getDescription ().equals (""))
   {
    addError ("Description is required");
   }
   if ( ! searchType.getDataType ().equals (""))
   {
    addError ("Data Type should be blank");
   }
    if ( ! searchType.getService ().equals (""))
   {
    if (findService (searchType.getService ()) == null)
    {
      addError ("Service, [" + searchType.getService ()
       + "] could not be found in the list of services");
    }
   }
  }
 
  private Service findService (String service)
  {
   // if we are only working with the searchModel then can't validate service
   if ( ! (model instanceof DictionaryModel))
   {
    return null;
   }
   return new ModelFinder ((DictionaryModel) model).findService (service);
  }
 
  private void addError (String msg)
  {
   String error = "Error in searchType entry: " + searchType.getKey () +
    ": " + 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.DictionaryModel;
19		import org.kuali.student.contract.model.SearchModel;
20		import org.kuali.student.contract.model.SearchType;
21		import org.kuali.student.contract.model.Service;
22		import org.kuali.student.contract.model.util.ModelFinder;
23
24		import java.util.ArrayList;
25		import java.util.Collection;
26
27		/**
28		* This validates a single searchTypeinoary entry
29		* @author nwright
30		*/
31		public class SearchTypeValidator implements ModelValidator
32		{
33
34		private SearchType searchType;
35		private SearchModel model;
36
37		public SearchTypeValidator (SearchType searchType, SearchModel model)
38	0	{
39	0	this.searchType = searchType;
40	0	this.model = model;
41	0	}
42
43		private Collection errors;
44
45		@Override
46		public Collection<String> validate ()
47		{
48	0	errors = new ArrayList ();
49	0	basicValidation ();
50	0	if (searchType.getImplementation () == null)
51		{
52	0	addError ("JPQL implementation is required");
53		}
54	0	if (searchType.getSearchCriteria () == null)
55		{
56	0	addError ("Criteria is required");
57		}
58	0	ModelValidator validator =
59		new SearchCriteriaValidator (searchType.getSearchCriteria (), searchType);
60	0	errors.addAll (validator.validate ());
61	0	if (searchType.getSearchResult () == null)
62		{
63	0	addError ("Results is required");
64		}
65	0	validator =
66		new SearchResultValidator (searchType.getSearchResult (), searchType);
67	0	errors.addAll (validator.validate ());
68	0	return errors;
69		}
70
71		private void basicValidation ()
72		{
73	0	if (searchType.getKey ().equals (""))
74		{
75	0	addError ("search type key is required");
76		}
77	0	if ( ! searchType.getType ().equals ("Search"))
78		{
79	0	addError ("'Type' column in the search type must be 'Search'");
80		}
81	0	if (searchType.getName ().equals (""))
82		{
83	0	addError ("Name is required");
84		}
85	0	if (searchType.getDescription ().equals (""))
86		{
87	0	addError ("Description is required");
88		}
89	0	if ( ! searchType.getDataType ().equals (""))
90		{
91	0	addError ("Data Type should be blank");
92		}
93	0	if ( ! searchType.getService ().equals (""))
94		{
95	0	if (findService (searchType.getService ()) == null)
96		{
97	0	addError ("Service, [" + searchType.getService ()
98		+ "] could not be found in the list of services");
99		}
100		}
101	0	}
102
103		private Service findService (String service)
104		{
105		// if we are only working with the searchModel then can't validate service
106	0	if ( ! (model instanceof DictionaryModel))
107		{
108	0	return null;
109		}
110	0	return new ModelFinder ((DictionaryModel) model).findService (service);
111		}
112
113		private void addError (String msg)
114		{
115	0	String error = "Error in searchType entry: " + searchType.getKey () +
116		": " + msg;
117	0	if ( ! errors.contains (error))
118		{
119	0	errors.add (error);
120		}
121	0	}
122
123		}