Coverage Report

Coverage Report - org.kuali.student.common.dao.impl.AbstractSearchableCrudDaoImpl

Classes in this File

0/141

0/108

 /**
  * 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.dao.impl;
 
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.StringTokenizer;
 
 import javax.persistence.Query;
 
 import org.apache.log4j.Logger;
 import org.kuali.student.common.dao.SearchableDao;
 import org.kuali.student.common.search.dto.QueryParamInfo;
 import org.kuali.student.common.search.dto.ResultColumnInfo;
 import org.kuali.student.common.search.dto.SearchParam;
 import org.kuali.student.common.search.dto.SearchRequest;
 import org.kuali.student.common.search.dto.SearchResult;
 import org.kuali.student.common.search.dto.SearchResultCell;
 import org.kuali.student.common.search.dto.SearchResultRow;
 import org.kuali.student.common.search.dto.SearchTypeInfo;
 import org.kuali.student.common.search.dto.SortDirection;
 
 public class AbstractSearchableCrudDaoImpl extends AbstractCrudDaoImpl
                 implements SearchableDao {
         final Logger LOG = Logger.getLogger(AbstractSearchableCrudDaoImpl.class);
     private static SimpleDateFormat df = new SimpleDateFormat("EEE MMM dd hh:mm:ss zzz yyyy");
 
         @Override
         public SearchResult search(SearchRequest searchRequest,        Map<String, String> queryMap, SearchTypeInfo searchTypeInfo) {
                 String searchKey = searchRequest.getSearchKey();
                 
                 boolean isNative = false;
                 
                 //retrieve the SELECT statement from search type definition
                 String queryString = queryMap.get(searchKey);
                 String optionalQueryString = "";
                 if(null == queryString){
                         LOG.error("No SQL query was found for searchKey:"+searchKey);
                 }
                 
                 if(queryString.toUpperCase().startsWith("NATIVE:")){
                         queryString = queryString.substring("NATIVE:".length());
                         isNative = true;
                 }
                 
                 //add in optional
                 List<SearchParam> searchParamsTemp = new ArrayList<SearchParam>(searchRequest.getParams());
                 // internalQueryParms is used only internally to know which parameters have to be set in the query
                 List<SearchParam> internalQueryParms = new ArrayList<SearchParam>(searchRequest.getParams());
                 for(SearchParam searchParam : searchParamsTemp){
                         for(QueryParamInfo queryParam:searchTypeInfo.getSearchCriteriaTypeInfo().getQueryParams()){
                                 // check to see if optional param has any values set.
                                 if(queryParam.isOptional()&&queryParam.getKey().equals(searchParam.getKey())&&searchParam.getValue()!=null){
                                         if(!optionalQueryString.isEmpty()){
                                                 optionalQueryString += " AND ";
                                         }
                                         
                                         //if optional query parameter has only a column name then create proper search expression
                                         String condition = queryMap.get(searchParam.getKey());
                                         if (condition.trim().startsWith("!!")) {
                                             String substitutionType = condition.trim().substring("!!".length());
                                             // to detect queryMap value in the form of !!____ ___
                                             if (condition.contains(" ")) {
                                                 substitutionType = condition.substring("!!".length(), condition.indexOf(" "));
                                             }
                                             
                                             if (substitutionType != null && substitutionType.equals("NUMBER_RANGE")) {
                                                 String realCondition = condition.substring("!!".length() + substitutionType.length()).trim();
                                                 String queryValue = (String)searchParam.getValue();
                                                 // if the query value is of the form n1 - n2
                                                 if (queryValue != null && queryValue.trim().contains("-")) {
                                                     StringTokenizer strTokenizer = new StringTokenizer(queryValue.trim(),"-");
                                                     if (strTokenizer.hasMoreElements()) {
                                                         String strNum1 = strTokenizer.nextToken().trim();
                                                         String strNum2 = strTokenizer.nextToken().trim();
                                                         optionalQueryString += 
                                                             realCondition +
                                                             " BETWEEN " + "'" + strNum1 + "'" + " AND " + "'" + strNum2 + "'";
                                                         internalQueryParms.remove(searchParam);
                                                     }
                                                 } else {
                                                     // the value is just one number
                                                     optionalQueryString += realCondition + " = '" + queryValue + "'";
                                                     internalQueryParms.remove(searchParam);
                                                 }
                                             }
                                         } else if (condition.trim().contains(":")) {
                                             //this parameter is not entered by end user but rather it is set with a default context value        
                                             String dataType = queryParam.getFieldDescriptor().getDataType();
                                             if ((dataType != null) && "boolean".equals(dataType)) {
                                                 optionalQueryString += queryMap.get(searchParam.getKey()).replace(":" + searchParam.getKey().replace(".", "_"), searchParam.getValue().toString());
                                                 internalQueryParms.remove(searchParam);
                                             } else {                                            
                                                 optionalQueryString += queryMap.get(searchParam.getKey());
                                             }                                                
                                         } else {
                                                 //comparison should be case insensitive and should include wild card such that we match beginning of a text 
                                                 //and each word within text
                                                 //FIXME SQL injection can occur here - or NOT if we need to assemble SQL to cover various ways one can compare criteria to a text
                                                 optionalQueryString += 
                                                         "(LOWER(" + queryMap.get(searchParam.getKey()) + ") LIKE LOWER('" + searchParam.getValue() + "') || '%' OR " +
                                                         "LOWER(" + queryMap.get(searchParam.getKey()) + ") LIKE '% ' || LOWER('" + searchParam.getValue() + "') || '%')"; 
                                                 internalQueryParms.remove(searchParam);
                                         }
                                 }
                         }
                 }
                 
                 //Add in the where clause or And clause if needed for the optional criteria
                 if(!optionalQueryString.isEmpty()){
                         if(!queryString.toUpperCase().contains(" WHERE ")){
                                 queryString += " WHERE ";
                         }
                         else {
                                 queryString += " AND ";
                         }
                 }
                 
                 //Do ordering
                 String orderByClause = "";                
                 if(!queryString.toUpperCase().contains("ORDER BY")&&searchRequest.getSortColumn()!=null){
                         //make sure the sort column is a real result column
                         int i = 0;
                         
                         //Get an array of the jpql results
                         int selectIndex = queryString.toLowerCase().indexOf("select")+"select".length();
                         int fromIndex = queryString.toLowerCase().indexOf(" from ");
                         
                         if (selectIndex >= 0 && fromIndex > selectIndex){
                                 String[] jpqlResultColumns = queryString.substring(selectIndex, fromIndex).replaceAll("\\s", "").split(",");
                                 for(ResultColumnInfo results : searchTypeInfo.getSearchResultTypeInfo().getResultColumns()){
                                         if(results.getKey().equals(searchRequest.getSortColumn())){
                                                 orderByClause = " ORDER BY "+jpqlResultColumns[i]+" ";
                                                 if(searchRequest.getSortDirection()!=null && searchRequest.getSortDirection()==SortDirection.DESC){
                                                         orderByClause += "DESC ";
                                                 }else{
                                                         orderByClause += "ASC ";
                                                 }
                                         }
                                         i++;
                                 }
                         }                        
                 }
                 
                 //Create the query
                 String finalQueryString = queryString + optionalQueryString + orderByClause;
                 
                 //remove special characters and extra spaces
                 //finalQueryString = finalQueryString.replaceAll("[\n\r\t]", " ");
                 //finalQueryString = finalQueryString.replaceAll("\\s+", " ");
                 
                 Query query;
                 if(isNative){
                         LOG.info("Native Query:"+finalQueryString);
                         query = em.createNativeQuery(finalQueryString);
                 }else{
                         LOG.info("JPQL Query:"+finalQueryString);
                         query = em.createQuery(finalQueryString);
                 }
                 
                 //Set the pagination information (eg. only return 25 rows starting at row 100)
                 if(searchRequest.getStartAt()!=null){
                         query.setFirstResult(searchRequest.getStartAt().intValue());
                 }
                 if(searchRequest.getMaxResults()!=null){
                         query.setMaxResults(searchRequest.getMaxResults().intValue());
                 }
                 
                 //replace all the "." notation with "_" since the "."s in the ids of the queries will cause problems with the jpql  
                 for (SearchParam searchParam : internalQueryParms) {
                         // check to see if optional param has any values set.
                         if (searchParam.getValue() != null) {
                             List<QueryParamInfo> queryParams = searchTypeInfo.getSearchCriteriaTypeInfo().getQueryParams();
                             String paramDataType = null;
                             if (queryParams != null) {
                                 for (QueryParamInfo queryParam : queryParams) {
                                     if (queryParam.getKey() != null && queryParam.getKey().equals(searchParam.getKey())) {
                                         paramDataType = queryParam.getFieldDescriptor().getDataType();
                                     }
                                 }
                             }
                             
                 Object queryParamValue = null;
                             if ("date".equals(paramDataType) && searchParam.getValue() instanceof String) {
                                 try {
                         queryParamValue = df.parse((String)searchParam.getValue());
                     } catch (ParseException e) {
                         throw new RuntimeException("Failed to parse date value " + searchParam.getValue(),e);
                     }
                             } if ("long".equals(paramDataType) && searchParam.getValue() instanceof String) {
                                 try{
                                         queryParamValue = Long.valueOf((String)searchParam.getValue());
                         } catch (NumberFormatException e) {
                             throw new RuntimeException("Failed to parse date value " + searchParam.getValue(),e);
                         }
                             } else {
                                 queryParamValue = searchParam.getValue();
                             }
                             //Needed to get around Hibernate not supporting IN(:var) where var is null or an empty collection
                             if((queryParamValue==null||queryParamValue instanceof Collection && ((Collection<?>)queryParamValue).isEmpty())&&"list".equals(paramDataType)){
                                     queryParamValue = "";
                             }
                             query.setParameter(searchParam.getKey().replace(".", "_"), queryParamValue);
                         }
                 }
 
                 // Turn into results
                 List<SearchResultRow> results = convertToResults(query.getResultList(),searchTypeInfo);
 
                 SearchResult searchResult = new SearchResult();
                 searchResult.setRows(results);
                 searchResult.setSortColumn(searchRequest.getSortColumn());
                 searchResult.setSortDirection(searchRequest.getSortDirection());
                 searchResult.setStartAt(searchRequest.getStartAt());
                 if(searchRequest.getNeededTotalResults()!=null && searchRequest.getNeededTotalResults()){
                         //Get count of total rows if needed
                         String regex = "^\\s*[Ss][Ee][Ll][Ee][Cc][Tt]\\s+([^,\\s]+)(.|[\r\n])*?\\s+[Ff][Rr][Oo][Mm]\\s+";
                         String replacement = "SELECT COUNT($1) FROM ";
                         String countQueryString = (queryString + optionalQueryString).replaceFirst(regex, replacement);
 
                         LOG.info("Executing query: "+countQueryString);
                         Query countQuery;
                         if(isNative){
                                 countQuery = em.createNativeQuery(countQueryString);
                         }else{
                                 countQuery = em.createQuery(countQueryString);
                         }
                         for (SearchParam searchParam : internalQueryParms) {
                                 countQuery.setParameter(searchParam.getKey().replace(".", "_"), searchParam.getValue());
                         }
                         Long totalResults = (Long) countQuery.getSingleResult();
                         searchResult.setTotalResults(totalResults.intValue());
                 }
 
                 return searchResult;
         }
         
         private List<SearchResultRow> convertToResults(List<?> queryResults,
                         SearchTypeInfo searchTypeInfo) {
                 List<SearchResultRow> results = new ArrayList<SearchResultRow>();
 
                 if(queryResults!=null){
                         //Copy the query results to a Result object
                         for(Object queryResult:queryResults){
                                 SearchResultRow result = new SearchResultRow();
                                 int i=0;
                                 for (ResultColumnInfo resultColumn : searchTypeInfo.getSearchResultTypeInfo().getResultColumns()) {
                         
                                         SearchResultCell resultCell = new SearchResultCell();
                                         resultCell.setKey(resultColumn.getKey());
                                         
                                         try {
                                                 Object queryResultCell = null;
                                                 if(queryResult.getClass().isArray()){
                                                         queryResultCell = ((Object[])queryResult)[i];
                                                         
                                                 }else{
                                                         queryResultCell = queryResult;
                                                 }
                                                 
                                                 if (queryResultCell != null) {
                                                         resultCell.setValue(queryResultCell.toString());                                                        
                                                 }
                                         
                                         } catch (Exception e) {
                                                 throw new RuntimeException("Error copying results from " + queryResult.toString(),e);
                                         }
                                         
                                         result.getCells().add(resultCell);
                                         i++;
                                 }
                                 results.add(result);
                         }
                 }
                 return results;
         }
 
 }

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.dao.impl;
17
18		import java.text.ParseException;
19		import java.text.SimpleDateFormat;
20		import java.util.ArrayList;
21		import java.util.Collection;
22		import java.util.List;
23		import java.util.Map;
24		import java.util.StringTokenizer;
25
26		import javax.persistence.Query;
27
28		import org.apache.log4j.Logger;
29		import org.kuali.student.common.dao.SearchableDao;
30		import org.kuali.student.common.search.dto.QueryParamInfo;
31		import org.kuali.student.common.search.dto.ResultColumnInfo;
32		import org.kuali.student.common.search.dto.SearchParam;
33		import org.kuali.student.common.search.dto.SearchRequest;
34		import org.kuali.student.common.search.dto.SearchResult;
35		import org.kuali.student.common.search.dto.SearchResultCell;
36		import org.kuali.student.common.search.dto.SearchResultRow;
37		import org.kuali.student.common.search.dto.SearchTypeInfo;
38		import org.kuali.student.common.search.dto.SortDirection;
39
40	0	public class AbstractSearchableCrudDaoImpl extends AbstractCrudDaoImpl
41		implements SearchableDao {
42	0	final Logger LOG = Logger.getLogger(AbstractSearchableCrudDaoImpl.class);
43	0	private static SimpleDateFormat df = new SimpleDateFormat("EEE MMM dd hh:mm:ss zzz yyyy");
44
45		@Override
46		public SearchResult search(SearchRequest searchRequest, Map<String, String> queryMap, SearchTypeInfo searchTypeInfo) {
47	0	String searchKey = searchRequest.getSearchKey();
48
49	0	boolean isNative = false;
50
51		//retrieve the SELECT statement from search type definition
52	0	String queryString = queryMap.get(searchKey);
53	0	String optionalQueryString = "";
54	0	if(null == queryString){
55	0	LOG.error("No SQL query was found for searchKey:"+searchKey);
56		}
57
58	0	if(queryString.toUpperCase().startsWith("NATIVE:")){
59	0	queryString = queryString.substring("NATIVE:".length());
60	0	isNative = true;
61		}
62
63		//add in optional
64	0	List<SearchParam> searchParamsTemp = new ArrayList<SearchParam>(searchRequest.getParams());
65		// internalQueryParms is used only internally to know which parameters have to be set in the query
66	0	List<SearchParam> internalQueryParms = new ArrayList<SearchParam>(searchRequest.getParams());
67	0	for(SearchParam searchParam : searchParamsTemp){
68	0	for(QueryParamInfo queryParam:searchTypeInfo.getSearchCriteriaTypeInfo().getQueryParams()){
69		// check to see if optional param has any values set.
70	0	if(queryParam.isOptional()&&queryParam.getKey().equals(searchParam.getKey())&&searchParam.getValue()!=null){
71	0	if(!optionalQueryString.isEmpty()){
72	0	optionalQueryString += " AND ";
73		}
74
75		//if optional query parameter has only a column name then create proper search expression
76	0	String condition = queryMap.get(searchParam.getKey());
77	0	if (condition.trim().startsWith("!!")) {
78	0	String substitutionType = condition.trim().substring("!!".length());
79		// to detect queryMap value in the form of !!____ ___
80	0	if (condition.contains(" ")) {
81	0	substitutionType = condition.substring("!!".length(), condition.indexOf(" "));
82		}
83
84	0	if (substitutionType != null && substitutionType.equals("NUMBER_RANGE")) {
85	0	String realCondition = condition.substring("!!".length() + substitutionType.length()).trim();
86	0	String queryValue = (String)searchParam.getValue();
87		// if the query value is of the form n1 - n2
88	0	if (queryValue != null && queryValue.trim().contains("-")) {
89	0	StringTokenizer strTokenizer = new StringTokenizer(queryValue.trim(),"-");
90	0	if (strTokenizer.hasMoreElements()) {
91	0	String strNum1 = strTokenizer.nextToken().trim();
92	0	String strNum2 = strTokenizer.nextToken().trim();
93	0	optionalQueryString +=
94		realCondition +
95		" BETWEEN " + "'" + strNum1 + "'" + " AND " + "'" + strNum2 + "'";
96	0	internalQueryParms.remove(searchParam);
97		}
98	0	} else {
99		// the value is just one number
100	0	optionalQueryString += realCondition + " = '" + queryValue + "'";
101	0	internalQueryParms.remove(searchParam);
102		}
103		}
104	0	} else if (condition.trim().contains(":")) {
105		//this parameter is not entered by end user but rather it is set with a default context value
106	0	String dataType = queryParam.getFieldDescriptor().getDataType();
107	0	if ((dataType != null) && "boolean".equals(dataType)) {
108	0	optionalQueryString += queryMap.get(searchParam.getKey()).replace(":" + searchParam.getKey().replace(".", "_"), searchParam.getValue().toString());
109	0	internalQueryParms.remove(searchParam);
110		} else {
111	0	optionalQueryString += queryMap.get(searchParam.getKey());
112		}
113	0	} else {
114		//comparison should be case insensitive and should include wild card such that we match beginning of a text
115		//and each word within text
116		//FIXME SQL injection can occur here - or NOT if we need to assemble SQL to cover various ways one can compare criteria to a text
117	0	optionalQueryString +=
118		"(LOWER(" + queryMap.get(searchParam.getKey()) + ") LIKE LOWER('" + searchParam.getValue() + "') \|\| '%' OR " +
119		"LOWER(" + queryMap.get(searchParam.getKey()) + ") LIKE '% ' \|\| LOWER('" + searchParam.getValue() + "') \|\| '%')";
120	0	internalQueryParms.remove(searchParam);
121		}
122	0	}
123		}
124		}
125
126		//Add in the where clause or And clause if needed for the optional criteria
127	0	if(!optionalQueryString.isEmpty()){
128	0	if(!queryString.toUpperCase().contains(" WHERE ")){
129	0	queryString += " WHERE ";
130		}
131		else {
132	0	queryString += " AND ";
133		}
134		}
135
136		//Do ordering
137	0	String orderByClause = "";
138	0	if(!queryString.toUpperCase().contains("ORDER BY")&&searchRequest.getSortColumn()!=null){
139		//make sure the sort column is a real result column
140	0	int i = 0;
141
142		//Get an array of the jpql results
143	0	int selectIndex = queryString.toLowerCase().indexOf("select")+"select".length();
144	0	int fromIndex = queryString.toLowerCase().indexOf(" from ");
145
146	0	if (selectIndex >= 0 && fromIndex > selectIndex){
147	0	String[] jpqlResultColumns = queryString.substring(selectIndex, fromIndex).replaceAll("\\s", "").split(",");
148	0	for(ResultColumnInfo results : searchTypeInfo.getSearchResultTypeInfo().getResultColumns()){
149	0	if(results.getKey().equals(searchRequest.getSortColumn())){
150	0	orderByClause = " ORDER BY "+jpqlResultColumns[i]+" ";
151	0	if(searchRequest.getSortDirection()!=null && searchRequest.getSortDirection()==SortDirection.DESC){
152	0	orderByClause += "DESC ";
153		}else{
154	0	orderByClause += "ASC ";
155		}
156		}
157	0	i++;
158		}
159		}
160		}
161
162		//Create the query
163	0	String finalQueryString = queryString + optionalQueryString + orderByClause;
164
165		//remove special characters and extra spaces
166		//finalQueryString = finalQueryString.replaceAll("[\n\r\t]", " ");
167		//finalQueryString = finalQueryString.replaceAll("\\s+", " ");
168
169		Query query;
170	0	if(isNative){
171	0	LOG.info("Native Query:"+finalQueryString);
172	0	query = em.createNativeQuery(finalQueryString);
173		}else{
174	0	LOG.info("JPQL Query:"+finalQueryString);
175	0	query = em.createQuery(finalQueryString);
176		}
177
178		//Set the pagination information (eg. only return 25 rows starting at row 100)
179	0	if(searchRequest.getStartAt()!=null){
180	0	query.setFirstResult(searchRequest.getStartAt().intValue());
181		}
182	0	if(searchRequest.getMaxResults()!=null){
183	0	query.setMaxResults(searchRequest.getMaxResults().intValue());
184		}
185
186		//replace all the "." notation with "_" since the "."s in the ids of the queries will cause problems with the jpql
187	0	for (SearchParam searchParam : internalQueryParms) {
188		// check to see if optional param has any values set.
189	0	if (searchParam.getValue() != null) {
190	0	List<QueryParamInfo> queryParams = searchTypeInfo.getSearchCriteriaTypeInfo().getQueryParams();
191	0	String paramDataType = null;
192	0	if (queryParams != null) {
193	0	for (QueryParamInfo queryParam : queryParams) {
194	0	if (queryParam.getKey() != null && queryParam.getKey().equals(searchParam.getKey())) {
195	0	paramDataType = queryParam.getFieldDescriptor().getDataType();
196		}
197		}
198		}
199
200	0	Object queryParamValue = null;
201	0	if ("date".equals(paramDataType) && searchParam.getValue() instanceof String) {
202		try {
203	0	queryParamValue = df.parse((String)searchParam.getValue());
204	0	} catch (ParseException e) {
205	0	throw new RuntimeException("Failed to parse date value " + searchParam.getValue(),e);
206	0	}
207	0	} if ("long".equals(paramDataType) && searchParam.getValue() instanceof String) {
208		try{
209	0	queryParamValue = Long.valueOf((String)searchParam.getValue());
210	0	} catch (NumberFormatException e) {
211	0	throw new RuntimeException("Failed to parse date value " + searchParam.getValue(),e);
212	0	}
213		} else {
214	0	queryParamValue = searchParam.getValue();
215		}
216		//Needed to get around Hibernate not supporting IN(:var) where var is null or an empty collection
217	0	if((queryParamValue==null\|\|queryParamValue instanceof Collection && ((Collection<?>)queryParamValue).isEmpty())&&"list".equals(paramDataType)){
218	0	queryParamValue = "";
219		}
220	0	query.setParameter(searchParam.getKey().replace(".", "_"), queryParamValue);
221	0	}
222		}
223
224		// Turn into results
225	0	List<SearchResultRow> results = convertToResults(query.getResultList(),searchTypeInfo);
226
227	0	SearchResult searchResult = new SearchResult();
228	0	searchResult.setRows(results);
229	0	searchResult.setSortColumn(searchRequest.getSortColumn());
230	0	searchResult.setSortDirection(searchRequest.getSortDirection());
231	0	searchResult.setStartAt(searchRequest.getStartAt());
232	0	if(searchRequest.getNeededTotalResults()!=null && searchRequest.getNeededTotalResults()){
233		//Get count of total rows if needed
234	0	String regex = "^\\s[Ss][Ee][Ll][Ee][Cc][Tt]\\s+([^,\\s]+)(.\|[\r\n])?\\s+[Ff][Rr][Oo][Mm]\\s+";
235	0	String replacement = "SELECT COUNT($1) FROM ";
236	0	String countQueryString = (queryString + optionalQueryString).replaceFirst(regex, replacement);
237
238	0	LOG.info("Executing query: "+countQueryString);
239		Query countQuery;
240	0	if(isNative){
241	0	countQuery = em.createNativeQuery(countQueryString);
242		}else{
243	0	countQuery = em.createQuery(countQueryString);
244		}
245	0	for (SearchParam searchParam : internalQueryParms) {
246	0	countQuery.setParameter(searchParam.getKey().replace(".", "_"), searchParam.getValue());
247		}
248	0	Long totalResults = (Long) countQuery.getSingleResult();
249	0	searchResult.setTotalResults(totalResults.intValue());
250		}
251
252	0	return searchResult;
253		}
254
255		private List<SearchResultRow> convertToResults(List<?> queryResults,
256		SearchTypeInfo searchTypeInfo) {
257	0	List<SearchResultRow> results = new ArrayList<SearchResultRow>();
258
259	0	if(queryResults!=null){
260		//Copy the query results to a Result object
261	0	for(Object queryResult:queryResults){
262	0	SearchResultRow result = new SearchResultRow();
263	0	int i=0;
264	0	for (ResultColumnInfo resultColumn : searchTypeInfo.getSearchResultTypeInfo().getResultColumns()) {
265
266	0	SearchResultCell resultCell = new SearchResultCell();
267	0	resultCell.setKey(resultColumn.getKey());
268
269		try {
270	0	Object queryResultCell = null;
271	0	if(queryResult.getClass().isArray()){
272	0	queryResultCell = ((Object[])queryResult)[i];
273
274		}else{
275	0	queryResultCell = queryResult;
276		}
277
278	0	if (queryResultCell != null) {
279	0	resultCell.setValue(queryResultCell.toString());
280		}
281
282	0	} catch (Exception e) {
283	0	throw new RuntimeException("Error copying results from " + queryResult.toString(),e);
284	0	}
285
286	0	result.getCells().add(resultCell);
287	0	i++;
288	0	}
289	0	results.add(result);
290	0	}
291		}
292	0	return results;
293		}
294
295		}