001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.dao.search;
016    
017    import com.liferay.portal.kernel.util.DeterminateKeyGenerator;
018    import com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil;
019    import com.liferay.portal.kernel.util.GetterUtil;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ParamUtil;
022    import com.liferay.portal.kernel.util.PropsKeys;
023    import com.liferay.portal.kernel.util.PropsUtil;
024    import com.liferay.portal.kernel.util.StringPool;
025    import com.liferay.portal.kernel.util.StringUtil;
026    import com.liferay.portal.kernel.util.TextFormatter;
027    import com.liferay.portal.kernel.util.Validator;
028    import com.liferay.portal.util.PortalUtil;
029    
030    import java.util.ArrayList;
031    import java.util.List;
032    import java.util.Map;
033    
034    import javax.portlet.PortletRequest;
035    import javax.portlet.PortletURL;
036    
037    import javax.servlet.http.HttpServletRequest;
038    
039    /**
040     * @author Brian Wing Shun Chan
041     */
042    public class SearchContainer<R> {
043    
044            public static final int DEFAULT_CUR = 1;
045    
046            public static final String DEFAULT_CUR_PARAM = "cur";
047    
048            /**
049             * @deprecated Use <code>DEFAULT_CUR</code>.
050             */
051            public static final int DEFAULT_CUR_VALUE = DEFAULT_CUR;
052    
053            public static final int DEFAULT_DELTA = GetterUtil.getInteger(
054                    PropsUtil.get(PropsKeys.SEARCH_CONTAINER_PAGE_DEFAULT_DELTA));
055    
056            public static final boolean DEFAULT_DELTA_CONFIGURABLE = true;
057    
058            public static final String DEFAULT_DELTA_PARAM = "delta";
059    
060            /**
061             * @deprecated LPS-6312
062             */
063            public static final int DEFAULT_MAX_PAGES = 25;
064    
065            public static final String DEFAULT_ORDER_BY_COL_PARAM = "orderByCol";
066    
067            public static final String DEFAULT_ORDER_BY_TYPE_PARAM = "orderByType";
068    
069            public static final int MAX_DELTA = 200;
070    
071            public SearchContainer() {
072            }
073    
074            public SearchContainer(
075                    PortletRequest portletRequest, DisplayTerms displayTerms,
076                    DisplayTerms searchTerms, String curParam, int cur, int delta,
077                    PortletURL iteratorURL, List<String> headerNames,
078                    String emptyResultsMessage) {
079    
080                    _portletRequest = portletRequest;
081                    _displayTerms = displayTerms;
082                    _searchTerms = searchTerms;
083    
084                    _curParam = curParam;
085    
086                    boolean resetCur = ParamUtil.getBoolean(portletRequest, "resetCur");
087    
088                    if (resetCur) {
089                            _cur = DEFAULT_CUR;
090                    }
091                    else {
092                            if (cur < 1) {
093                                    _cur = ParamUtil.getInteger(
094                                            portletRequest, _curParam, DEFAULT_CUR);
095    
096                                    if (_cur < 1) {
097                                            _cur = DEFAULT_CUR;
098                                    }
099                            }
100                            else {
101                                    _cur = cur;
102                            }
103                    }
104    
105                    if (!_curParam.equals(DEFAULT_CUR_PARAM)) {
106                            _deltaParam =
107                                    DEFAULT_DELTA_PARAM +
108                                            StringUtil.replace(
109                                                    _curParam, DEFAULT_CUR_PARAM, StringPool.BLANK);
110                    }
111    
112                    setDelta(ParamUtil.getInteger(portletRequest, _deltaParam, delta));
113    
114                    _iteratorURL = iteratorURL;
115    
116                    _iteratorURL.setParameter(_curParam, String.valueOf(_cur));
117                    _iteratorURL.setParameter(_deltaParam, String.valueOf(_delta));
118                    _iteratorURL.setParameter(
119                            DisplayTerms.KEYWORDS,
120                            ParamUtil.getString(portletRequest, DisplayTerms.KEYWORDS));
121                    _iteratorURL.setParameter(
122                            DisplayTerms.ADVANCED_SEARCH,
123                            String.valueOf(
124                                    ParamUtil.getBoolean(
125                                            portletRequest, DisplayTerms.ADVANCED_SEARCH)));
126                    _iteratorURL.setParameter(
127                            DisplayTerms.AND_OPERATOR,
128                            String.valueOf(
129                                    ParamUtil.getBoolean(
130                                            portletRequest, DisplayTerms.AND_OPERATOR, true)));
131    
132                    if (headerNames != null) {
133                            _headerNames = new ArrayList<String>(headerNames.size());
134    
135                            _headerNames.addAll(headerNames);
136    
137                            _buildNormalizedHeaderNames(_headerNames);
138                    }
139    
140                    _emptyResultsMessage = emptyResultsMessage;
141            }
142    
143            public SearchContainer(
144                    PortletRequest portletRequest, DisplayTerms displayTerms,
145                    DisplayTerms searchTerms, String curParam, int delta,
146                    PortletURL iteratorURL, List<String> headerNames,
147                    String emptyResultsMessage) {
148    
149                    this (
150                            portletRequest, displayTerms, searchTerms, curParam, 0, delta,
151                            iteratorURL, headerNames, emptyResultsMessage);
152            }
153    
154            public SearchContainer(
155                    PortletRequest portletRequest, PortletURL iteratorURL,
156                    List<String> headerNames, String emptyResultsMessage) {
157    
158                    this(
159                            portletRequest, null, null, DEFAULT_CUR_PARAM, DEFAULT_DELTA,
160                            iteratorURL, headerNames, emptyResultsMessage);
161            }
162    
163            public String getClassName() {
164                    return _className;
165            }
166    
167            public int getCur() {
168                    return _cur;
169            }
170    
171            public String getCurParam() {
172                    return _curParam;
173            }
174    
175            /**
176             * @deprecated Use <code>getCur</code>.
177             */
178            public int getCurValue() {
179                    return getCur();
180            }
181    
182            public int getDelta() {
183                    return _delta;
184            }
185    
186            public String getDeltaParam() {
187                    return _deltaParam;
188            }
189    
190            public DisplayTerms getDisplayTerms() {
191                    return _displayTerms;
192            }
193    
194            public String getEmptyResultsMessage() {
195                    return _emptyResultsMessage;
196            }
197    
198            public int getEnd() {
199                    return _end;
200            }
201    
202            public List<String> getHeaderNames() {
203                    return _headerNames;
204            }
205    
206            public String getId(HttpServletRequest request, String namespace) {
207                    if (_uniqueId) {
208                            return _id;
209                    }
210    
211                    if (Validator.isNotNull(_id)) {
212                            _id = PortalUtil.getUniqueElementId(request, namespace, _id);
213                            _uniqueId = true;
214    
215                            return _id;
216                    }
217    
218                    String id = null;
219    
220                    if (Validator.isNotNull(_className)) {
221                            String simpleClassName = _className;
222    
223                            int pos = simpleClassName.lastIndexOf(StringPool.PERIOD);
224    
225                            if (pos != -1) {
226                                    simpleClassName = simpleClassName.substring(pos + 1);
227                            }
228    
229                            String variableCasingSimpleClassName = TextFormatter.format(
230                                    simpleClassName, TextFormatter.I);
231    
232                            id = TextFormatter.formatPlural(variableCasingSimpleClassName);
233    
234                            id = id.concat("SearchContainer");
235    
236                            _id = PortalUtil.getUniqueElementId(request, namespace, id);
237                            _uniqueId = true;
238    
239                            return _id;
240                    }
241                    else {
242                            id = DeterminateKeyGenerator.generate("taglib_search_container");
243    
244                            _id = id.concat("SearchContainer");
245                            _uniqueId = true;
246    
247                            return _id;
248                    }
249            }
250    
251            public PortletURL getIteratorURL() {
252                    return _iteratorURL;
253            }
254    
255            /**
256             * @deprecated LPS-6312
257             */
258            public int getMaxPages() {
259                    return _maxPages;
260            }
261    
262            public List<String> getNormalizedHeaderNames() {
263                    return _normalizedHeaderNames;
264            }
265    
266            public Map<String, String> getOrderableHeaders() {
267                    return _orderableHeaders;
268            }
269    
270            public String getOrderByCol() {
271                    return _orderByCol;
272            }
273    
274            public String getOrderByColParam() {
275                    return _orderByColParam;
276            }
277    
278            public OrderByComparator getOrderByComparator() {
279                    return _orderByComparator;
280            }
281    
282            public String getOrderByJS() {
283                    return _orderByJS;
284            }
285    
286            public String getOrderByType() {
287                    return _orderByType;
288            }
289    
290            public String getOrderByTypeParam() {
291                    return _orderByTypeParam;
292            }
293    
294            public PortletRequest getPortletRequest() {
295                    return _portletRequest;
296            }
297    
298            public int getResultEnd() {
299                    return _resultEnd;
300            }
301    
302            public List<ResultRow> getResultRows() {
303                    return _resultRows;
304            }
305    
306            public List<R> getResults() {
307                    return _results;
308            }
309    
310            public RowChecker getRowChecker() {
311                    return _rowChecker;
312            }
313    
314            public DisplayTerms getSearchTerms() {
315                    return _searchTerms;
316            }
317    
318            public int getStart() {
319                    return _start;
320            }
321    
322            public int getTotal() {
323                    return _total;
324            }
325    
326            public boolean isDeltaConfigurable() {
327                    return _deltaConfigurable;
328            }
329    
330            public boolean isHover() {
331                    return _hover;
332            }
333    
334            public void setClassName(String className) {
335                    _className = className;
336            }
337    
338            public void setDelta(int delta) {
339                    if (delta <= 0) {
340                            _delta = DEFAULT_DELTA;
341                    }
342                    else if (delta > MAX_DELTA) {
343                            _delta = MAX_DELTA;
344                    }
345                    else {
346                            _delta = delta;
347                    }
348    
349                    _calculateStartAndEnd();
350            }
351    
352            public void setDeltaConfigurable(boolean deltaConfigurable) {
353                    _deltaConfigurable = deltaConfigurable;
354            }
355    
356            public void setDeltaParam(String deltaParam) {
357                    _deltaParam = deltaParam;
358            }
359    
360            public void setEmptyResultsMessage(String emptyResultsMessage) {
361                    _emptyResultsMessage = emptyResultsMessage;
362            }
363    
364            public void setHeaderNames(List<String> headerNames) {
365                    _headerNames = headerNames;
366    
367                    _buildNormalizedHeaderNames(headerNames);
368            }
369    
370            public void setHover(boolean hover) {
371                    _hover = hover;
372            }
373    
374            public void setId(String id) {
375                    _id = id;
376            }
377    
378            public void setIteratorURL(PortletURL iteratorURL) {
379                    _iteratorURL = iteratorURL;
380            }
381    
382            /**
383             * @deprecated LPS-6312
384             */
385            public void setMaxPages(int maxPages) {
386                    _maxPages = maxPages;
387            }
388    
389            public void setOrderableHeaders(Map<String, String> orderableHeaders) {
390                    _orderableHeaders = orderableHeaders;
391            }
392    
393            public void setOrderByCol(String orderByCol) {
394                    _orderByCol = orderByCol;
395    
396                    _iteratorURL.setParameter(_orderByColParam, _orderByCol);
397            }
398    
399            public void setOrderByColParam(String orderByColParam) {
400                    _orderByColParam = orderByColParam;
401            }
402    
403            public void setOrderByComparator(OrderByComparator orderByComparator) {
404                    _orderByComparator = orderByComparator;
405            }
406    
407            public void setOrderByJS(String orderByJS) {
408                    _orderByJS = orderByJS;
409            }
410    
411            public void setOrderByType(String orderByType) {
412                    _orderByType = orderByType;
413    
414                    _iteratorURL.setParameter(_orderByTypeParam, _orderByType);
415            }
416    
417            public void setOrderByTypeParam(String orderByTypeParam) {
418                    _orderByTypeParam = orderByTypeParam;
419            }
420    
421            public void setResults(List<R> results) {
422                    _results = results;
423            }
424    
425            public void setRowChecker(RowChecker rowChecker) {
426                    _rowChecker = rowChecker;
427            }
428    
429            public void setTotal(int total) {
430                    _total = total;
431    
432                    if (((_cur - 1) * _delta) >= _total) {
433                            _cur = DEFAULT_CUR;
434                    }
435    
436                    _calculateStartAndEnd();
437            }
438    
439            private void _buildNormalizedHeaderNames(List<String> headerNames) {
440                    if (headerNames == null) {
441                            return;
442                    }
443    
444                    _normalizedHeaderNames = new ArrayList<String>(headerNames.size());
445    
446                    for (String headerName : headerNames) {
447                            _normalizedHeaderNames.add(
448                                    FriendlyURLNormalizerUtil.normalize(headerName));
449                    }
450            }
451    
452            private void _calculateStartAndEnd() {
453                    _start = (_cur - 1) * _delta;
454                    _end = _start + _delta;
455    
456                    _resultEnd = _end;
457    
458                    if (_resultEnd > _total) {
459                            _resultEnd = _total;
460                    }
461            }
462    
463            private String _className;
464            private int _cur;
465            private String _curParam = DEFAULT_CUR_PARAM;
466            private int _delta = DEFAULT_DELTA;
467            private boolean _deltaConfigurable = DEFAULT_DELTA_CONFIGURABLE;
468            private String _deltaParam = DEFAULT_DELTA_PARAM;
469            private DisplayTerms _displayTerms;
470            private String _emptyResultsMessage;
471            private int _end;
472            private List<String> _headerNames;
473            private boolean _hover = true;
474            private String _id;
475            private PortletURL _iteratorURL;
476    
477            /**
478             * @deprecated LPS-6312
479             */
480            private int _maxPages = DEFAULT_MAX_PAGES;
481    
482            private List<String> _normalizedHeaderNames;
483            private Map<String, String> _orderableHeaders;
484            private String _orderByCol;
485            private String _orderByColParam = DEFAULT_ORDER_BY_COL_PARAM;
486            private OrderByComparator _orderByComparator;
487            private String _orderByJS;
488            private String _orderByType;
489            private String _orderByTypeParam = DEFAULT_ORDER_BY_TYPE_PARAM;
490            private PortletRequest _portletRequest;
491            private int _resultEnd;
492            private List<ResultRow> _resultRows = new ArrayList<ResultRow>();
493            private List<R> _results = new ArrayList<R>();
494            private RowChecker _rowChecker;
495            private DisplayTerms _searchTerms;
496            private int _start;
497            private int _total;
498            private boolean _uniqueId;
499    
500    }