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