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.portlet.journal.service.persistence;
016    
017    import com.liferay.portal.kernel.dao.orm.QueryPos;
018    import com.liferay.portal.kernel.dao.orm.QueryUtil;
019    import com.liferay.portal.kernel.dao.orm.SQLQuery;
020    import com.liferay.portal.kernel.dao.orm.Session;
021    import com.liferay.portal.kernel.dao.orm.Type;
022    import com.liferay.portal.kernel.exception.SystemException;
023    import com.liferay.portal.kernel.util.OrderByComparator;
024    import com.liferay.portal.kernel.util.StringBundler;
025    import com.liferay.portal.kernel.util.StringPool;
026    import com.liferay.portal.kernel.util.StringUtil;
027    import com.liferay.portal.kernel.util.Validator;
028    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
029    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
030    import com.liferay.portlet.journal.model.JournalTemplate;
031    import com.liferay.portlet.journal.model.impl.JournalTemplateImpl;
032    import com.liferay.util.dao.orm.CustomSQLUtil;
033    
034    import java.util.Iterator;
035    import java.util.List;
036    
037    /**
038     * @author Brian Wing Shun Chan
039     * @author Bruno Farache
040     * @author Prakash Reddy
041     * @author Connor McKay
042     */
043    public class JournalTemplateFinderImpl
044            extends BasePersistenceImpl<JournalTemplate>
045            implements JournalTemplateFinder {
046    
047            public static final String COUNT_BY_C_G_T_S_N_D =
048                    JournalTemplateFinder.class.getName() + ".countByC_G_T_S_N_D";
049    
050            public static final String FIND_BY_C_G_T_S_N_D =
051                    JournalTemplateFinder.class.getName() + ".findByC_G_T_S_N_D";
052    
053            public int countByKeywords(
054                            long companyId, long[] groupIds, String keywords,
055                            String structureId, String structureIdComparator)
056                    throws SystemException {
057    
058                    String[] templateIds = null;
059                    String[] names = null;
060                    String[] descriptions = null;
061                    boolean andOperator = false;
062    
063                    if (Validator.isNotNull(keywords)) {
064                            templateIds = CustomSQLUtil.keywords(keywords, false);
065                            names = CustomSQLUtil.keywords(keywords);
066                            descriptions = CustomSQLUtil.keywords(keywords);
067                    }
068                    else {
069                            andOperator = true;
070                    }
071    
072                    return doCountByC_G_T_S_N_D(
073                            companyId, groupIds, templateIds, structureId,
074                            structureIdComparator, names, descriptions, andOperator, false);
075            }
076    
077            public int countByC_G_T_S_N_D(
078                            long companyId, long[] groupIds, String templateId,
079                            String structureId, String structureIdComparator, String name,
080                            String description, boolean andOperator)
081                    throws SystemException {
082    
083                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
084                    String[] names = CustomSQLUtil.keywords(name);
085                    String[] descriptions = CustomSQLUtil.keywords(description);
086    
087                    return doCountByC_G_T_S_N_D(
088                            companyId, groupIds, templateIds, structureId,
089                            structureIdComparator, names, descriptions, andOperator, false);
090            }
091    
092            public int filterCountByKeywords(
093                            long companyId, long[] groupIds, String keywords,
094                            String structureId, String structureIdComparator)
095                    throws SystemException {
096    
097                    String[] templateIds = null;
098                    String[] names = null;
099                    String[] descriptions = null;
100                    boolean andOperator = false;
101    
102                    if (Validator.isNotNull(keywords)) {
103                            templateIds = CustomSQLUtil.keywords(keywords, false);
104                            names = CustomSQLUtil.keywords(keywords);
105                            descriptions = CustomSQLUtil.keywords(keywords);
106                    }
107                    else {
108                            andOperator = true;
109                    }
110    
111                    return doCountByC_G_T_S_N_D(
112                            companyId, groupIds, templateIds, structureId,
113                            structureIdComparator, names, descriptions, andOperator, true);
114            }
115    
116            public int filterCountByC_G_T_S_N_D(
117                            long companyId, long[] groupIds, String templateId,
118                            String structureId, String structureIdComparator, String name,
119                            String description, boolean andOperator)
120                    throws SystemException {
121    
122                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
123                    String[] names = CustomSQLUtil.keywords(name);
124                    String[] descriptions = CustomSQLUtil.keywords(description);
125    
126                    return doCountByC_G_T_S_N_D(
127                            companyId, groupIds, templateIds, structureId,
128                            structureIdComparator, names, descriptions, andOperator, true);
129            }
130    
131            public List<JournalTemplate> filterFindByKeywords(
132                            long companyId, long[] groupIds, String keywords,
133                            String structureId, String structureIdComparator, int start,
134                            int end, OrderByComparator obc)
135                    throws SystemException {
136    
137                    String[] templateIds = null;
138                    String[] names = null;
139                    String[] descriptions = null;
140                    boolean andOperator = false;
141    
142                    if (Validator.isNotNull(keywords)) {
143                            templateIds = CustomSQLUtil.keywords(keywords, false);
144                            names = CustomSQLUtil.keywords(keywords);
145                            descriptions = CustomSQLUtil.keywords(keywords);
146                    }
147                    else {
148                            andOperator = true;
149                    }
150    
151                    return doFindByC_G_T_S_N_D(
152                            companyId, groupIds, templateIds, structureId,
153                            structureIdComparator, names, descriptions, andOperator, start, end,
154                            obc, true);
155            }
156    
157            public List<JournalTemplate> filterFindByC_G_T_S_N_D(
158                            long companyId, long[] groupIds, String templateId,
159                            String structureId, String structureIdComparator, String name,
160                            String description, boolean andOperator, int start, int end,
161                            OrderByComparator obc)
162                    throws SystemException {
163    
164                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
165                    String[] names = CustomSQLUtil.keywords(name);
166                    String[] descriptions = CustomSQLUtil.keywords(description);
167    
168                    return doFindByC_G_T_S_N_D(
169                            companyId, groupIds, templateIds, structureId,
170                            structureIdComparator, names, descriptions, andOperator, start, end,
171                            obc, true);
172            }
173    
174            public List<JournalTemplate> findByKeywords(
175                            long companyId, long[] groupIds, String keywords,
176                            String structureId, String structureIdComparator, int start,
177                            int end, OrderByComparator obc)
178                    throws SystemException {
179    
180                    String[] templateIds = null;
181                    String[] names = null;
182                    String[] descriptions = null;
183                    boolean andOperator = false;
184    
185                    if (Validator.isNotNull(keywords)) {
186                            templateIds = CustomSQLUtil.keywords(keywords, false);
187                            names = CustomSQLUtil.keywords(keywords);
188                            descriptions = CustomSQLUtil.keywords(keywords);
189                    }
190                    else {
191                            andOperator = true;
192                    }
193    
194                    return doFindByC_G_T_S_N_D(
195                            companyId, groupIds, templateIds, structureId,
196                            structureIdComparator, names, descriptions, andOperator, start, end,
197                            obc, false);
198            }
199    
200            public List<JournalTemplate> findByC_G_T_S_N_D(
201                            long companyId, long[] groupIds, String templateId,
202                            String structureId, String structureIdComparator, String name,
203                            String description, boolean andOperator, int start, int end,
204                            OrderByComparator obc)
205                    throws SystemException {
206    
207                    String[] templateIds = CustomSQLUtil.keywords(templateId, false);
208                    String[] names = CustomSQLUtil.keywords(name);
209                    String[] descriptions = CustomSQLUtil.keywords(description);
210    
211                    return doFindByC_G_T_S_N_D(
212                            companyId, groupIds, templateIds, structureId,
213                            structureIdComparator, names, descriptions, andOperator, start, end,
214                            obc, false);
215            }
216    
217            protected int doCountByC_G_T_S_N_D(
218                            long companyId, long[] groupIds, String[] templateIds,
219                            String structureId, String structureIdComparator, String[] names,
220                            String[] descriptions, boolean andOperator, boolean inlineSQLHelper)
221                    throws SystemException {
222    
223                    templateIds = CustomSQLUtil.keywords(templateIds, false);
224                    names = CustomSQLUtil.keywords(names);
225                    descriptions = CustomSQLUtil.keywords(descriptions);
226    
227                    Session session = null;
228    
229                    try {
230                            session = openSession();
231    
232                            String sql = CustomSQLUtil.get(COUNT_BY_C_G_T_S_N_D);
233    
234                            sql = StringUtil.replace(
235                                    sql, "[$GROUP_ID$]", getGroupIds(groupIds));
236                            sql = CustomSQLUtil.replaceKeywords(
237                                    sql, "templateId", StringPool.LIKE, false, templateIds);
238    
239                            if (structureIdComparator.equals(StringPool.NOT_LIKE)) {
240                                    sql = replaceStructureIdComparator(sql);
241                            }
242    
243                            sql = CustomSQLUtil.replaceKeywords(
244                                    sql, "lower(name)", StringPool.LIKE, false, names);
245                            sql = CustomSQLUtil.replaceKeywords(
246                                    sql, "lower(description)", StringPool.LIKE, true, descriptions);
247    
248                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
249    
250                            if (inlineSQLHelper) {
251                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
252                                            sql, JournalTemplate.class.getName(), "JournalTemplate.id_",
253                                            groupIds);
254    
255                                    sql = StringUtil.replace(
256                                            sql, "(companyId", "(JournalTemplate.companyId");
257    
258                                    sql = StringUtil.replace(sql, "(name", "(JournalTemplate.name");
259                            }
260    
261                            SQLQuery q = session.createSQLQuery(sql);
262    
263                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
264    
265                            QueryPos qPos = QueryPos.getInstance(q);
266    
267                            qPos.add(companyId);
268                            qPos.add(groupIds);
269                            qPos.add(templateIds, 2);
270    
271                            if (structureIdComparator.equals(StringPool.LIKE)) {
272                                    qPos.add(structureId);
273                                    qPos.add(structureId);
274                            }
275    
276                            qPos.add(names, 2);
277                            qPos.add(descriptions, 2);
278    
279                            if (structureIdComparator.equals(StringPool.NOT_LIKE)) {
280                                    if (CustomSQLUtil.isVendorOracle()) {
281                                    }
282                                    else {
283                                            qPos.add(structureId);
284                                    }
285                            }
286    
287                            Iterator<Long> itr = q.iterate();
288    
289                            if (itr.hasNext()) {
290                                    Long count = itr.next();
291    
292                                    if (count != null) {
293                                            return count.intValue();
294                                    }
295                            }
296    
297                            return 0;
298                    }
299                    catch (Exception e) {
300                            throw new SystemException(e);
301                    }
302                    finally {
303                            closeSession(session);
304                    }
305            }
306    
307            protected List<JournalTemplate> doFindByC_G_T_S_N_D(
308                            long companyId, long[] groupIds, String[] templateIds,
309                            String structureId, String structureIdComparator, String[] names,
310                            String[] descriptions, boolean andOperator, int start, int end,
311                            OrderByComparator obc, boolean inlineSQLHelper)
312                    throws SystemException {
313    
314                    templateIds = CustomSQLUtil.keywords(templateIds, false);
315                    names = CustomSQLUtil.keywords(names);
316                    descriptions = CustomSQLUtil.keywords(descriptions);
317    
318                    Session session = null;
319    
320                    try {
321                            session = openSession();
322    
323                            String sql = CustomSQLUtil.get(FIND_BY_C_G_T_S_N_D);
324    
325                            sql = StringUtil.replace(
326                                    sql, "[$GROUP_ID$]", getGroupIds(groupIds));
327                            sql = CustomSQLUtil.replaceKeywords(
328                                    sql, "templateId", StringPool.LIKE, false, templateIds);
329    
330                            if (structureIdComparator.equals(StringPool.NOT_LIKE)) {
331                                    sql = replaceStructureIdComparator(sql);
332                            }
333    
334                            sql = CustomSQLUtil.replaceKeywords(
335                                    sql, "lower(name)", StringPool.LIKE, false, names);
336                            sql = CustomSQLUtil.replaceKeywords(
337                                    sql, "lower(description)", StringPool.LIKE, true, descriptions);
338    
339                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
340                            sql = CustomSQLUtil.replaceOrderBy(sql, obc);
341    
342                            if (inlineSQLHelper) {
343                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
344                                                    sql, JournalTemplate.class.getName(),
345                                                    "JournalTemplate.id_", groupIds);
346    
347                                    sql = StringUtil.replace(
348                                            sql, "(companyId", "(JournalTemplate.companyId");
349    
350                                    sql = StringUtil.replace(sql, "(name", "(JournalTemplate.name");
351                            }
352    
353                            SQLQuery q = session.createSQLQuery(sql);
354    
355                            q.addEntity("JournalTemplate", JournalTemplateImpl.class);
356    
357                            QueryPos qPos = QueryPos.getInstance(q);
358    
359                            qPos.add(companyId);
360                            qPos.add(groupIds);
361                            qPos.add(templateIds, 2);
362    
363                            if (structureIdComparator.equals(StringPool.LIKE)) {
364                                    qPos.add(structureId);
365                                    qPos.add(structureId);
366                            }
367    
368                            qPos.add(names, 2);
369                            qPos.add(descriptions, 2);
370    
371                            if (structureIdComparator.equals(StringPool.NOT_LIKE)) {
372                                    if (CustomSQLUtil.isVendorOracle()) {
373                                    }
374                                    else {
375                                            qPos.add(structureId);
376                                    }
377                            }
378    
379                            return (List<JournalTemplate>)QueryUtil.list(
380                                    q, getDialect(), start, end);
381                    }
382                    catch (Exception e) {
383                            throw new SystemException(e);
384                    }
385                    finally {
386                            closeSession(session);
387                    }
388            }
389    
390            protected String getGroupIds(long[] groupIds) {
391                    if (groupIds.length == 0) {
392                            return StringPool.BLANK;
393                    }
394    
395                    StringBundler sb = new StringBundler(groupIds.length + 2);
396    
397                    sb.append(" (groupId = ? ");
398    
399                    for (int i = 1; i < groupIds.length; i++) {
400                            sb.append(" OR groupId = ? ");
401                    }
402    
403                    sb.append(") AND ");
404    
405                    return sb.toString();
406            }
407    
408            protected String replaceStructureIdComparator(String sql) {
409                    String insertSQL = "structureId NOT LIKE ? AND structureId IS NOT NULL";
410    
411                    if (CustomSQLUtil.isVendorOracle()) {
412                            insertSQL = "structureId IS NOT NULL";
413                    }
414    
415                    insertSQL = " AND (" + insertSQL + ") ";
416    
417                    String removeSQL =
418                            "(structureId LIKE ? [$AND_OR_NULL_CHECK$]) [$AND_OR_CONNECTOR$]";
419    
420                    sql = StringUtil.replace(sql, removeSQL, StringPool.BLANK);
421    
422                    int pos = sql.indexOf("ORDER BY");
423    
424                    if (pos == -1) {
425                            sql = sql + insertSQL;
426                    }
427                    else {
428                            sql = StringUtil.insert(sql, insertSQL, pos);
429                    }
430    
431                    return sql;
432            }
433    
434    }