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