Coverage Report

Coverage Report - org.kuali.rice.kns.web.struts.form.MultipleValueLookupForm

Classes in this File

Line Coverage

Branch Coverage

Complexity

MultipleValueLookupForm

0/111

0/32

1.476

 /**
  * Copyright 2005-2011 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.web.struts.form;
 
 import org.apache.commons.lang.StringUtils;
 import org.kuali.rice.kns.lookup.HtmlData;
 import org.kuali.rice.kns.lookup.LookupUtils;
 import org.kuali.rice.kns.util.PagingBannerUtils;
 import org.kuali.rice.krad.util.KRADConstants;
 
 import javax.servlet.http.HttpServletRequest;
 import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 
 /**
  * Form to handle multiple value lookups 
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  *
  */
 public class MultipleValueLookupForm extends LookupForm {
     private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(MultipleValueLookupForm.class);
     
     private KualiTableRenderFormMetadata tableMetadata;
     
     private String lookupResultsSequenceNumber;
     
     /**
      * @see LookupForm#addRequiredNonEditableProperties()
      */
     @Override
     public void addRequiredNonEditableProperties(){
             super.addRequiredNonEditableProperties();
             registerRequiredNonEditableProperty(KRADConstants.LOOKUP_RESULTS_SEQUENCE_NUMBER);
             registerRequiredNonEditableProperty(KRADConstants.LOOKED_UP_COLLECTION_NAME);
     }
     
     /**
      * The number of rows that match the query criteria
      */
     private int resultsActualSize;
     
     /**
      * The number of rows that match the query criteria or
      *  the max results limit size (if applicable), whichever is less
      */
     private int resultsLimitedSize;
     
     /**
      * when the looked results screen was rendered, the index of the column that the results were sorted on.  -1 for unknown, index numbers
      * starting at 0
      */
     private String previouslySortedColumnIndex;
     
     /**
      * Comment for <code>columnToSortIndex</code>
      */
     private int columnToSortIndex;
     
     /**
      * the name of the collection being looked up by the calling page.  This value will be returned unmodified to the 
      * calling page (indicated by super.getBackLocation()), which should use it to determine in which collection the 
      * selected results will be returned.
      */
     private String lookedUpCollectionName;
     
     /**
      * Those object IDs that were selected before the current page is rendered 
      */
     private Set<String> previouslySelectedObjectIdSet;
     /**
      * Those object IDs that are rendered on the current page
      */
     private Set<String> displayedObjectIdSet;
     /**
      * Those object IDs that are selected/checked on the current page
      */
     private Set<String> selectedObjectIdSet;
     /**
      * The object IDs that are selected after the struts action is complete; the obj IDs in the keys of this Map will be considered checked in the UI
      */
     private Map<String, String> compositeObjectIdMap;
     
     public MultipleValueLookupForm() {
         tableMetadata = new KualiTableRenderFormMetadata();
         setHtmlDataType(HtmlData.INPUT_HTML_DATA_TYPE);
     }
     
     @Override
     public void populate(HttpServletRequest request) {
         super.populate(request);
         
         if (StringUtils.isNotBlank(request.getParameter(KRADConstants.TableRenderConstants.VIEWED_PAGE_NUMBER))) {
             setViewedPageNumber(Integer.parseInt(request.getParameter(KRADConstants.TableRenderConstants.VIEWED_PAGE_NUMBER)));
         }
         else {
             setViewedPageNumber(0); // first page is page 0
         }
         
         if (KRADConstants.TableRenderConstants.SWITCH_TO_PAGE_METHOD.equals(getMethodToCall())) {
             final String paramPrefix = KRADConstants.DISPATCH_REQUEST_PARAMETER + "." + KRADConstants.TableRenderConstants.SWITCH_TO_PAGE_METHOD + ".";
                 setSwitchToPageNumber(PagingBannerUtils.getNumbericalValueAfterPrefix(paramPrefix, request.getParameterNames()));
             if (getSwitchToPageNumber() == -1) {
                 throw new RuntimeException("Couldn't find page number");
             }
         }
         
         if (KRADConstants.TableRenderConstants.SORT_METHOD.equals(getMethodToCall())) {
             final String paramPrefix = KRADConstants.DISPATCH_REQUEST_PARAMETER + "." + KRADConstants.TableRenderConstants.SORT_METHOD + ".";
             setColumnToSortIndex(
                     PagingBannerUtils.getNumbericalValueAfterPrefix(paramPrefix, request.getParameterNames()));
             if (getColumnToSortIndex() == -1) {
                 throw new RuntimeException("Couldn't find column to sort");
             }
         }
         
         setPreviouslySelectedObjectIdSet(parsePreviouslySelectedObjectIds(request));
         setSelectedObjectIdSet(parseSelectedObjectIdSet(request));
         setDisplayedObjectIdSet(parseDisplayedObjectIdSet(request));
 
         setSearchUsingOnlyPrimaryKeyValues(parseSearchUsingOnlyPrimaryKeyValues(request));
         if (isSearchUsingOnlyPrimaryKeyValues()) {
             setPrimaryKeyFieldLabels(getLookupable().getPrimaryKeyFieldLabels());
         }
     }
     
 
     
     /**
      * This method converts the composite object IDs into a String
      * @return
      */
     public String getCompositeSelectedObjectIds() {
         return LookupUtils.convertSetOfObjectIdsToString(getCompositeObjectIdMap().keySet());
     }
 
     protected Set<String> parsePreviouslySelectedObjectIds(HttpServletRequest request) {
         String previouslySelectedObjectIds = request.getParameter(KRADConstants.MULTIPLE_VALUE_LOOKUP_PREVIOUSLY_SELECTED_OBJ_IDS_PARAM);
         return LookupUtils.convertStringOfObjectIdsToSet(previouslySelectedObjectIds);
     }
     
     protected Set<String> parseSelectedObjectIdSet(HttpServletRequest request) {
         Set<String> set = new HashSet<String>();
         
         Enumeration paramNames = request.getParameterNames();
         while (paramNames.hasMoreElements()) {
             String paramName = (String) paramNames.nextElement();
             if (paramName.startsWith(KRADConstants.MULTIPLE_VALUE_LOOKUP_SELECTED_OBJ_ID_PARAM_PREFIX) && StringUtils.isNotBlank(request.getParameter(paramName))) {
                 set.add(StringUtils.substringAfter(paramName, KRADConstants.MULTIPLE_VALUE_LOOKUP_SELECTED_OBJ_ID_PARAM_PREFIX));
             }
         }
         return set;
     }
     
     protected Set<String> parseDisplayedObjectIdSet(HttpServletRequest request) {
         Set<String> set = new HashSet<String>();
         
         Enumeration paramNames = request.getParameterNames();
         while (paramNames.hasMoreElements()) {
             String paramName = (String) paramNames.nextElement();
             if (paramName.startsWith(KRADConstants.MULTIPLE_VALUE_LOOKUP_DISPLAYED_OBJ_ID_PARAM_PREFIX) && StringUtils.isNotBlank(request.getParameter(paramName))) {
                 set.add(StringUtils.substringAfter(paramName, KRADConstants.MULTIPLE_VALUE_LOOKUP_DISPLAYED_OBJ_ID_PARAM_PREFIX));
             }
         }
         return set;
     }
     
     /**
      * Iterates through the request params, looks for the parameter representing the method to call in the format like
      * methodToCall.sort.1.(::;true;::).x, and returns the boolean value in the (::; and ;::) delimiters.
      * 
      * @see MultipleValueLookupForm#parseSearchUsingOnlyPrimaryKeyValues(String)
      * 
      * @param request
      * @return
      */
     protected boolean parseSearchUsingOnlyPrimaryKeyValues(HttpServletRequest request) {
         // the param we're looking for looks like: methodToCall.sort.1.(::;true;::).x , we want to parse out the "true" component
         String paramPrefix = KRADConstants.DISPATCH_REQUEST_PARAMETER + "." + getMethodToCall() + ".";
         for (Enumeration i = request.getParameterNames(); i.hasMoreElements();) {
             String parameterName = (String) i.nextElement();
             if (parameterName.startsWith(paramPrefix) && parameterName.endsWith(".x")) {
                 return parseSearchUsingOnlyPrimaryKeyValues(parameterName);
             }
         }
         // maybe doing an initial search, so no value will be present 
         return false;
     }
     
     /**
      * Parses the method to call parameter passed in as a post parameter
      * 
      * The parameter should be something like methodToCall.sort.1.(::;true;::).x, this method will return the value
      * between (::; and ;::) as a boolean
      * 
      * @param methodToCallParam the method to call in a format described above
      * @return the value between the delimiters, false if there are no delimiters
      */
     protected boolean parseSearchUsingOnlyPrimaryKeyValues(String methodToCallParam) {
         String searchUsingOnlyPrimaryKeyValuesStr = StringUtils.substringBetween(methodToCallParam, KRADConstants.METHOD_TO_CALL_PARM12_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM12_RIGHT_DEL);
         if (StringUtils.isBlank(searchUsingOnlyPrimaryKeyValuesStr)) {
             return false;
         }
         return Boolean.parseBoolean(searchUsingOnlyPrimaryKeyValuesStr);
     }
     
     public int getViewedPageNumber() {
         return tableMetadata.getViewedPageNumber();
     }
 
     public void setViewedPageNumber(int pageNumberBeingViewedForMultivalueLookups) {
         tableMetadata.setViewedPageNumber(pageNumberBeingViewedForMultivalueLookups);
     }
 
     public String getLookupResultsSequenceNumber() {
         return lookupResultsSequenceNumber;
     }
 
     public void setLookupResultsSequenceNumber(String lookupResultSequenceNumber) {
         this.lookupResultsSequenceNumber = lookupResultSequenceNumber;
     }
     
     public int getTotalNumberOfPages() {
         return tableMetadata.getTotalNumberOfPages();
     }
 
     public void setTotalNumberOfPages(int totalNumberOfPages) {
         tableMetadata.setTotalNumberOfPages(totalNumberOfPages);
     }
 
     public int getFirstRowIndex() {
         return tableMetadata.getFirstRowIndex();
     }
 
     public void setFirstRowIndex(int firstRowIndex) {
         tableMetadata.setFirstRowIndex(firstRowIndex);
     }
 
     public int getLastRowIndex() {
         return tableMetadata.getLastRowIndex();
     }
 
     public void setLastRowIndex(int lastRowIndex) {
         tableMetadata.setLastRowIndex(lastRowIndex);
     }
 
     public int getSwitchToPageNumber() {
         return tableMetadata.getSwitchToPageNumber();
     }
 
     protected void setSwitchToPageNumber(int switchToPageNumber) {
         tableMetadata.setSwitchToPageNumber(switchToPageNumber);
     }
 
     public Set<String> getPreviouslySelectedObjectIdSet() {
         return previouslySelectedObjectIdSet;
     }
 
     public void setPreviouslySelectedObjectIdSet(Set<String> previouslySelectedObjectIds) {
         this.previouslySelectedObjectIdSet = previouslySelectedObjectIds;
     }
 
     public Set<String> getSelectedObjectIdSet() {
         return selectedObjectIdSet;
     }
 
     public void setSelectedObjectIdSet(Set<String> selectedObjectIdSet) {
         this.selectedObjectIdSet = selectedObjectIdSet;
     }
 
     public Set<String> getDisplayedObjectIdSet() {
         return displayedObjectIdSet;
     }
 
     public void setDisplayedObjectIdSet(Set<String> displayedObjectIdSet) {
         this.displayedObjectIdSet = displayedObjectIdSet;
     }
 
     public Map<String, String> getCompositeObjectIdMap() {
         return compositeObjectIdMap;
     }
 
     public void setCompositeObjectIdMap(Map<String, String> compositeObjectIdMap) {
         this.compositeObjectIdMap = compositeObjectIdMap;
     }
 
     public int getColumnToSortIndex() {
         return columnToSortIndex;
     }
 
     public void setColumnToSortIndex(int columnToSortIndex) {
         this.columnToSortIndex = columnToSortIndex;
     }
 
     public String getPreviouslySortedColumnIndex() {
         return previouslySortedColumnIndex;
     }
 
     public void setPreviouslySortedColumnIndex(String previouslySortedColumnIndex) {
         this.previouslySortedColumnIndex = previouslySortedColumnIndex;
     }
 
     /**
      * gets the name of the collection being looked up by the calling page.  This value will be returned unmodified to the 
      * calling page (indicated by super.getBackLocation()), which should use it to determine in which collection the 
      * selected results will be returned.
      * 
      * @return
      */
     public String getLookedUpCollectionName() {
         return lookedUpCollectionName;
     }
 
     /**
      * sets the name of the collection being looked up by the calling page.  This value will be returned unmodified to the 
      * calling page (indicated by super.getBackLocation()), which should use it to determine in which collection the 
      * selected results will be returned
      * 
      * @param lookedUpCollectionName
      */
     public void setLookedUpCollectionName(String lookedUpCollectionName) {
         this.lookedUpCollectionName = lookedUpCollectionName;
     }
 
     public int getResultsActualSize() {
         return resultsActualSize;
     }
 
     public void setResultsActualSize(int resultsActualSize) {
         this.resultsActualSize = resultsActualSize;
     }
 
     public int getResultsLimitedSize() {
         return resultsLimitedSize;
     }
 
     public void setResultsLimitedSize(int resultsLimitedSize) {
         this.resultsLimitedSize = resultsLimitedSize;
     }
     
     public void jumpToFirstPage(int listSize, int maxRowsPerPage) {
         tableMetadata.jumpToFirstPage(listSize, maxRowsPerPage);
     }
     
     public void jumpToLastPage(int listSize, int maxRowsPerPage) {
         tableMetadata.jumpToLastPage(listSize, maxRowsPerPage);
     }
     
     public void jumpToPage(int pageNumber, int listSize, int maxRowsPerPage) {
         tableMetadata.jumpToPage(pageNumber, listSize, maxRowsPerPage);
     }
 }

