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.dynamicdatamapping.service.persistence.impl;
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.ArrayUtil;
024    import com.liferay.portal.kernel.util.OrderByComparator;
025    import com.liferay.portal.kernel.util.StringBundler;
026    import com.liferay.portal.kernel.util.StringPool;
027    import com.liferay.portal.kernel.util.StringUtil;
028    import com.liferay.portal.kernel.util.Validator;
029    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
030    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
031    import com.liferay.portal.util.PortalUtil;
032    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
033    import com.liferay.portlet.dynamicdatamapping.model.DDMTemplate;
034    import com.liferay.portlet.dynamicdatamapping.model.impl.DDMTemplateImpl;
035    import com.liferay.portlet.dynamicdatamapping.service.persistence.DDMTemplateFinder;
036    import com.liferay.util.dao.orm.CustomSQLUtil;
037    
038    import java.util.Iterator;
039    import java.util.List;
040    
041    /**
042     * @author Eduardo Lundgren
043     * @author Connor McKay
044     * @author Marcellus Tavares
045     * @author Juan Fern??ndez
046     */
047    public class DDMTemplateFinderImpl
048            extends BasePersistenceImpl<DDMTemplate> implements DDMTemplateFinder {
049    
050            public static final String COUNT_BY_G_C_SC =
051                    DDMTemplateFinder.class.getName() + ".countByG_C_SC";
052    
053            public static final String COUNT_BY_C_G_C_C_R_N_D_T_M_L =
054                    DDMTemplateFinder.class.getName() + ".countByC_G_C_C_R_N_D_T_M_L";
055    
056            public static final String FIND_BY_G_C_SC =
057                    DDMTemplateFinder.class.getName() + ".findByG_C_SC";
058    
059            public static final String FIND_BY_C_G_C_C_R_N_D_T_M_L =
060                    DDMTemplateFinder.class.getName() + ".findByC_G_C_C_R_N_D_T_M_L";
061    
062            @Override
063            public int countByKeywords(
064                    long companyId, long groupId, long classNameId, long classPK,
065                    long resourceClassNameId, String keywords, String type, String mode) {
066    
067                    String[] names = null;
068                    String[] descriptions = null;
069                    String[] types = CustomSQLUtil.keywords(type, false);
070                    String[] modes = CustomSQLUtil.keywords(mode, false);
071                    String[] languages = null;
072                    boolean andOperator = false;
073    
074                    if (Validator.isNotNull(keywords)) {
075                            names = CustomSQLUtil.keywords(keywords);
076                            descriptions = CustomSQLUtil.keywords(keywords, false);
077                            languages = CustomSQLUtil.keywords(keywords, false);
078                    }
079                    else {
080                            andOperator = true;
081                    }
082    
083                    return countByC_G_C_C_R_N_D_T_M_L(
084                            companyId, groupId, classNameId, classPK, resourceClassNameId,
085                            names, descriptions, types, modes, languages, andOperator);
086            }
087    
088            @Override
089            public int countByKeywords(
090                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
091                    long resourceClassNameId, String keywords, String type, String mode) {
092    
093                    String[] names = null;
094                    String[] descriptions = null;
095                    String[] types = CustomSQLUtil.keywords(type, false);
096                    String[] modes = CustomSQLUtil.keywords(mode, false);
097                    String[] languages = null;
098                    boolean andOperator = false;
099    
100                    if (Validator.isNotNull(keywords)) {
101                            names = CustomSQLUtil.keywords(keywords);
102                            descriptions = CustomSQLUtil.keywords(keywords, false);
103                            languages = CustomSQLUtil.keywords(keywords, false);
104                    }
105                    else {
106                            andOperator = true;
107                    }
108    
109                    return countByC_G_C_C_R_N_D_T_M_L(
110                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
111                            names, descriptions, types, modes, languages, andOperator);
112            }
113    
114            @Override
115            public int countByG_SC(long groupId, long structureClassNameId) {
116                    long[] groupIds = new long[] {groupId};
117                    long classNameId = PortalUtil.getClassNameId(DDMStructure.class);
118    
119                    return doCountByG_C_SC(
120                            groupIds, classNameId, structureClassNameId, false);
121            }
122    
123            @Override
124            public int countByC_G_C_C_R_N_D_T_M_L(
125                    long companyId, long groupId, long classNameId, long classPK,
126                    long resourceClassNameId, String name, String description, String type,
127                    String mode, String language, boolean andOperator) {
128    
129                    String[] names = CustomSQLUtil.keywords(name);
130                    String[] descriptions = CustomSQLUtil.keywords(description, false);
131                    String[] types = CustomSQLUtil.keywords(type, false);
132                    String[] modes = CustomSQLUtil.keywords(mode, false);
133                    String[] languages = CustomSQLUtil.keywords(language, false);
134    
135                    return countByC_G_C_C_R_N_D_T_M_L(
136                            companyId, groupId, classNameId, classPK, resourceClassNameId,
137                            names, descriptions, types, modes, languages, andOperator);
138            }
139    
140            @Override
141            public int countByC_G_C_C_R_N_D_T_M_L(
142                    long companyId, long groupId, long classNameId, long classPK,
143                    long resourceClassNameId, String[] names, String[] descriptions,
144                    String[] types, String[] modes, String[] languages,
145                    boolean andOperator) {
146    
147                    long[] groupIds = new long[] {groupId};
148                    long[] classNameIds = new long[] {classNameId};
149                    long[] classPKs = new long[] {classPK};
150    
151                    return doCountByC_G_C_C_R_N_D_T_M_L(
152                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
153                            names, descriptions, types, modes, languages, andOperator, false);
154            }
155    
156            @Override
157            public int countByC_G_C_C_R_N_D_T_M_L(
158                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
159                    long resourceClassNameId, String name, String description, String type,
160                    String mode, String language, boolean andOperator) {
161    
162                    String[] names = CustomSQLUtil.keywords(name);
163                    String[] descriptions = CustomSQLUtil.keywords(description, false);
164                    String[] types = CustomSQLUtil.keywords(type, false);
165                    String[] modes = CustomSQLUtil.keywords(mode, false);
166                    String[] languages = CustomSQLUtil.keywords(language, false);
167    
168                    return countByC_G_C_C_R_N_D_T_M_L(
169                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
170                            names, descriptions, types, modes, languages, andOperator);
171            }
172    
173            @Override
174            public int countByC_G_C_C_R_N_D_T_M_L(
175                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
176                    long resourceClassNameId, String[] names, String[] descriptions,
177                    String[] types, String[] modes, String[] languages,
178                    boolean andOperator) {
179    
180                    return doCountByC_G_C_C_R_N_D_T_M_L(
181                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
182                            names, descriptions, types, modes, languages, andOperator, false);
183            }
184    
185            @Override
186            public int filterCountByKeywords(
187                    long companyId, long groupId, long classNameId, long classPK,
188                    long resourceClassNameId, String keywords, String type, String mode) {
189    
190                    String[] names = null;
191                    String[] descriptions = null;
192                    String[] types = CustomSQLUtil.keywords(type, false);
193                    String[] modes = CustomSQLUtil.keywords(mode, false);
194                    String[] languages = null;
195                    boolean andOperator = false;
196    
197                    if (Validator.isNotNull(keywords)) {
198                            names = CustomSQLUtil.keywords(keywords);
199                            descriptions = CustomSQLUtil.keywords(keywords, false);
200                            languages = CustomSQLUtil.keywords(keywords, false);
201                    }
202                    else {
203                            andOperator = true;
204                    }
205    
206                    return filterCountByC_G_C_C_R_N_D_T_M_L(
207                            companyId, groupId, classNameId, classPK, resourceClassNameId,
208                            names, descriptions, types, modes, languages, andOperator);
209            }
210    
211            @Override
212            public int filterCountByKeywords(
213                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
214                    long resourceClassNameId, String keywords, String type, String mode) {
215    
216                    String[] names = null;
217                    String[] descriptions = null;
218                    String[] types = CustomSQLUtil.keywords(type, false);
219                    String[] modes = CustomSQLUtil.keywords(mode, false);
220                    String[] languages = null;
221                    boolean andOperator = false;
222    
223                    if (Validator.isNotNull(keywords)) {
224                            names = CustomSQLUtil.keywords(keywords);
225                            descriptions = CustomSQLUtil.keywords(keywords, false);
226                            languages = CustomSQLUtil.keywords(keywords, false);
227                    }
228                    else {
229                            andOperator = true;
230                    }
231    
232                    return filterCountByC_G_C_C_R_N_D_T_M_L(
233                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
234                            names, descriptions, types, modes, languages, andOperator);
235            }
236    
237            @Override
238            public int filterCountByC_G_C_C_R_N_D_T_M_L(
239                    long companyId, long groupId, long classNameId, long classPK,
240                    long resourceClassNameId, String name, String description, String type,
241                    String mode, String language, boolean andOperator) {
242    
243                    String[] names = CustomSQLUtil.keywords(name);
244                    String[] descriptions = CustomSQLUtil.keywords(description, false);
245                    String[] types = CustomSQLUtil.keywords(type, false);
246                    String[] modes = CustomSQLUtil.keywords(mode, false);
247                    String[] languages = CustomSQLUtil.keywords(language, false);
248    
249                    return filterCountByC_G_C_C_R_N_D_T_M_L(
250                            companyId, groupId, classNameId, classPK, resourceClassNameId,
251                            names, descriptions, types, modes, languages, andOperator);
252            }
253    
254            @Override
255            public int filterCountByC_G_C_C_R_N_D_T_M_L(
256                    long companyId, long groupId, long classNameId, long classPK,
257                    long resourceClassNameId, String[] names, String[] descriptions,
258                    String[] types, String[] modes, String[] languages,
259                    boolean andOperator) {
260    
261                    long[] groupIds = new long[] {groupId};
262                    long[] classNameIds = new long[] {classNameId};
263                    long[] classPKs = new long[] {classPK};
264    
265                    return filterCountByC_G_C_C_R_N_D_T_M_L(
266                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
267                            names, descriptions, types, modes, languages, andOperator);
268            }
269    
270            @Override
271            public int filterCountByC_G_C_C_R_N_D_T_M_L(
272                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
273                    long resourceClassNameId, String name, String description, String type,
274                    String mode, String language, boolean andOperator) {
275    
276                    String[] names = CustomSQLUtil.keywords(name);
277                    String[] descriptions = CustomSQLUtil.keywords(description, false);
278                    String[] types = CustomSQLUtil.keywords(type, false);
279                    String[] modes = CustomSQLUtil.keywords(mode, false);
280                    String[] languages = CustomSQLUtil.keywords(language, false);
281    
282                    return filterCountByC_G_C_C_R_N_D_T_M_L(
283                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
284                            names, descriptions, types, modes, languages, andOperator);
285            }
286    
287            @Override
288            public int filterCountByC_G_C_C_R_N_D_T_M_L(
289                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
290                    long resourceClassNameId, String[] names, String[] descriptions,
291                    String[] types, String[] modes, String[] languages,
292                    boolean andOperator) {
293    
294                    return doCountByC_G_C_C_R_N_D_T_M_L(
295                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
296                            names, descriptions, types, modes, languages, andOperator, true);
297            }
298    
299            @Override
300            public int filterCountByG_SC(long groupId, long structureClassNameId) {
301                    long[] groupIds = new long[] {groupId};
302                    long classNameId = PortalUtil.getClassNameId(DDMStructure.class);
303    
304                    return doCountByG_C_SC(
305                            groupIds, classNameId, structureClassNameId, true);
306            }
307    
308            @Override
309            public int filterCountByG_SC(long[] groupIds, long structureClassNameId) {
310                    long classNameId = PortalUtil.getClassNameId(DDMStructure.class);
311    
312                    return doCountByG_C_SC(
313                            groupIds, classNameId, structureClassNameId, true);
314            }
315    
316            @Override
317            public List<DDMTemplate> filterFindByKeywords(
318                    long companyId, long groupId, long classNameId, long classPK,
319                    long resourceClassNameId, String keywords, String type, String mode,
320                    int start, int end, OrderByComparator<DDMTemplate> orderByComparator) {
321    
322                    String[] names = null;
323                    String[] descriptions = null;
324                    String[] types = CustomSQLUtil.keywords(type, false);
325                    String[] modes = CustomSQLUtil.keywords(mode, false);
326                    String[] languages = null;
327                    boolean andOperator = false;
328    
329                    if (Validator.isNotNull(keywords)) {
330                            names = CustomSQLUtil.keywords(keywords);
331                            descriptions = CustomSQLUtil.keywords(keywords, false);
332                            languages = CustomSQLUtil.keywords(keywords, false);
333                    }
334                    else {
335                            andOperator = true;
336                    }
337    
338                    return filterFindByC_G_C_C_R_N_D_T_M_L(
339                            companyId, groupId, classNameId, classPK, resourceClassNameId,
340                            names, descriptions, types, modes, languages, andOperator, start,
341                            end, orderByComparator);
342            }
343    
344            @Override
345            public List<DDMTemplate> filterFindByKeywords(
346                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
347                    long resourceClassNameId, String keywords, String type, String mode,
348                    int start, int end, OrderByComparator<DDMTemplate> orderByComparator) {
349    
350                    String[] names = null;
351                    String[] descriptions = null;
352                    String[] types = CustomSQLUtil.keywords(type, false);
353                    String[] modes = CustomSQLUtil.keywords(mode, false);
354                    String[] languages = null;
355                    boolean andOperator = false;
356    
357                    if (Validator.isNotNull(keywords)) {
358                            names = CustomSQLUtil.keywords(keywords);
359                            descriptions = CustomSQLUtil.keywords(keywords, false);
360                            languages = CustomSQLUtil.keywords(languages, false);
361                    }
362                    else {
363                            andOperator = true;
364                    }
365    
366                    return filterFindByC_G_C_C_R_N_D_T_M_L(
367                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
368                            names, descriptions, types, modes, languages, andOperator, start,
369                            end, orderByComparator);
370            }
371    
372            @Override
373            public List<DDMTemplate> filterFindByC_G_C_C_R_N_D_T_M_L(
374                    long companyId, long groupId, long classNameId, long classPK,
375                    long resourceClassNameId, String name, String description, String type,
376                    String mode, String language, boolean andOperator, int start, int end,
377                    OrderByComparator<DDMTemplate> orderByComparator) {
378    
379                    String[] names = CustomSQLUtil.keywords(name);
380                    String[] descriptions = CustomSQLUtil.keywords(description, false);
381                    String[] types = CustomSQLUtil.keywords(type, false);
382                    String[] modes = CustomSQLUtil.keywords(mode, false);
383                    String[] languages = CustomSQLUtil.keywords(language, false);
384    
385                    return filterFindByC_G_C_C_R_N_D_T_M_L(
386                            companyId, groupId, classNameId, classPK, resourceClassNameId,
387                            names, descriptions, types, modes, languages, andOperator, start,
388                            end, orderByComparator);
389            }
390    
391            @Override
392            public List<DDMTemplate> filterFindByC_G_C_C_R_N_D_T_M_L(
393                    long companyId, long groupId, long classNameId, long classPK,
394                    long resourceClassNameId, String[] names, String[] descriptions,
395                    String[] types, String[] modes, String[] languages, boolean andOperator,
396                    int start, int end, OrderByComparator<DDMTemplate> orderByComparator) {
397    
398                    long[] groupIds = new long[] {groupId};
399                    long[] classNameIds = new long[] {classNameId};
400                    long[] classPKs = new long[] {classPK};
401    
402                    return filterFindByC_G_C_C_R_N_D_T_M_L(
403                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
404                            names, descriptions, types, modes, languages, andOperator, start,
405                            end, orderByComparator);
406            }
407    
408            @Override
409            public List<DDMTemplate> filterFindByC_G_C_C_R_N_D_T_M_L(
410                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
411                    long resourceClassNameId, String name, String description, String type,
412                    String mode, String language, boolean andOperator, int start, int end,
413                    OrderByComparator<DDMTemplate> orderByComparator) {
414    
415                    String[] names = CustomSQLUtil.keywords(name);
416                    String[] descriptions = CustomSQLUtil.keywords(description, false);
417                    String[] types = CustomSQLUtil.keywords(type, false);
418                    String[] modes = CustomSQLUtil.keywords(mode, false);
419                    String[] languages = CustomSQLUtil.keywords(language, false);
420    
421                    return filterFindByC_G_C_C_R_N_D_T_M_L(
422                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
423                            names, descriptions, types, modes, languages, andOperator, start,
424                            end, orderByComparator);
425            }
426    
427            @Override
428            public List<DDMTemplate> filterFindByC_G_C_C_R_N_D_T_M_L(
429                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
430                    long resourceClassNameId, String[] names, String[] descriptions,
431                    String[] types, String[] modes, String[] languages, boolean andOperator,
432                    int start, int end, OrderByComparator<DDMTemplate> orderByComparator) {
433    
434                    return doFindByC_G_C_C_R_N_D_T_M_L(
435                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
436                            names, descriptions, types, modes, languages, andOperator, start,
437                            end, orderByComparator, true);
438            }
439    
440            @Override
441            public List<DDMTemplate> filterFindByG_SC(
442                    long groupId, long structureClassNameId, int start, int end,
443                    OrderByComparator<DDMTemplate> orderByComparator) {
444    
445                    long[] groupIds = new long[] {groupId};
446                    long classNameId = PortalUtil.getClassNameId(DDMStructure.class);
447    
448                    return doFindByG_C_SC(
449                            groupIds, classNameId, structureClassNameId, start, end,
450                            orderByComparator, true);
451            }
452    
453            @Override
454            public List<DDMTemplate> filterFindByG_SC(
455                    long[] groupIds, long structureClassNameId, int start, int end,
456                    OrderByComparator<DDMTemplate> orderByComparator) {
457    
458                    long classNameId = PortalUtil.getClassNameId(DDMStructure.class);
459    
460                    return doFindByG_C_SC(
461                            groupIds, classNameId, structureClassNameId, start, end,
462                            orderByComparator, true);
463            }
464    
465            @Override
466            public List<DDMTemplate> findByKeywords(
467                    long companyId, long groupId, long classNameId, long classPK,
468                    long resourceClassNameId, String keywords, String type, String mode,
469                    int start, int end, OrderByComparator<DDMTemplate> orderByComparator) {
470    
471                    String[] names = null;
472                    String[] descriptions = null;
473                    String[] types = CustomSQLUtil.keywords(type, false);
474                    String[] modes = CustomSQLUtil.keywords(mode, false);
475                    String[] languages = null;
476                    boolean andOperator = false;
477    
478                    if (Validator.isNotNull(keywords)) {
479                            names = CustomSQLUtil.keywords(keywords);
480                            descriptions = CustomSQLUtil.keywords(keywords, false);
481                            languages = CustomSQLUtil.keywords(keywords, false);
482                    }
483                    else {
484                            andOperator = true;
485                    }
486    
487                    return findByC_G_C_C_R_N_D_T_M_L(
488                            companyId, groupId, classNameId, classPK, resourceClassNameId,
489                            names, descriptions, types, modes, languages, andOperator, start,
490                            end, orderByComparator);
491            }
492    
493            @Override
494            public List<DDMTemplate> findByKeywords(
495                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
496                    long resourceClassNameId, String keywords, String type, String mode,
497                    int start, int end, OrderByComparator<DDMTemplate> orderByComparator) {
498    
499                    String[] names = null;
500                    String[] descriptions = null;
501                    String[] types = CustomSQLUtil.keywords(type, false);
502                    String[] modes = CustomSQLUtil.keywords(mode, false);
503                    String[] languages = null;
504                    boolean andOperator = false;
505    
506                    if (Validator.isNotNull(keywords)) {
507                            names = CustomSQLUtil.keywords(keywords);
508                            descriptions = CustomSQLUtil.keywords(keywords, false);
509                            languages = CustomSQLUtil.keywords(languages, false);
510                    }
511                    else {
512                            andOperator = true;
513                    }
514    
515                    return findByC_G_C_C_R_N_D_T_M_L(
516                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
517                            names, descriptions, types, modes, languages, andOperator, start,
518                            end, orderByComparator);
519            }
520    
521            @Override
522            public List<DDMTemplate> findByG_SC(
523                    long groupId, long structureClassNameId, int start, int end,
524                    OrderByComparator<DDMTemplate> orderByComparator) {
525    
526                    long[] groupIds = new long[] {groupId};
527                    long classNameId = PortalUtil.getClassNameId(DDMStructure.class);
528    
529                    return doFindByG_C_SC(
530                            groupIds, classNameId, structureClassNameId, start, end,
531                            orderByComparator, false);
532            }
533    
534            @Override
535            public List<DDMTemplate> findByG_SC(
536                    long[] groupIds, long structureClassNameId, int start, int end,
537                    OrderByComparator<DDMTemplate> orderByComparator) {
538    
539                    long classNameId = PortalUtil.getClassNameId(DDMStructure.class);
540    
541                    return doFindByG_C_SC(
542                            groupIds, classNameId, structureClassNameId, start, end,
543                            orderByComparator, false);
544            }
545    
546            @Override
547            public List<DDMTemplate> findByC_G_C_C_R_N_D_T_M_L(
548                    long companyId, long groupId, long classNameId, long classPK,
549                    long resourceClassNameId, String name, String description, String type,
550                    String mode, String language, boolean andOperator, int start, int end,
551                    OrderByComparator<DDMTemplate> orderByComparator) {
552    
553                    String[] names = CustomSQLUtil.keywords(name);
554                    String[] descriptions = CustomSQLUtil.keywords(description, false);
555                    String[] types = CustomSQLUtil.keywords(type, false);
556                    String[] modes = CustomSQLUtil.keywords(mode, false);
557                    String[] languages = CustomSQLUtil.keywords(language, false);
558    
559                    return findByC_G_C_C_R_N_D_T_M_L(
560                            companyId, groupId, classNameId, classPK, resourceClassNameId,
561                            names, descriptions, types, modes, languages, andOperator, start,
562                            end, orderByComparator);
563            }
564    
565            @Override
566            public List<DDMTemplate> findByC_G_C_C_R_N_D_T_M_L(
567                    long companyId, long groupId, long classNameId, long classPK,
568                    long resourceClassNameId, String[] names, String[] descriptions,
569                    String[] types, String[] modes, String[] languages, boolean andOperator,
570                    int start, int end, OrderByComparator<DDMTemplate> orderByComparator) {
571    
572                    long[] groupIds = new long[] {groupId};
573                    long[] classNameIds = new long[] {classNameId};
574                    long[] classPKs = new long[] {classPK};
575    
576                    return doFindByC_G_C_C_R_N_D_T_M_L(
577                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
578                            names, descriptions, types, modes, languages, andOperator, start,
579                            end, orderByComparator, false);
580            }
581    
582            @Override
583            public List<DDMTemplate> findByC_G_C_C_R_N_D_T_M_L(
584                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
585                    long resourceClassNameId, String name, String description, String type,
586                    String mode, String language, boolean andOperator, int start, int end,
587                    OrderByComparator<DDMTemplate> orderByComparator) {
588    
589                    String[] names = CustomSQLUtil.keywords(name);
590                    String[] descriptions = CustomSQLUtil.keywords(description, false);
591                    String[] types = CustomSQLUtil.keywords(type, false);
592                    String[] modes = CustomSQLUtil.keywords(mode, false);
593                    String[] languages = CustomSQLUtil.keywords(language, false);
594    
595                    return findByC_G_C_C_R_N_D_T_M_L(
596                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
597                            names, descriptions, types, modes, languages, andOperator, start,
598                            end, orderByComparator);
599            }
600    
601            @Override
602            public List<DDMTemplate> findByC_G_C_C_R_N_D_T_M_L(
603                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
604                    long resourceClassNameId, String[] names, String[] descriptions,
605                    String[] types, String[] modes, String[] languages, boolean andOperator,
606                    int start, int end, OrderByComparator<DDMTemplate> orderByComparator) {
607    
608                    return doFindByC_G_C_C_R_N_D_T_M_L(
609                            companyId, groupIds, classNameIds, classPKs, resourceClassNameId,
610                            names, descriptions, types, modes, languages, andOperator, start,
611                            end, orderByComparator, false);
612            }
613    
614            protected int doCountByG_C_SC(
615                    long[] groupIds, long classNameId, long structureClassNameId,
616                    boolean inlineSQLHelper) {
617    
618                    Session session = null;
619    
620                    try {
621                            session = openSession();
622    
623                            String sql = CustomSQLUtil.get(COUNT_BY_G_C_SC);
624    
625                            if (inlineSQLHelper) {
626                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
627                                            sql, DDMTemplate.class.getName(), "DDMTemplate.templateId",
628                                            groupIds);
629                            }
630    
631                            sql = StringUtil.replace(
632                                    sql, "[$GROUP_ID$]", getGroupIds(groupIds));
633    
634                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
635    
636                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
637    
638                            QueryPos qPos = QueryPos.getInstance(q);
639    
640                            if (groupIds != null) {
641                                    qPos.add(groupIds);
642                            }
643    
644                            qPos.add(classNameId);
645                            qPos.add(structureClassNameId);
646    
647                            Iterator<Long> itr = q.iterate();
648    
649                            if (itr.hasNext()) {
650                                    Long count = itr.next();
651    
652                                    if (count != null) {
653                                            return count.intValue();
654                                    }
655                            }
656    
657                            return 0;
658                    }
659                    catch (Exception e) {
660                            throw new SystemException(e);
661                    }
662                    finally {
663                            closeSession(session);
664                    }
665            }
666    
667            protected int doCountByC_G_C_C_R_N_D_T_M_L(
668                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
669                    long resourceClassNameId, String[] names, String[] descriptions,
670                    String[] types, String[] modes, String[] languages, boolean andOperator,
671                    boolean inlineSQLHelper) {
672    
673                    names = CustomSQLUtil.keywords(names);
674                    descriptions = CustomSQLUtil.keywords(descriptions, false);
675                    types = CustomSQLUtil.keywords(types, false);
676                    modes = CustomSQLUtil.keywords(modes, false);
677                    languages = CustomSQLUtil.keywords(languages, false);
678    
679                    Session session = null;
680    
681                    try {
682                            session = openSession();
683    
684                            String sql = CustomSQLUtil.get(COUNT_BY_C_G_C_C_R_N_D_T_M_L);
685    
686                            if (inlineSQLHelper) {
687                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
688                                            sql, DDMTemplate.class.getName(), "DDMTemplate.templateId",
689                                            groupIds);
690                            }
691    
692                            sql = StringUtil.replace(
693                                    sql, "[$GROUP_ID$]", getGroupIds(groupIds));
694                            sql = StringUtil.replace(
695                                    sql, "[$CLASSNAME_ID$]", getClassNameIds(classNameIds));
696                            sql = StringUtil.replace(
697                                    sql, "[$CLASS_PK$]", getClassPKs(classPKs));
698                            sql = CustomSQLUtil.replaceKeywords(
699                                    sql, "lower(name)", StringPool.LIKE, false, names);
700                            sql = CustomSQLUtil.replaceKeywords(
701                                    sql, "description", StringPool.LIKE, false, descriptions);
702                            sql = CustomSQLUtil.replaceKeywords(
703                                    sql, "type", StringPool.LIKE, false, types);
704                            sql = CustomSQLUtil.replaceKeywords(
705                                    sql, "mode", StringPool.LIKE, false, modes);
706                            sql = CustomSQLUtil.replaceKeywords(
707                                    sql, "language", StringPool.LIKE, true, languages);
708                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
709    
710                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
711    
712                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
713    
714                            QueryPos qPos = QueryPos.getInstance(q);
715    
716                            qPos.add(companyId);
717    
718                            if (groupIds != null) {
719                                    qPos.add(groupIds);
720                            }
721    
722                            if (classNameIds != null) {
723                                    qPos.add(classNameIds);
724                            }
725    
726                            if (classPKs != null) {
727                                    qPos.add(classPKs);
728                            }
729    
730                            qPos.add(resourceClassNameId);
731                            qPos.add(names, 2);
732                            qPos.add(descriptions, 2);
733                            qPos.add(types, 2);
734                            qPos.add(modes, 2);
735                            qPos.add(languages, 2);
736    
737                            Iterator<Long> itr = q.iterate();
738    
739                            if (itr.hasNext()) {
740                                    Long count = itr.next();
741    
742                                    if (count != null) {
743                                            return count.intValue();
744                                    }
745                            }
746    
747                            return 0;
748                    }
749                    catch (Exception e) {
750                            throw new SystemException(e);
751                    }
752                    finally {
753                            closeSession(session);
754                    }
755            }
756    
757            protected List<DDMTemplate> doFindByG_C_SC(
758                    long[] groupIds, long classNameId, long structureClassNameId, int start,
759                    int end, OrderByComparator<DDMTemplate> orderByComparator,
760                    boolean inlineSQLHelper) {
761    
762                    Session session = null;
763    
764                    try {
765                            session = openSession();
766    
767                            String sql = CustomSQLUtil.get(FIND_BY_G_C_SC);
768    
769                            if (inlineSQLHelper) {
770                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
771                                            sql, DDMTemplate.class.getName(), "DDMTemplate.templateId",
772                                            groupIds);
773                            }
774    
775                            sql = StringUtil.replace(
776                                    sql, "[$GROUP_ID$]", getGroupIds(groupIds));
777    
778                            if (orderByComparator != null) {
779                                    sql = CustomSQLUtil.replaceOrderBy(sql, orderByComparator);
780                            }
781    
782                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
783    
784                            q.addEntity("DDMTemplate", DDMTemplateImpl.class);
785    
786                            QueryPos qPos = QueryPos.getInstance(q);
787    
788                            if (groupIds != null) {
789                                    qPos.add(groupIds);
790                            }
791    
792                            qPos.add(classNameId);
793                            qPos.add(structureClassNameId);
794    
795                            return (List<DDMTemplate>)QueryUtil.list(
796                                    q, getDialect(), start, end);
797                    }
798                    catch (Exception e) {
799                            throw new SystemException(e);
800                    }
801                    finally {
802                            closeSession(session);
803                    }
804            }
805    
806            protected List<DDMTemplate> doFindByC_G_C_C_R_N_D_T_M_L(
807                    long companyId, long[] groupIds, long[] classNameIds, long[] classPKs,
808                    long resourceClassNameId, String[] names, String[] descriptions,
809                    String[] types, String[] modes, String[] languages, boolean andOperator,
810                    int start, int end, OrderByComparator<DDMTemplate> orderByComparator,
811                    boolean inlineSQLHelper) {
812    
813                    names = CustomSQLUtil.keywords(names);
814                    descriptions = CustomSQLUtil.keywords(descriptions, false);
815                    types = CustomSQLUtil.keywords(types, false);
816                    modes = CustomSQLUtil.keywords(modes, false);
817                    languages = CustomSQLUtil.keywords(languages, false);
818    
819                    Session session = null;
820    
821                    try {
822                            session = openSession();
823    
824                            String sql = CustomSQLUtil.get(FIND_BY_C_G_C_C_R_N_D_T_M_L);
825    
826                            if (inlineSQLHelper) {
827                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
828                                            sql, DDMTemplate.class.getName(), "DDMTemplate.templateId",
829                                            groupIds);
830                            }
831    
832                            sql = StringUtil.replace(
833                                    sql, "[$GROUP_ID$]", getGroupIds(groupIds));
834                            sql = StringUtil.replace(
835                                    sql, "[$CLASSNAME_ID$]", getClassNameIds(classNameIds));
836                            sql = StringUtil.replace(
837                                    sql, "[$CLASS_PK$]", getClassPKs(classPKs));
838                            sql = CustomSQLUtil.replaceKeywords(
839                                    sql, "lower(name)", StringPool.LIKE, false, names);
840                            sql = CustomSQLUtil.replaceKeywords(
841                                    sql, "description", StringPool.LIKE, false, descriptions);
842                            sql = CustomSQLUtil.replaceKeywords(
843                                    sql, "type", StringPool.LIKE, false, types);
844                            sql = CustomSQLUtil.replaceKeywords(
845                                    sql, "mode", StringPool.LIKE, false, modes);
846                            sql = CustomSQLUtil.replaceKeywords(
847                                    sql, "language", StringPool.LIKE, true, languages);
848                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
849    
850                            if (orderByComparator != null) {
851                                    sql = CustomSQLUtil.replaceOrderBy(sql, orderByComparator);
852                            }
853    
854                            SQLQuery q = session.createSynchronizedSQLQuery(sql);
855    
856                            q.addEntity("DDMTemplate", DDMTemplateImpl.class);
857    
858                            QueryPos qPos = QueryPos.getInstance(q);
859    
860                            qPos.add(companyId);
861    
862                            if (groupIds != null) {
863                                    qPos.add(groupIds);
864                            }
865    
866                            if (classNameIds != null) {
867                                    qPos.add(classNameIds);
868                            }
869    
870                            if (classPKs != null) {
871                                    qPos.add(classPKs);
872                            }
873    
874                            qPos.add(resourceClassNameId);
875                            qPos.add(names, 2);
876                            qPos.add(descriptions, 2);
877                            qPos.add(types, 2);
878                            qPos.add(modes, 2);
879                            qPos.add(languages, 2);
880    
881                            return (List<DDMTemplate>)QueryUtil.list(
882                                    q, getDialect(), start, end);
883                    }
884                    catch (Exception e) {
885                            throw new SystemException(e);
886                    }
887                    finally {
888                            closeSession(session);
889                    }
890            }
891    
892            protected String getClassNameIds(long[] classNameIds) {
893                    if (ArrayUtil.isEmpty(classNameIds)) {
894                            return StringPool.BLANK;
895                    }
896    
897                    StringBundler sb = new StringBundler(classNameIds.length * 2);
898    
899                    sb.append(StringPool.OPEN_PARENTHESIS);
900    
901                    for (int i = 0; i < classNameIds.length; i++) {
902                            sb.append("classNameId = ?");
903    
904                            if ((i + 1) < classNameIds.length) {
905                                    sb.append(" OR ");
906                            }
907                    }
908    
909                    sb.append(") AND");
910    
911                    return sb.toString();
912            }
913    
914            protected String getClassPKs(long[] classPKs) {
915                    if (ArrayUtil.isEmpty(classPKs)) {
916                            return StringPool.BLANK;
917                    }
918    
919                    StringBundler sb = new StringBundler(classPKs.length * 2);
920    
921                    sb.append(StringPool.OPEN_PARENTHESIS);
922    
923                    for (int i = 0; i < classPKs.length; i++) {
924                            sb.append("classPK = ?");
925    
926                            if ((i + 1) < classPKs.length) {
927                                    sb.append(" OR ");
928                            }
929                    }
930    
931                    sb.append(") AND");
932    
933                    return sb.toString();
934            }
935    
936            protected String getGroupIds(long[] groupIds) {
937                    if (ArrayUtil.isEmpty(groupIds)) {
938                            return StringPool.BLANK;
939                    }
940    
941                    StringBundler sb = new StringBundler(groupIds.length * 2);
942    
943                    sb.append(StringPool.OPEN_PARENTHESIS);
944    
945                    for (int i = 0; i < groupIds.length; i++) {
946                            sb.append("groupId = ?");
947    
948                            if ((i + 1) < groupIds.length) {
949                                    sb.append(" OR ");
950                            }
951                    }
952    
953                    sb.append(") AND");
954    
955                    return sb.toString();
956            }
957    
958    }