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