1		/**
2		* Copyright 2005-2011 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		package org.kuali.rice.kns.web.struts.form;
17
18		import org.apache.commons.lang.StringUtils;
19		import org.kuali.rice.kns.lookup.HtmlData;
20		import org.kuali.rice.kns.lookup.LookupUtils;
21		import org.kuali.rice.kns.util.PagingBannerUtils;
22		import org.kuali.rice.krad.util.KRADConstants;
23
24		import javax.servlet.http.HttpServletRequest;
25		import java.util.Enumeration;
26		import java.util.HashSet;
27		import java.util.Map;
28		import java.util.Set;
29
30		/**
31		* Form to handle multiple value lookups
32		*
33		* @author Kuali Rice Team (rice.collab@kuali.org)
34		*
35		*/
36		public class MultipleValueLookupForm extends LookupForm {
37	0	private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(MultipleValueLookupForm.class);
38
39		private KualiTableRenderFormMetadata tableMetadata;
40
41		private String lookupResultsSequenceNumber;
42
43		/**
44		* @see LookupForm#addRequiredNonEditableProperties()
45		*/
46		@Override
47		public void addRequiredNonEditableProperties(){
48	0	super.addRequiredNonEditableProperties();
49	0	registerRequiredNonEditableProperty(KRADConstants.LOOKUP_RESULTS_SEQUENCE_NUMBER);
50	0	registerRequiredNonEditableProperty(KRADConstants.LOOKED_UP_COLLECTION_NAME);
51	0	}
52
53		/**
54		* The number of rows that match the query criteria
55		*/
56		private int resultsActualSize;
57
58		/**
59		* The number of rows that match the query criteria or
60		* the max results limit size (if applicable), whichever is less
61		*/
62		private int resultsLimitedSize;
63
64		/**
65		* when the looked results screen was rendered, the index of the column that the results were sorted on. -1 for unknown, index numbers
66		* starting at 0
67		*/
68		private String previouslySortedColumnIndex;
69
70		/**
71		* Comment for <code>columnToSortIndex</code>
72		*/
73		private int columnToSortIndex;
74
75		/**
76		* the name of the collection being looked up by the calling page. This value will be returned unmodified to the
77		* calling page (indicated by super.getBackLocation()), which should use it to determine in which collection the
78		* selected results will be returned.
79		*/
80		private String lookedUpCollectionName;
81
82		/**
83		* Those object IDs that were selected before the current page is rendered
84		*/
85		private Set<String> previouslySelectedObjectIdSet;
86		/**
87		* Those object IDs that are rendered on the current page
88		*/
89		private Set<String> displayedObjectIdSet;
90		/**
91		* Those object IDs that are selected/checked on the current page
92		*/
93		private Set<String> selectedObjectIdSet;
94		/**
95		* The object IDs that are selected after the struts action is complete; the obj IDs in the keys of this Map will be considered checked in the UI
96		*/
97		private Map<String, String> compositeObjectIdMap;
98
99	0	public MultipleValueLookupForm() {
100	0	tableMetadata = new KualiTableRenderFormMetadata();
101	0	setHtmlDataType(HtmlData.INPUT_HTML_DATA_TYPE);
102	0	}
103
104		@Override
105		public void populate(HttpServletRequest request) {
106	0	super.populate(request);
107
108	0	if (StringUtils.isNotBlank(request.getParameter(KRADConstants.TableRenderConstants.VIEWED_PAGE_NUMBER))) {
109	0	setViewedPageNumber(Integer.parseInt(request.getParameter(KRADConstants.TableRenderConstants.VIEWED_PAGE_NUMBER)));
110		}
111		else {
112	0	setViewedPageNumber(0); // first page is page 0
113		}
114
115	0	if (KRADConstants.TableRenderConstants.SWITCH_TO_PAGE_METHOD.equals(getMethodToCall())) {
116	0	final String paramPrefix = KRADConstants.DISPATCH_REQUEST_PARAMETER + "." + KRADConstants.TableRenderConstants.SWITCH_TO_PAGE_METHOD + ".";
117	0	setSwitchToPageNumber(PagingBannerUtils.getNumbericalValueAfterPrefix(paramPrefix, request.getParameterNames()));
118	0	if (getSwitchToPageNumber() == -1) {
119	0	throw new RuntimeException("Couldn't find page number");
120		}
121		}
122
123	0	if (KRADConstants.TableRenderConstants.SORT_METHOD.equals(getMethodToCall())) {
124	0	final String paramPrefix = KRADConstants.DISPATCH_REQUEST_PARAMETER + "." + KRADConstants.TableRenderConstants.SORT_METHOD + ".";
125	0	setColumnToSortIndex(
126		PagingBannerUtils.getNumbericalValueAfterPrefix(paramPrefix, request.getParameterNames()));
127	0	if (getColumnToSortIndex() == -1) {
128	0	throw new RuntimeException("Couldn't find column to sort");
129		}
130		}
131
132	0	setPreviouslySelectedObjectIdSet(parsePreviouslySelectedObjectIds(request));
133	0	setSelectedObjectIdSet(parseSelectedObjectIdSet(request));
134	0	setDisplayedObjectIdSet(parseDisplayedObjectIdSet(request));
135
136	0	setSearchUsingOnlyPrimaryKeyValues(parseSearchUsingOnlyPrimaryKeyValues(request));
137	0	if (isSearchUsingOnlyPrimaryKeyValues()) {
138	0	setPrimaryKeyFieldLabels(getLookupable().getPrimaryKeyFieldLabels());
139		}
140	0	}
141
142
143
144		/**
145		* This method converts the composite object IDs into a String
146		* @return
147		*/
148		public String getCompositeSelectedObjectIds() {
149	0	return LookupUtils.convertSetOfObjectIdsToString(getCompositeObjectIdMap().keySet());
150		}
151
152		protected Set<String> parsePreviouslySelectedObjectIds(HttpServletRequest request) {
153	0	String previouslySelectedObjectIds = request.getParameter(KRADConstants.MULTIPLE_VALUE_LOOKUP_PREVIOUSLY_SELECTED_OBJ_IDS_PARAM);
154	0	return LookupUtils.convertStringOfObjectIdsToSet(previouslySelectedObjectIds);
155		}
156
157		protected Set<String> parseSelectedObjectIdSet(HttpServletRequest request) {
158	0	Set<String> set = new HashSet<String>();
159
160	0	Enumeration paramNames = request.getParameterNames();
161	0	while (paramNames.hasMoreElements()) {
162	0	String paramName = (String) paramNames.nextElement();
163	0	if (paramName.startsWith(KRADConstants.MULTIPLE_VALUE_LOOKUP_SELECTED_OBJ_ID_PARAM_PREFIX) && StringUtils.isNotBlank(request.getParameter(paramName))) {
164	0	set.add(StringUtils.substringAfter(paramName, KRADConstants.MULTIPLE_VALUE_LOOKUP_SELECTED_OBJ_ID_PARAM_PREFIX));
165		}
166	0	}
167	0	return set;
168		}
169
170		protected Set<String> parseDisplayedObjectIdSet(HttpServletRequest request) {
171	0	Set<String> set = new HashSet<String>();
172
173	0	Enumeration paramNames = request.getParameterNames();
174	0	while (paramNames.hasMoreElements()) {
175	0	String paramName = (String) paramNames.nextElement();
176	0	if (paramName.startsWith(KRADConstants.MULTIPLE_VALUE_LOOKUP_DISPLAYED_OBJ_ID_PARAM_PREFIX) && StringUtils.isNotBlank(request.getParameter(paramName))) {
177	0	set.add(StringUtils.substringAfter(paramName, KRADConstants.MULTIPLE_VALUE_LOOKUP_DISPLAYED_OBJ_ID_PARAM_PREFIX));
178		}
179	0	}
180	0	return set;
181		}
182
183		/**
184		* Iterates through the request params, looks for the parameter representing the method to call in the format like
185		* methodToCall.sort.1.(::;true;::).x, and returns the boolean value in the (::; and ;::) delimiters.
186		*
187		* @see MultipleValueLookupForm#parseSearchUsingOnlyPrimaryKeyValues(String)
188		*
189		* @param request
190		* @return
191		*/
192		protected boolean parseSearchUsingOnlyPrimaryKeyValues(HttpServletRequest request) {
193		// the param we're looking for looks like: methodToCall.sort.1.(::;true;::).x , we want to parse out the "true" component
194	0	String paramPrefix = KRADConstants.DISPATCH_REQUEST_PARAMETER + "." + getMethodToCall() + ".";
195	0	for (Enumeration i = request.getParameterNames(); i.hasMoreElements();) {
196	0	String parameterName = (String) i.nextElement();
197	0	if (parameterName.startsWith(paramPrefix) && parameterName.endsWith(".x")) {
198	0	return parseSearchUsingOnlyPrimaryKeyValues(parameterName);
199		}
200	0	}
201		// maybe doing an initial search, so no value will be present
202	0	return false;
203		}
204
205		/**
206		* Parses the method to call parameter passed in as a post parameter
207		*
208		* The parameter should be something like methodToCall.sort.1.(::;true;::).x, this method will return the value
209		* between (::; and ;::) as a boolean
210		*
211		* @param methodToCallParam the method to call in a format described above
212		* @return the value between the delimiters, false if there are no delimiters
213		*/
214		protected boolean parseSearchUsingOnlyPrimaryKeyValues(String methodToCallParam) {
215	0	String searchUsingOnlyPrimaryKeyValuesStr = StringUtils.substringBetween(methodToCallParam, KRADConstants.METHOD_TO_CALL_PARM12_LEFT_DEL, KRADConstants.METHOD_TO_CALL_PARM12_RIGHT_DEL);
216	0	if (StringUtils.isBlank(searchUsingOnlyPrimaryKeyValuesStr)) {
217	0	return false;
218		}
219	0	return Boolean.parseBoolean(searchUsingOnlyPrimaryKeyValuesStr);
220		}
221
222		public int getViewedPageNumber() {
223	0	return tableMetadata.getViewedPageNumber();
224		}
225
226		public void setViewedPageNumber(int pageNumberBeingViewedForMultivalueLookups) {
227	0	tableMetadata.setViewedPageNumber(pageNumberBeingViewedForMultivalueLookups);
228	0	}
229
230		public String getLookupResultsSequenceNumber() {
231	0	return lookupResultsSequenceNumber;
232		}
233
234		public void setLookupResultsSequenceNumber(String lookupResultSequenceNumber) {
235	0	this.lookupResultsSequenceNumber = lookupResultSequenceNumber;
236	0	}
237
238		public int getTotalNumberOfPages() {
239	0	return tableMetadata.getTotalNumberOfPages();
240		}
241
242		public void setTotalNumberOfPages(int totalNumberOfPages) {
243	0	tableMetadata.setTotalNumberOfPages(totalNumberOfPages);
244	0	}
245
246		public int getFirstRowIndex() {
247	0	return tableMetadata.getFirstRowIndex();
248		}
249
250		public void setFirstRowIndex(int firstRowIndex) {
251	0	tableMetadata.setFirstRowIndex(firstRowIndex);
252	0	}
253
254		public int getLastRowIndex() {
255	0	return tableMetadata.getLastRowIndex();
256		}
257
258		public void setLastRowIndex(int lastRowIndex) {
259	0	tableMetadata.setLastRowIndex(lastRowIndex);
260	0	}
261
262		public int getSwitchToPageNumber() {
263	0	return tableMetadata.getSwitchToPageNumber();
264		}
265
266		protected void setSwitchToPageNumber(int switchToPageNumber) {
267	0	tableMetadata.setSwitchToPageNumber(switchToPageNumber);
268	0	}
269
270		public Set<String> getPreviouslySelectedObjectIdSet() {
271	0	return previouslySelectedObjectIdSet;
272		}
273
274		public void setPreviouslySelectedObjectIdSet(Set<String> previouslySelectedObjectIds) {
275	0	this.previouslySelectedObjectIdSet = previouslySelectedObjectIds;
276	0	}
277
278		public Set<String> getSelectedObjectIdSet() {
279	0	return selectedObjectIdSet;
280		}
281
282		public void setSelectedObjectIdSet(Set<String> selectedObjectIdSet) {
283	0	this.selectedObjectIdSet = selectedObjectIdSet;
284	0	}
285
286		public Set<String> getDisplayedObjectIdSet() {
287	0	return displayedObjectIdSet;
288		}
289
290		public void setDisplayedObjectIdSet(Set<String> displayedObjectIdSet) {
291	0	this.displayedObjectIdSet = displayedObjectIdSet;
292	0	}
293
294		public Map<String, String> getCompositeObjectIdMap() {
295	0	return compositeObjectIdMap;
296		}
297
298		public void setCompositeObjectIdMap(Map<String, String> compositeObjectIdMap) {
299	0	this.compositeObjectIdMap = compositeObjectIdMap;
300	0	}
301
302		public int getColumnToSortIndex() {
303	0	return columnToSortIndex;
304		}
305
306		public void setColumnToSortIndex(int columnToSortIndex) {
307	0	this.columnToSortIndex = columnToSortIndex;
308	0	}
309
310		public String getPreviouslySortedColumnIndex() {
311	0	return previouslySortedColumnIndex;
312		}
313
314		public void setPreviouslySortedColumnIndex(String previouslySortedColumnIndex) {
315	0	this.previouslySortedColumnIndex = previouslySortedColumnIndex;
316	0	}
317
318		/**
319		* gets the name of the collection being looked up by the calling page. This value will be returned unmodified to the
320		* calling page (indicated by super.getBackLocation()), which should use it to determine in which collection the
321		* selected results will be returned.
322		*
323		* @return
324		*/
325		public String getLookedUpCollectionName() {
326	0	return lookedUpCollectionName;
327		}
328
329		/**
330		* sets the name of the collection being looked up by the calling page. This value will be returned unmodified to the
331		* calling page (indicated by super.getBackLocation()), which should use it to determine in which collection the
332		* selected results will be returned
333		*
334		* @param lookedUpCollectionName
335		*/
336		public void setLookedUpCollectionName(String lookedUpCollectionName) {
337	0	this.lookedUpCollectionName = lookedUpCollectionName;
338	0	}
339
340		public int getResultsActualSize() {
341	0	return resultsActualSize;
342		}
343
344		public void setResultsActualSize(int resultsActualSize) {
345	0	this.resultsActualSize = resultsActualSize;
346	0	}
347
348		public int getResultsLimitedSize() {
349	0	return resultsLimitedSize;
350		}
351
352		public void setResultsLimitedSize(int resultsLimitedSize) {
353	0	this.resultsLimitedSize = resultsLimitedSize;
354	0	}
355
356		public void jumpToFirstPage(int listSize, int maxRowsPerPage) {
357	0	tableMetadata.jumpToFirstPage(listSize, maxRowsPerPage);
358	0	}
359
360		public void jumpToLastPage(int listSize, int maxRowsPerPage) {
361	0	tableMetadata.jumpToLastPage(listSize, maxRowsPerPage);
362	0	}
363
364		public void jumpToPage(int pageNumber, int listSize, int maxRowsPerPage) {
365	0	tableMetadata.jumpToPage(pageNumber, listSize, maxRowsPerPage);
366	0	}
367		}