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