001    /**
002     * Copyright (c) 2000-present 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.exportimport.service.persistence.impl;
016    
017    import com.liferay.portal.kernel.dao.orm.QueryDefinition;
018    import com.liferay.portal.kernel.dao.orm.QueryPos;
019    import com.liferay.portal.kernel.dao.orm.QueryUtil;
020    import com.liferay.portal.kernel.dao.orm.SQLQuery;
021    import com.liferay.portal.kernel.dao.orm.Session;
022    import com.liferay.portal.kernel.dao.orm.Type;
023    import com.liferay.portal.kernel.exception.SystemException;
024    import com.liferay.portal.kernel.security.permission.InlineSQLHelperUtil;
025    import com.liferay.portal.kernel.util.OrderByComparator;
026    import com.liferay.portal.kernel.util.StringPool;
027    import com.liferay.portal.kernel.util.Validator;
028    import com.liferay.portal.kernel.workflow.WorkflowConstants;
029    import com.liferay.portlet.exportimport.model.ExportImportConfiguration;
030    import com.liferay.portlet.exportimport.model.impl.ExportImportConfigurationImpl;
031    import com.liferay.portlet.exportimport.service.persistence.ExportImportConfigurationFinder;
032    import com.liferay.util.dao.orm.CustomSQLUtil;
033    
034    import java.util.Iterator;
035    import java.util.List;
036    
037    /**
038     * @author Daniel Kocsis
039     */
040    public class ExportImportConfigurationFinderImpl
041            extends ExportImportConfigurationFinderBaseImpl
042            implements ExportImportConfigurationFinder {
043    
044            public static final String COUNT_BY_C_G_N_D_T =
045                    ExportImportConfigurationFinder.class.getName() + ".countByC_G_N_D_T";
046    
047            public static final String FIND_BY_C_G_N_D_T =
048                    ExportImportConfigurationFinder.class.getName() + ".findByC_G_N_D_T";
049    
050            @Override
051            public int countByKeywords(
052                    long companyId, long groupId, String keywords, int type, int status) {
053    
054                    String[] names = null;
055                    String[] descriptions = null;
056                    boolean andOperator = false;
057    
058                    if (Validator.isNotNull(keywords)) {
059                            names = CustomSQLUtil.keywords(keywords);
060                            descriptions = CustomSQLUtil.keywords(keywords, false);
061                    }
062                    else {
063                            andOperator = true;
064                    }
065    
066                    QueryDefinition<ExportImportConfiguration> queryDefinition =
067                            new QueryDefinition<>(status);
068    
069                    return doCountByC_G_N_D_T(
070                            companyId, groupId, names, descriptions, type, andOperator,
071                            queryDefinition, false);
072            }
073    
074            @Override
075            public int countByC_G_N_D_T(
076                    long companyId, long groupId, String name, String description, int type,
077                    int status, boolean andOperator) {
078    
079                    String[] names = CustomSQLUtil.keywords(name);
080                    String[] descriptions = CustomSQLUtil.keywords(description, false);
081    
082                    QueryDefinition<ExportImportConfiguration> queryDefinition =
083                            new QueryDefinition<>(status);
084    
085                    return doCountByC_G_N_D_T(
086                            companyId, groupId, names, descriptions, type, andOperator,
087                            queryDefinition, false);
088            }
089    
090            @Override
091            public int filterCountByKeywords(
092                    long companyId, long groupId, String keywords, int type, int status) {
093    
094                    String[] names = null;
095                    String[] descriptions = null;
096                    boolean andOperator = false;
097    
098                    if (Validator.isNotNull(keywords)) {
099                            names = CustomSQLUtil.keywords(keywords);
100                            descriptions = CustomSQLUtil.keywords(keywords, false);
101                    }
102                    else {
103                            andOperator = true;
104                    }
105    
106                    return filterCountByC_G_N_D_T(
107                            companyId, groupId, names, descriptions, type, status, andOperator);
108            }
109    
110            @Override
111            public int filterCountByC_G_N_D_T(
112                    long companyId, long groupId, String name, String description, int type,
113                    int status, boolean andOperator) {
114    
115                    String[] names = CustomSQLUtil.keywords(name);
116                    String[] descriptions = CustomSQLUtil.keywords(description, false);
117    
118                    return filterCountByC_G_N_D_T(
119                            companyId, groupId, names, descriptions, type, status, andOperator);
120            }
121    
122            @Override
123            public int filterCountByC_G_N_D_T(
124                    long companyId, long groupId, String[] names, String[] descriptions,
125                    int type, int status, boolean andOperator) {
126    
127                    QueryDefinition<ExportImportConfiguration> queryDefinition =
128                            new QueryDefinition<>(status);
129    
130                    return doCountByC_G_N_D_T(
131                            companyId, groupId, names, descriptions, type, andOperator,
132                            queryDefinition, true);
133            }
134    
135            @Override
136            public List<ExportImportConfiguration> filterFindByKeywords(
137                    long companyId, long groupId, String keywords, int type, int status,
138                    int start, int end,
139                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
140    
141                    String[] names = null;
142                    String[] descriptions = null;
143                    boolean andOperator = false;
144    
145                    if (Validator.isNotNull(keywords)) {
146                            names = CustomSQLUtil.keywords(keywords);
147                            descriptions = CustomSQLUtil.keywords(keywords, false);
148                    }
149                    else {
150                            andOperator = true;
151                    }
152    
153                    return filterFindByC_G_N_D_T(
154                            companyId, groupId, names, descriptions, type, status, andOperator,
155                            start, end, orderByComparator);
156            }
157    
158            @Override
159            public List<ExportImportConfiguration> filterFindByC_G_N_D_T(
160                    long companyId, long groupId, String name, String description, int type,
161                    int status, boolean andOperator, int start, int end,
162                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
163    
164                    String[] names = CustomSQLUtil.keywords(name);
165                    String[] descriptions = CustomSQLUtil.keywords(description, false);
166    
167                    return filterFindByC_G_N_D_T(
168                            companyId, groupId, names, descriptions, type, status, andOperator,
169                            start, end, orderByComparator);
170            }
171    
172            @Override
173            public List<ExportImportConfiguration> filterFindByC_G_N_D_T(
174                    long companyId, long groupId, String[] names, String[] descriptions,
175                    int type, int status, boolean andOperator, int start, int end,
176                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
177    
178                    QueryDefinition<ExportImportConfiguration> queryDefinition =
179                            new QueryDefinition<>(status, false, start, end, orderByComparator);
180    
181                    return doFindByC_G_N_D_T(
182                            companyId, groupId, names, descriptions, type, andOperator,
183                            queryDefinition, true);
184            }
185    
186            @Override
187            public List<ExportImportConfiguration> findByKeywords(
188                    long companyId, long groupId, String keywords, int type, int status,
189                    int start, int end,
190                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
191    
192                    String[] names = null;
193                    String[] descriptions = null;
194                    boolean andOperator = false;
195    
196                    if (Validator.isNotNull(keywords)) {
197                            names = CustomSQLUtil.keywords(keywords);
198                            descriptions = CustomSQLUtil.keywords(keywords, false);
199                    }
200                    else {
201                            andOperator = true;
202                    }
203    
204                    return findByC_G_N_D_T(
205                            companyId, groupId, names, descriptions, type, status, andOperator,
206                            start, end, orderByComparator);
207            }
208    
209            @Override
210            public List<ExportImportConfiguration> findByC_G_N_D_T(
211                    long companyId, long groupId, String name, String description, int type,
212                    int status, boolean andOperator, int start, int end,
213                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
214    
215                    String[] names = CustomSQLUtil.keywords(name);
216                    String[] descriptions = CustomSQLUtil.keywords(description, false);
217    
218                    return findByC_G_N_D_T(
219                            companyId, groupId, names, descriptions, type, status, andOperator,
220                            start, end, orderByComparator);
221            }
222    
223            @Override
224            public List<ExportImportConfiguration> findByC_G_N_D_T(
225                    long companyId, long groupId, String[] names, String[] descriptions,
226                    int type, int status, boolean andOperator, int start, int end,
227                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
228    
229                    QueryDefinition<ExportImportConfiguration> queryDefinition =
230                            new QueryDefinition<>(status, false, start, end, orderByComparator);
231    
232                    return doFindByC_G_N_D_T(
233                            companyId, groupId, names, descriptions, type, andOperator,
234                            queryDefinition, false);
235            }
236    
237            protected int doCountByC_G_N_D_T(
238                    long companyId, long groupId, String[] names, String[] descriptions,
239                    int type, boolean andOperator,
240                    QueryDefinition<ExportImportConfiguration> queryDefinition,
241                    boolean inlineSQLHelper) {
242    
243                    names = CustomSQLUtil.keywords(names);
244                    descriptions = CustomSQLUtil.keywords(descriptions, false);
245    
246                    Session session = null;
247    
248                    try {
249                            session = openSession();
250    
251                            String sql = CustomSQLUtil.get(COUNT_BY_C_G_N_D_T);
252    
253                            sql = updateSQL(sql, queryDefinition);
254    
255                            if (inlineSQLHelper) {
256                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
257                                            sql, ExportImportConfiguration.class.getName(),
258                                            "ExportImportConfiguration.exportImportConfigurationId",
259                                            groupId);
260                            }
261    
262                            sql = CustomSQLUtil.replaceKeywords(
263                                    sql, "lower(name)", StringPool.LIKE, false, names);
264                            sql = CustomSQLUtil.replaceKeywords(
265                                    sql, "description", StringPool.LIKE, true, descriptions);
266    
267                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
268    
269                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
270    
271                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
272    
273                            QueryPos qPos = QueryPos.getInstance(q);
274    
275                            qPos.add(companyId);
276                            qPos.add(groupId);
277                            qPos.add(names, 2);
278                            qPos.add(descriptions, 2);
279                            qPos.add(type);
280    
281                            if (queryDefinition.getStatus() != WorkflowConstants.STATUS_ANY) {
282                                    qPos.add(queryDefinition.getStatus());
283                            }
284    
285                            Iterator<Long> itr = q.iterate();
286    
287                            if (itr.hasNext()) {
288                                    Long count = itr.next();
289    
290                                    if (count != null) {
291                                            return count.intValue();
292                                    }
293                            }
294    
295                            return 0;
296                    }
297                    catch (Exception e) {
298                            throw new SystemException(e);
299                    }
300                    finally {
301                            closeSession(session);
302                    }
303            }
304    
305            protected List<ExportImportConfiguration> doFindByC_G_N_D_T(
306                    long companyId, long groupId, String[] names, String[] descriptions,
307                    int type, boolean andOperator,
308                    QueryDefinition<ExportImportConfiguration> queryDefinition,
309                    boolean inlineSQLHelper) {
310    
311                    names = CustomSQLUtil.keywords(names);
312                    descriptions = CustomSQLUtil.keywords(descriptions, false);
313    
314                    Session session = null;
315    
316                    try {
317                            session = openSession();
318    
319                            String sql = CustomSQLUtil.get(FIND_BY_C_G_N_D_T);
320    
321                            sql = updateSQL(sql, queryDefinition);
322    
323                            sql = CustomSQLUtil.replaceOrderBy(
324                                    sql, queryDefinition.getOrderByComparator());
325    
326                            if (inlineSQLHelper) {
327                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
328                                            sql, ExportImportConfiguration.class.getName(),
329                                            "ExportImportConfiguration.exportImportConfigurationId",
330                                            groupId);
331                            }
332    
333                            sql = CustomSQLUtil.replaceKeywords(
334                                    sql, "lower(name)", StringPool.LIKE, false, names);
335                            sql = CustomSQLUtil.replaceKeywords(
336                                    sql, "description", StringPool.LIKE, true, descriptions);
337    
338                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
339    
340                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
341    
342                            q.addEntity(
343                                    "ExportImportConfiguration",
344                                    ExportImportConfigurationImpl.class);
345    
346                            QueryPos qPos = QueryPos.getInstance(q);
347    
348                            qPos.add(companyId);
349                            qPos.add(groupId);
350                            qPos.add(names, 2);
351                            qPos.add(descriptions, 2);
352                            qPos.add(type);
353    
354                            if (queryDefinition.getStatus() != WorkflowConstants.STATUS_ANY) {
355                                    qPos.add(queryDefinition.getStatus());
356                            }
357    
358                            return (List<ExportImportConfiguration>)QueryUtil.list(
359                                    q, getDialect(), queryDefinition.getStart(),
360                                    queryDefinition.getEnd());
361                    }
362                    catch (Exception e) {
363                            throw new SystemException(e);
364                    }
365                    finally {
366                            closeSession(session);
367                    }
368            }
369    
370            protected String updateSQL(
371                    String sql,
372                    QueryDefinition<ExportImportConfiguration> queryDefinition) {
373    
374                    if (queryDefinition.getStatus() == WorkflowConstants.STATUS_ANY) {
375                            return sql;
376                    }
377    
378                    if (queryDefinition.isExcludeStatus()) {
379                            return CustomSQLUtil.appendCriteria(sql, "AND (status != ?)");
380                    }
381    
382                    return CustomSQLUtil.appendCriteria(sql, "AND (status = ?)");
383            }
384    
385    }