1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    *
5    *
6    *
7    * The contents of this file are subject to the terms of the Liferay Enterprise
8    * Subscription License ("License"). You may not use this file except in
9    * compliance with the License. You can obtain a copy of the License by
10   * contacting Liferay, Inc. See the License for the specific language governing
11   * permissions and limitations under the License, including but not limited to
12   * distribution rights of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.kernel.dao.search;
24  
25  import com.liferay.portal.kernel.util.OrderByComparator;
26  import com.liferay.portal.kernel.util.ParamUtil;
27  
28  import java.util.ArrayList;
29  import java.util.List;
30  import java.util.Map;
31  
32  import javax.portlet.PortletRequest;
33  import javax.portlet.PortletURL;
34  
35  /**
36   * <a href="SearchContainer.java.html"><b><i>View Source</i></b></a>
37   *
38   * @author Brian Wing Shun Chan
39   */
40  public class SearchContainer<R> {
41  
42      public static final int DEFAULT_CUR = 1;
43  
44      public static final String DEFAULT_CUR_PARAM = "cur";
45  
46      /**
47       * @deprecated Use <code>DEFAULT_CUR</code>.
48       */
49      public static final int DEFAULT_CUR_VALUE = DEFAULT_CUR;
50  
51      public static final int DEFAULT_DELTA = 20;
52  
53      public static final boolean DEFAULT_DELTA_CONFIGURABLE = true;
54  
55      public static final String DEFAULT_DELTA_PARAM = "delta";
56  
57      /**
58       * @deprecated LPS-6312
59       */
60      public static final int DEFAULT_MAX_PAGES = 25;
61  
62      public static final String DEFAULT_ORDER_BY_COL_PARAM = "orderByCol";
63  
64      public static final String DEFAULT_ORDER_BY_TYPE_PARAM = "orderByType";
65  
66      public static final int MAX_DELTA = 200;
67  
68      public SearchContainer() {
69      }
70  
71      public SearchContainer(
72          PortletRequest portletRequest, PortletURL iteratorURL,
73          List<String> headerNames, String emptyResultsMessage) {
74  
75          this(
76              portletRequest, null, null, DEFAULT_CUR_PARAM, DEFAULT_DELTA,
77              iteratorURL, headerNames, emptyResultsMessage);
78      }
79  
80      public SearchContainer(
81          PortletRequest portletRequest, DisplayTerms displayTerms,
82          DisplayTerms searchTerms, String curParam, int delta,
83          PortletURL iteratorURL, List<String> headerNames,
84          String emptyResultsMessage) {
85  
86          this (
87              portletRequest, displayTerms, searchTerms, curParam, 0, delta,
88              iteratorURL, headerNames, emptyResultsMessage);
89      }
90  
91      public SearchContainer(
92          PortletRequest portletRequest, DisplayTerms displayTerms,
93          DisplayTerms searchTerms, String curParam, int cur, int delta,
94          PortletURL iteratorURL, List<String> headerNames,
95          String emptyResultsMessage) {
96  
97          _portletRequest = portletRequest;
98          _displayTerms = displayTerms;
99          _searchTerms = searchTerms;
100 
101         _curParam = curParam;
102 
103         if (cur < 1) {
104             _cur = ParamUtil.getInteger(portletRequest, _curParam, DEFAULT_CUR);
105 
106             if (_cur < 1) {
107                 _cur = DEFAULT_CUR;
108             }
109         }
110         else {
111             _cur = cur;
112         }
113 
114         setDelta(ParamUtil.getInteger(portletRequest, _deltaParam, delta));
115 
116         _iteratorURL = iteratorURL;
117 
118         _iteratorURL.setParameter(_curParam, String.valueOf(_cur));
119         _iteratorURL.setParameter(_deltaParam, String.valueOf(_delta));
120         _iteratorURL.setParameter(
121             DisplayTerms.KEYWORDS,
122             ParamUtil.getString(portletRequest, DisplayTerms.KEYWORDS));
123         _iteratorURL.setParameter(
124             DisplayTerms.ADVANCED_SEARCH,
125             String.valueOf(
126                 ParamUtil.getBoolean(
127                     portletRequest, DisplayTerms.ADVANCED_SEARCH)));
128         _iteratorURL.setParameter(
129             DisplayTerms.AND_OPERATOR,
130             String.valueOf(
131                 ParamUtil.getBoolean(
132                     portletRequest, DisplayTerms.AND_OPERATOR, true)));
133 
134         if (headerNames != null) {
135             _headerNames = new ArrayList<String>(headerNames.size());
136 
137             _headerNames.addAll(headerNames);
138         }
139 
140         _emptyResultsMessage = emptyResultsMessage;
141     }
142 
143     public int getCur() {
144         return _cur;
145     }
146 
147     public String getCurParam() {
148         return _curParam;
149     }
150 
151     /**
152      * @deprecated Use <code>getCur</code>.
153      */
154     public int getCurValue() {
155         return getCur();
156     }
157 
158     public int getDelta() {
159         return _delta;
160     }
161 
162     public String getDeltaParam() {
163         return _deltaParam;
164     }
165 
166     public DisplayTerms getDisplayTerms() {
167         return _displayTerms;
168     }
169 
170     public String getEmptyResultsMessage() {
171         return _emptyResultsMessage;
172     }
173 
174     public int getEnd() {
175         return _end;
176     }
177 
178     public List<String> getHeaderNames() {
179         return _headerNames;
180     }
181 
182     public String getId() {
183         return _id;
184     }
185 
186     public PortletURL getIteratorURL() {
187         return _iteratorURL;
188     }
189 
190     /**
191      * @deprecated LPS-6312
192      */
193     public int getMaxPages() {
194         return _maxPages;
195     }
196 
197     public Map<String, String> getOrderableHeaders() {
198         return _orderableHeaders;
199     }
200 
201     public String getOrderByCol() {
202         return _orderByCol;
203     }
204 
205     public String getOrderByColParam() {
206         return _orderByColParam;
207     }
208 
209     public OrderByComparator getOrderByComparator() {
210         return _orderByComparator;
211     }
212 
213     public String getOrderByType() {
214         return _orderByType;
215     }
216 
217     public String getOrderByTypeParam() {
218         return _orderByTypeParam;
219     }
220 
221     public PortletRequest getPortletRequest() {
222         return _portletRequest;
223     }
224 
225     public int getResultEnd() {
226         return _resultEnd;
227     }
228 
229     public List<ResultRow> getResultRows() {
230         return _resultRows;
231     }
232 
233     public List<R> getResults() {
234         return _results;
235     }
236 
237     public RowChecker getRowChecker() {
238         return _rowChecker;
239     }
240 
241     public DisplayTerms getSearchTerms() {
242         return _searchTerms;
243     }
244 
245     public int getStart() {
246         return _start;
247     }
248 
249     public int getTotal() {
250         return _total;
251     }
252 
253     public boolean isDeltaConfigurable() {
254         return _deltaConfigurable;
255     }
256 
257     public boolean isHover() {
258         return _hover;
259     }
260 
261     public void setDelta(int delta) {
262         if (delta <= 0) {
263             _delta = DEFAULT_DELTA;
264         }
265         else if (delta > MAX_DELTA) {
266             _delta = MAX_DELTA;
267         }
268         else {
269             _delta = delta;
270         }
271 
272         _calculateStartAndEnd();
273     }
274 
275     public void setDeltaConfigurable(boolean deltaConfigurable) {
276         _deltaConfigurable = deltaConfigurable;
277     }
278 
279     public void setDeltaParam(String deltaParam) {
280         _deltaParam = deltaParam;
281     }
282 
283     public void setEmptyResultsMessage(String emptyResultsMessage) {
284         _emptyResultsMessage = emptyResultsMessage;
285     }
286 
287     public void setHeaderNames(List<String> headerNames) {
288         _headerNames = headerNames;
289     }
290 
291     public void setHover(boolean hover) {
292         _hover = hover;
293     }
294 
295     public void setId(String id) {
296         _id = id;
297     }
298 
299     public void setIteratorURL(PortletURL iteratorURL) {
300         _iteratorURL = iteratorURL;
301     }
302 
303     /**
304      * @deprecated LPS-6312
305      */
306     public void setMaxPages(int maxPages) {
307         _maxPages = maxPages;
308     }
309 
310     public void setOrderableHeaders(Map<String, String> orderableHeaders) {
311         _orderableHeaders = orderableHeaders;
312     }
313 
314     public void setOrderByCol(String orderByCol) {
315         _orderByCol = orderByCol;
316 
317         _iteratorURL.setParameter(_orderByColParam, _orderByCol);
318     }
319 
320     public void setOrderByColParam(String orderByColParam) {
321         _orderByColParam = orderByColParam;
322     }
323 
324     public void setOrderByComparator(OrderByComparator orderByComparator) {
325         _orderByComparator = orderByComparator;
326     }
327 
328     public void setOrderByType(String orderByType) {
329         _orderByType = orderByType;
330 
331         _iteratorURL.setParameter(_orderByTypeParam, _orderByType);
332     }
333 
334     public void setOrderByTypeParam(String orderByTypeParam) {
335         _orderByTypeParam = orderByTypeParam;
336     }
337 
338     public void setResults(List<R> results) {
339         _results = results;
340     }
341 
342     public void setRowChecker(RowChecker rowChecker) {
343         _rowChecker = rowChecker;
344     }
345 
346     public void setTotal(int total) {
347         _total = total;
348 
349         if (((_cur - 1) * _delta) > _total) {
350             _cur = DEFAULT_CUR;
351         }
352 
353         _calculateStartAndEnd();
354     }
355 
356     private void _calculateStartAndEnd() {
357         _start = (_cur - 1) * _delta;
358         _end = _start + _delta;
359 
360         _resultEnd = _end;
361 
362         if (_resultEnd > _total) {
363             _resultEnd = _total;
364         }
365     }
366 
367     private int _cur;
368     private String _curParam = DEFAULT_CUR_PARAM;
369     private int _delta = DEFAULT_DELTA;
370     private boolean _deltaConfigurable = DEFAULT_DELTA_CONFIGURABLE;
371     private String _deltaParam = DEFAULT_DELTA_PARAM;
372     private DisplayTerms _displayTerms;
373     private String _emptyResultsMessage;
374     private int _end;
375     private List<String> _headerNames;
376     private boolean _hover = true;
377     private String _id;
378     private PortletURL _iteratorURL;
379 
380     /**
381      * @deprecated LPS-6312
382      */
383     private int _maxPages = DEFAULT_MAX_PAGES;
384 
385     private Map<String, String> _orderableHeaders;
386     private String _orderByCol;
387     private String _orderByColParam = DEFAULT_ORDER_BY_COL_PARAM;
388     private OrderByComparator _orderByComparator;
389     private String _orderByType;
390     private String _orderByTypeParam = DEFAULT_ORDER_BY_TYPE_PARAM;
391     private PortletRequest _portletRequest;
392     private int _resultEnd;
393     private List<ResultRow> _resultRows = new ArrayList<ResultRow>();
394     private List<R> _results = new ArrayList<R>();
395     private RowChecker _rowChecker;
396     private DisplayTerms _searchTerms;
397     private int _start;
398     private int _total;
399 
400 }