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