001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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.SearchContainerReference;
025    import com.liferay.portal.kernel.util.StringPool;
026    import com.liferay.portal.kernel.util.StringUtil;
027    import com.liferay.portal.kernel.util.TextFormatter;
028    import com.liferay.portal.kernel.util.Validator;
029    import com.liferay.portal.kernel.util.WebKeys;
030    import com.liferay.portal.util.PortalUtil;
031    
032    import java.util.ArrayList;
033    import java.util.List;
034    import java.util.Map;
035    
036    import javax.portlet.PortletRequest;
037    import javax.portlet.PortletURL;
038    
039    import javax.servlet.http.HttpServletRequest;
040    
041    /**
042     * @author Brian Wing Shun Chan
043     */
044    public class SearchContainer<R> {
045    
046            public static final int DEFAULT_CUR = 1;
047    
048            public static final String DEFAULT_CUR_PARAM = "cur";
049    
050            /**
051             * @deprecated As of 6.2.0, replaced by {@link #DEFAULT_CUR}.
052             */
053            public static final int DEFAULT_CUR_VALUE = DEFAULT_CUR;
054    
055            public static final int DEFAULT_DELTA = GetterUtil.getInteger(
056                    PropsUtil.get(PropsKeys.SEARCH_CONTAINER_PAGE_DEFAULT_DELTA));
057    
058            public static final boolean DEFAULT_DELTA_CONFIGURABLE = true;
059    
060            public static final String DEFAULT_DELTA_PARAM = "delta";
061    
062            public static final String DEFAULT_DEPRECATED_TOTAL_VAR = "deprecatedTotal";
063    
064            public static final boolean DEFAULT_FORCE_POST = false;
065    
066            /**
067             * @deprecated As of 6.2.0, see LPS-6312
068             */
069            public static final int DEFAULT_MAX_PAGES = 25;
070    
071            public static final String DEFAULT_ORDER_BY_COL_PARAM = "orderByCol";
072    
073            public static final String DEFAULT_ORDER_BY_TYPE_PARAM = "orderByType";
074    
075            public static final String DEFAULT_RESULTS_VAR = "results";
076    
077            public static final String DEFAULT_TOTAL_VAR = "total";
078    
079            public static final String DEFAULT_VAR = "searchContainer";
080    
081            public static final int MAX_DELTA = 200;
082    
083            public SearchContainer() {
084            }
085    
086            public SearchContainer(
087                    PortletRequest portletRequest, DisplayTerms displayTerms,
088                    DisplayTerms searchTerms, String curParam, int cur, int delta,
089                    PortletURL iteratorURL, List<String> headerNames,
090                    String emptyResultsMessage) {
091    
092                    _portletRequest = portletRequest;
093                    _displayTerms = displayTerms;
094                    _searchTerms = searchTerms;
095    
096                    _curParam = curParam;
097    
098                    boolean resetCur = ParamUtil.getBoolean(portletRequest, "resetCur");
099    
100                    if (resetCur) {
101                            _cur = DEFAULT_CUR;
102                    }
103                    else {
104                            if (cur < 1) {
105                                    _cur = ParamUtil.getInteger(
106                                            portletRequest, _curParam, DEFAULT_CUR);
107    
108                                    if (_cur < 1) {
109                                            _cur = DEFAULT_CUR;
110                                    }
111                            }
112                            else {
113                                    _cur = cur;
114                            }
115                    }
116    
117                    if (!_curParam.equals(DEFAULT_CUR_PARAM)) {
118                            _deltaParam =
119                                    DEFAULT_DELTA_PARAM +
120                                            StringUtil.replace(
121                                                    _curParam, DEFAULT_CUR_PARAM, StringPool.BLANK);
122                    }
123    
124                    setDelta(ParamUtil.getInteger(portletRequest, _deltaParam, delta));
125    
126                    _iteratorURL = iteratorURL;
127    
128                    _iteratorURL.setParameter(_curParam, String.valueOf(_cur));
129                    _iteratorURL.setParameter(_deltaParam, String.valueOf(_delta));
130                    _iteratorURL.setParameter(
131                            DisplayTerms.KEYWORDS,
132                            ParamUtil.getString(portletRequest, DisplayTerms.KEYWORDS));
133                    _iteratorURL.setParameter(
134                            DisplayTerms.ADVANCED_SEARCH,
135                            String.valueOf(
136                                    ParamUtil.getBoolean(
137                                            portletRequest, DisplayTerms.ADVANCED_SEARCH)));
138                    _iteratorURL.setParameter(
139                            DisplayTerms.AND_OPERATOR,
140                            String.valueOf(
141                                    ParamUtil.getBoolean(
142                                            portletRequest, DisplayTerms.AND_OPERATOR, true)));
143    
144                    if (headerNames != null) {
145                            _headerNames = new ArrayList<String>(headerNames.size());
146    
147                            _headerNames.addAll(headerNames);
148    
149                            _buildNormalizedHeaderNames(_headerNames);
150                    }
151    
152                    _emptyResultsMessage = emptyResultsMessage;
153    
154                    SearchContainerReference searchContainerReference =
155                            (SearchContainerReference)portletRequest.getAttribute(
156                                    WebKeys.SEARCH_CONTAINER_REFERENCE);
157    
158                    if (searchContainerReference != null) {
159                            searchContainerReference.register(this);
160                    }
161            }
162    
163            public SearchContainer(
164                    PortletRequest portletRequest, DisplayTerms displayTerms,
165                    DisplayTerms searchTerms, String curParam, int delta,
166                    PortletURL iteratorURL, List<String> headerNames,
167                    String emptyResultsMessage) {
168    
169                    this (
170                            portletRequest, displayTerms, searchTerms, curParam, 0, delta,
171                            iteratorURL, headerNames, emptyResultsMessage);
172            }
173    
174            public SearchContainer(
175                    PortletRequest portletRequest, PortletURL iteratorURL,
176                    List<String> headerNames, String emptyResultsMessage) {
177    
178                    this(
179                            portletRequest, null, null, DEFAULT_CUR_PARAM, DEFAULT_DELTA,
180                            iteratorURL, headerNames, emptyResultsMessage);
181            }
182    
183            public String getClassName() {
184                    return _className;
185            }
186    
187            public int getCur() {
188                    return _cur;
189            }
190    
191            public String getCurParam() {
192                    return _curParam;
193            }
194    
195            /**
196             * @deprecated As of 6.2.0, replaced by {@link #getCur}
197             */
198            public int getCurValue() {
199                    return getCur();
200            }
201    
202            public int getDelta() {
203                    return _delta;
204            }
205    
206            public String getDeltaParam() {
207                    return _deltaParam;
208            }
209    
210            public DisplayTerms getDisplayTerms() {
211                    return _displayTerms;
212            }
213    
214            public String getEmptyResultsMessage() {
215                    return _emptyResultsMessage;
216            }
217    
218            public int getEnd() {
219                    return _end;
220            }
221    
222            public List<String> getHeaderNames() {
223                    return _headerNames;
224            }
225    
226            public String getId(HttpServletRequest request, String namespace) {
227                    if (_uniqueId) {
228                            return _id;
229                    }
230    
231                    if (Validator.isNotNull(_id)) {
232                            _id = PortalUtil.getUniqueElementId(request, namespace, _id);
233                            _uniqueId = true;
234    
235                            return _id;
236                    }
237    
238                    String id = null;
239    
240                    if (Validator.isNotNull(_className)) {
241                            String simpleClassName = _className;
242    
243                            int pos = simpleClassName.lastIndexOf(StringPool.PERIOD);
244    
245                            if (pos != -1) {
246                                    simpleClassName = simpleClassName.substring(pos + 1);
247                            }
248    
249                            String variableCasingSimpleClassName = TextFormatter.format(
250                                    simpleClassName, TextFormatter.I);
251    
252                            id = TextFormatter.formatPlural(variableCasingSimpleClassName);
253    
254                            id = id.concat("SearchContainer");
255    
256                            _id = PortalUtil.getUniqueElementId(request, namespace, id);
257                            _uniqueId = true;
258    
259                            return _id;
260                    }
261    
262                    id = DeterminateKeyGenerator.generate("taglib_search_container");
263    
264                    _id = id.concat("SearchContainer");
265                    _uniqueId = true;
266    
267                    return _id;
268            }
269    
270            public PortletURL getIteratorURL() {
271                    return _iteratorURL;
272            }
273    
274            /**
275             * @deprecated As of 6.2.0, see LPS-6312
276             */
277            public int getMaxPages() {
278                    return _maxPages;
279            }
280    
281            public List<String> getNormalizedHeaderNames() {
282                    return _normalizedHeaderNames;
283            }
284    
285            public Map<String, String> getOrderableHeaders() {
286                    return _orderableHeaders;
287            }
288    
289            public String getOrderByCol() {
290                    return _orderByCol;
291            }
292    
293            public String getOrderByColParam() {
294                    return _orderByColParam;
295            }
296    
297            public OrderByComparator getOrderByComparator() {
298                    return _orderByComparator;
299            }
300    
301            public String getOrderByJS() {
302                    return _orderByJS;
303            }
304    
305            public String getOrderByType() {
306                    return _orderByType;
307            }
308    
309            public String getOrderByTypeParam() {
310                    return _orderByTypeParam;
311            }
312    
313            public PortletRequest getPortletRequest() {
314                    return _portletRequest;
315            }
316    
317            public int getResultEnd() {
318                    return _resultEnd;
319            }
320    
321            public List<ResultRow> getResultRows() {
322                    return _resultRows;
323            }
324    
325            public List<R> getResults() {
326                    return _results;
327            }
328    
329            public RowChecker getRowChecker() {
330                    return _rowChecker;
331            }
332    
333            public DisplayTerms getSearchTerms() {
334                    return _searchTerms;
335            }
336    
337            public int getStart() {
338                    return _start;
339            }
340    
341            public int getTotal() {
342                    return _total;
343            }
344    
345            public String getTotalVar() {
346                    return _totalVar;
347            }
348    
349            public boolean isDeltaConfigurable() {
350                    return _deltaConfigurable;
351            }
352    
353            public boolean isForcePost() {
354                    return _forcePost;
355            }
356    
357            public boolean isHover() {
358                    return _hover;
359            }
360    
361            public boolean isRecalculateCur() {
362                    if ((_total == 0) && (_cur == DEFAULT_CUR)) {
363                            return false;
364                    }
365    
366                    if (((_cur - 1) * _delta) >= _total) {
367                            return true;
368                    }
369    
370                    return false;
371            }
372    
373            public void setClassName(String className) {
374                    _className = className;
375            }
376    
377            public void setDelta(int delta) {
378                    if (delta <= 0) {
379                            _delta = DEFAULT_DELTA;
380                    }
381                    else if (delta > MAX_DELTA) {
382                            _delta = MAX_DELTA;
383                    }
384                    else {
385                            _delta = delta;
386                    }
387    
388                    _calculateStartAndEnd();
389            }
390    
391            public void setDeltaConfigurable(boolean deltaConfigurable) {
392                    _deltaConfigurable = deltaConfigurable;
393            }
394    
395            public void setDeltaParam(String deltaParam) {
396                    _deltaParam = deltaParam;
397            }
398    
399            public void setEmptyResultsMessage(String emptyResultsMessage) {
400                    _emptyResultsMessage = emptyResultsMessage;
401            }
402    
403            public void setForcePost(boolean forcePost) {
404                    _forcePost = forcePost;
405            }
406    
407            public void setHeaderNames(List<String> headerNames) {
408                    _headerNames = headerNames;
409    
410                    _buildNormalizedHeaderNames(headerNames);
411            }
412    
413            public void setHover(boolean hover) {
414                    _hover = hover;
415            }
416    
417            public void setId(String id) {
418                    _id = id;
419            }
420    
421            public void setIteratorURL(PortletURL iteratorURL) {
422                    _iteratorURL = iteratorURL;
423            }
424    
425            /**
426             * @deprecated As of 6.2.0, see LPS-6312
427             */
428            public void setMaxPages(int maxPages) {
429                    _maxPages = maxPages;
430            }
431    
432            public void setOrderableHeaders(Map<String, String> orderableHeaders) {
433                    _orderableHeaders = orderableHeaders;
434            }
435    
436            public void setOrderByCol(String orderByCol) {
437                    _orderByCol = orderByCol;
438    
439                    _iteratorURL.setParameter(_orderByColParam, _orderByCol);
440            }
441    
442            public void setOrderByColParam(String orderByColParam) {
443                    _orderByColParam = orderByColParam;
444            }
445    
446            public void setOrderByComparator(OrderByComparator orderByComparator) {
447                    _orderByComparator = orderByComparator;
448            }
449    
450            public void setOrderByJS(String orderByJS) {
451                    _orderByJS = orderByJS;
452            }
453    
454            public void setOrderByType(String orderByType) {
455                    _orderByType = orderByType;
456    
457                    _iteratorURL.setParameter(_orderByTypeParam, _orderByType);
458            }
459    
460            public void setOrderByTypeParam(String orderByTypeParam) {
461                    _orderByTypeParam = orderByTypeParam;
462            }
463    
464            public void setResults(List<R> results) {
465                    _results = results;
466            }
467    
468            public void setRowChecker(RowChecker rowChecker) {
469                    _rowChecker = rowChecker;
470            }
471    
472            public void setTotal(int total) {
473                    _total = total;
474    
475                    _calculateCur();
476                    _calculateStartAndEnd();
477            }
478    
479            public void setTotalVar(String totalVar) {
480                    _totalVar = totalVar;
481            }
482    
483            private void _buildNormalizedHeaderNames(List<String> headerNames) {
484                    if (headerNames == null) {
485                            return;
486                    }
487    
488                    _normalizedHeaderNames = new ArrayList<String>(headerNames.size());
489    
490                    for (String headerName : headerNames) {
491                            _normalizedHeaderNames.add(
492                                    FriendlyURLNormalizerUtil.normalize(headerName));
493                    }
494            }
495    
496            private void _calculateCur() {
497                    if (_total == 0) {
498                            _cur = DEFAULT_CUR;
499    
500                            return;
501                    }
502    
503                    if (isRecalculateCur()) {
504                            if ((_total % _delta) == 0) {
505                                    _cur = (_total / _delta);
506                            }
507                            else {
508                                    _cur = (_total / _delta) + 1;
509                            }
510                    }
511            }
512    
513            private void _calculateStartAndEnd() {
514                    int[] startAndEnd = SearchPaginationUtil.calculateStartAndEnd(
515                            _cur, _delta);
516    
517                    _start = startAndEnd[0];
518                    _end = startAndEnd[1];
519    
520                    _resultEnd = _end;
521    
522                    if (_resultEnd > _total) {
523                            _resultEnd = _total;
524                    }
525            }
526    
527            private String _className;
528            private int _cur;
529            private String _curParam = DEFAULT_CUR_PARAM;
530            private int _delta = DEFAULT_DELTA;
531            private boolean _deltaConfigurable = DEFAULT_DELTA_CONFIGURABLE;
532            private String _deltaParam = DEFAULT_DELTA_PARAM;
533            private DisplayTerms _displayTerms;
534            private String _emptyResultsMessage;
535            private int _end;
536            private boolean _forcePost = DEFAULT_FORCE_POST;
537            private List<String> _headerNames;
538            private boolean _hover = true;
539            private String _id;
540            private PortletURL _iteratorURL;
541    
542            /**
543             * @deprecated As of 6.2.0, see LPS-6312
544             */
545            private int _maxPages = DEFAULT_MAX_PAGES;
546    
547            private List<String> _normalizedHeaderNames;
548            private Map<String, String> _orderableHeaders;
549            private String _orderByCol;
550            private String _orderByColParam = DEFAULT_ORDER_BY_COL_PARAM;
551            private OrderByComparator _orderByComparator;
552            private String _orderByJS;
553            private String _orderByType;
554            private String _orderByTypeParam = DEFAULT_ORDER_BY_TYPE_PARAM;
555            private PortletRequest _portletRequest;
556            private int _resultEnd;
557            private List<ResultRow> _resultRows = new ArrayList<ResultRow>();
558            private List<R> _results = new ArrayList<R>();
559            private RowChecker _rowChecker;
560            private DisplayTerms _searchTerms;
561            private int _start;
562            private int _total;
563            private String _totalVar;
564            private boolean _uniqueId;
565    
566    }