001    /**
002     * Copyright (c) 2000-2011 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.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 String COUNT_BY_C_G_T_S_N_D =
048                    JournalTemplateFinder.class.getName() + ".countByC_G_T_S_N_D";
049    
050            public static 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(
259                                            sql, "(name", "(JournalTemplate.name");
260                            }
261    
262                            SQLQuery q = session.createSQLQuery(sql);
263    
264                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
265    
266                            QueryPos qPos = QueryPos.getInstance(q);
267    
268                            qPos.add(companyId);
269                            qPos.add(groupIds);
270                            qPos.add(templateIds, 2);
271    
272                            if (structureIdComparator.equals(StringPool.LIKE)) {
273                                    qPos.add(structureId);
274                                    qPos.add(structureId);
275                            }
276    
277                            qPos.add(names, 2);
278                            qPos.add(descriptions, 2);
279    
280                            if (structureIdComparator.equals(StringPool.NOT_LIKE)) {
281                                    if (CustomSQLUtil.isVendorOracle()) {
282                                    }
283                                    else {
284                                            qPos.add(structureId);
285                                    }
286                            }
287    
288                            Iterator<Long> itr = q.iterate();
289    
290                            if (itr.hasNext()) {
291                                    Long count = itr.next();
292    
293                                    if (count != null) {
294                                            return count.intValue();
295                                    }
296                            }
297    
298                            return 0;
299                    }
300                    catch (Exception e) {
301                            throw new SystemException(e);
302                    }
303                    finally {
304                            closeSession(session);
305                    }
306            }
307    
308            protected List<JournalTemplate> doFindByC_G_T_S_N_D(
309                            long companyId, long[] groupIds, String[] templateIds,
310                            String structureId, String structureIdComparator, String[] names,
311                            String[] descriptions, boolean andOperator, int start, int end,
312                            OrderByComparator obc, boolean inlineSQLHelper)
313                    throws SystemException {
314    
315                    templateIds = CustomSQLUtil.keywords(templateIds, false);
316                    names = CustomSQLUtil.keywords(names);
317                    descriptions = CustomSQLUtil.keywords(descriptions);
318    
319                    Session session = null;
320    
321                    try {
322                            session = openSession();
323    
324                            String sql = CustomSQLUtil.get(FIND_BY_C_G_T_S_N_D);
325    
326                            sql = StringUtil.replace(
327                                    sql, "[$GROUP_ID$]", getGroupIds(groupIds));
328                            sql = CustomSQLUtil.replaceKeywords(
329                                    sql, "templateId", StringPool.LIKE, false, templateIds);
330    
331                            if (structureIdComparator.equals(StringPool.NOT_LIKE)) {
332                                    sql = replaceStructureIdComparator(sql);
333                            }
334    
335                            sql = CustomSQLUtil.replaceKeywords(
336                                    sql, "lower(name)", StringPool.LIKE, false, names);
337                            sql = CustomSQLUtil.replaceKeywords(
338                                    sql, "lower(description)", StringPool.LIKE, true, descriptions);
339    
340                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
341                            sql = CustomSQLUtil.replaceOrderBy(sql, obc);
342    
343                            if (inlineSQLHelper) {
344                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
345                                                    sql, JournalTemplate.class.getName(),
346                                                    "JournalTemplate.id_", groupIds);
347    
348                                    sql = StringUtil.replace(
349                                            sql, "(companyId", "(JournalTemplate.companyId");
350    
351                                    sql = StringUtil.replace(
352                                            sql, "(name", "(JournalTemplate.name");
353                            }
354    
355                            SQLQuery q = session.createSQLQuery(sql);
356    
357                            q.addEntity("JournalTemplate", JournalTemplateImpl.class);
358    
359                            QueryPos qPos = QueryPos.getInstance(q);
360    
361                            qPos.add(companyId);
362                            qPos.add(groupIds);
363                            qPos.add(templateIds, 2);
364    
365                            if (structureIdComparator.equals(StringPool.LIKE)) {
366                                    qPos.add(structureId);
367                                    qPos.add(structureId);
368                            }
369    
370                            qPos.add(names, 2);
371                            qPos.add(descriptions, 2);
372    
373                            if (structureIdComparator.equals(StringPool.NOT_LIKE)) {
374                                    if (CustomSQLUtil.isVendorOracle()) {
375                                    }
376                                    else {
377                                            qPos.add(structureId);
378                                    }
379                            }
380    
381                            return (List<JournalTemplate>)QueryUtil.list(
382                                    q, getDialect(), start, end);
383                    }
384                    catch (Exception e) {
385                            throw new SystemException(e);
386                    }
387                    finally {
388                            closeSession(session);
389                    }
390            }
391    
392            protected String getGroupIds(long[] groupIds) {
393                    if (groupIds.length == 0) {
394                            return StringPool.BLANK;
395                    }
396    
397                    StringBundler sb = new StringBundler(groupIds.length + 2);
398    
399                    sb.append(" (groupId = ? ");
400    
401                    for (int i = 1; i < groupIds.length; i++) {
402                            sb.append(" OR groupId = ? ");
403                    }
404    
405                    sb.append(") AND ");
406    
407                    return sb.toString();
408            }
409    
410            protected String replaceStructureIdComparator(String sql) {
411                    String insertSQL = "structureId NOT LIKE ? AND structureId IS NOT NULL";
412    
413                    if (CustomSQLUtil.isVendorOracle()) {
414                            insertSQL = "structureId IS NOT NULL";
415                    }
416    
417                    insertSQL = " AND (" + insertSQL + ") ";
418    
419                    String removeSQL =
420                            "(structureId LIKE ? [$AND_OR_NULL_CHECK$]) [$AND_OR_CONNECTOR$]";
421    
422                    sql = StringUtil.replace(sql, removeSQL, StringPool.BLANK);
423    
424                    int pos = sql.indexOf("ORDER BY");
425    
426                    if (pos == -1) {
427                            sql = sql + insertSQL;
428                    }
429                    else {
430                            sql = StringUtil.insert(sql, insertSQL, pos);
431                    }
432    
433                    return sql;
434            }
435    
436    }