001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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, "DDMTemplate.description", StringPool.LIKE, false,
737                                    descriptions);
738                            sql = CustomSQLUtil.replaceKeywords(
739                                    sql, "DDMTemplate.type", StringPool.LIKE, false, types);
740                            sql = CustomSQLUtil.replaceKeywords(
741                                    sql, "DDMTemplate.mode", StringPool.LIKE, false, modes);
742                            sql = CustomSQLUtil.replaceKeywords(
743                                    sql, "DDMTemplate.language", StringPool.LIKE, true, languages);
744                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
745    
746                            SQLQuery q = session.createSQLQuery(sql);
747    
748                            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
749    
750                            QueryPos qPos = QueryPos.getInstance(q);
751    
752                            qPos.add(companyId);
753    
754                            if (groupIds != null) {
755                                    qPos.add(groupIds);
756                            }
757    
758                            if (classNameIds != null) {
759                                    qPos.add(classNameIds);
760                            }
761    
762                            if (classPKs != null) {
763                                    qPos.add(classPKs);
764                            }
765    
766                            qPos.add(names, 2);
767                            qPos.add(descriptions, 2);
768                            qPos.add(types, 2);
769                            qPos.add(modes, 2);
770                            qPos.add(languages, 2);
771    
772                            Iterator<Long> itr = q.iterate();
773    
774                            if (itr.hasNext()) {
775                                    Long count = itr.next();
776    
777                                    if (count != null) {
778                                            return count.intValue();
779                                    }
780                            }
781    
782                            return 0;
783                    }
784                    catch (Exception e) {
785                            throw new SystemException(e);
786                    }
787                    finally {
788                            closeSession(session);
789                    }
790            }
791    
792            protected List<DDMTemplate> doFindByG_C_SC(
793                            long[] groupIds, long classNameId, long structureClassNameId,
794                            int start, int end, OrderByComparator orderByComparator,
795                            boolean inlineSQLHelper)
796                    throws SystemException {
797    
798                    Session session = null;
799    
800                    try {
801                            session = openSession();
802    
803                            String sql = CustomSQLUtil.get(FIND_BY_G_C_SC);
804    
805                            if (inlineSQLHelper) {
806                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
807                                            sql, DDMTemplate.class.getName(), "DDMTemplate.templateId",
808                                            groupIds);
809                            }
810    
811                            sql = StringUtil.replace(
812                                    sql, "[$GROUP_ID$]", getGroupIds(groupIds));
813    
814                            if (orderByComparator != null) {
815                                    sql = CustomSQLUtil.replaceOrderBy(sql, orderByComparator);
816                            }
817    
818                            SQLQuery q = session.createSQLQuery(sql);
819    
820                            q.addEntity("DDMTemplate", DDMTemplateImpl.class);
821    
822                            QueryPos qPos = QueryPos.getInstance(q);
823    
824                            if (groupIds != null) {
825                                    qPos.add(groupIds);
826                            }
827    
828                            qPos.add(classNameId);
829                            qPos.add(structureClassNameId);
830    
831                            return (List<DDMTemplate>)QueryUtil.list(
832                                    q, getDialect(), start, end);
833                    }
834                    catch (Exception e) {
835                            throw new SystemException(e);
836                    }
837                    finally {
838                            closeSession(session);
839                    }
840            }
841    
842            protected List<DDMTemplate> doFindByC_G_C_C_N_D_T_M_L(
843                            long companyId, long[] groupIds, long[] classNameIds,
844                            long[] classPKs, String[] names, String[] descriptions,
845                            String[] types, String[] modes, String[] languages,
846                            boolean andOperator, int start, int end,
847                            OrderByComparator orderByComparator, boolean inlineSQLHelper)
848                    throws SystemException {
849    
850                    names = CustomSQLUtil.keywords(names);
851                    descriptions = CustomSQLUtil.keywords(descriptions, false);
852                    types = CustomSQLUtil.keywords(types, false);
853                    modes = CustomSQLUtil.keywords(modes, false);
854                    languages = CustomSQLUtil.keywords(languages, false);
855    
856                    Session session = null;
857    
858                    try {
859                            session = openSession();
860    
861                            String sql = CustomSQLUtil.get(FIND_BY_C_G_C_C_N_D_T_M_L);
862    
863                            if (inlineSQLHelper) {
864                                    sql = InlineSQLHelperUtil.replacePermissionCheck(
865                                            sql, DDMTemplate.class.getName(), "DDMTemplate.templateId",
866                                            groupIds);
867                            }
868    
869                            sql = StringUtil.replace(
870                                    sql, "[$GROUP_ID$]", getGroupIds(groupIds));
871                            sql = StringUtil.replace(
872                                    sql, "[$CLASSNAME_ID$]", getClassNameIds(classNameIds));
873                            sql = StringUtil.replace(
874                                    sql, "[$CLASS_PK$]", getClassPKs(classPKs));
875                            sql = CustomSQLUtil.replaceKeywords(
876                                    sql, "lower(DDMTemplate.name)", StringPool.LIKE, false, names);
877                            sql = CustomSQLUtil.replaceKeywords(
878                                    sql, "DDMTemplate.description", StringPool.LIKE, false,
879                                    descriptions);
880                            sql = CustomSQLUtil.replaceKeywords(
881                                    sql, "DDMTemplate.type", StringPool.LIKE, false, types);
882                            sql = CustomSQLUtil.replaceKeywords(
883                                    sql, "DDMTemplate.mode", StringPool.LIKE, false, modes);
884                            sql = CustomSQLUtil.replaceKeywords(
885                                    sql, "DDMTemplate.language", StringPool.LIKE, true, languages);
886                            sql = CustomSQLUtil.replaceAndOperator(sql, andOperator);
887    
888                            if (orderByComparator != null) {
889                                    sql = CustomSQLUtil.replaceOrderBy(sql, orderByComparator);
890                            }
891    
892                            SQLQuery q = session.createSQLQuery(sql);
893    
894                            q.addEntity("DDMTemplate", DDMTemplateImpl.class);
895    
896                            QueryPos qPos = QueryPos.getInstance(q);
897    
898                            qPos.add(companyId);
899    
900                            if (groupIds != null) {
901                                    qPos.add(groupIds);
902                            }
903    
904                            if (classNameIds != null) {
905                                    qPos.add(classNameIds);
906                            }
907    
908                            if (classPKs != null) {
909                                    qPos.add(classPKs);
910                            }
911    
912                            qPos.add(names, 2);
913                            qPos.add(descriptions, 2);
914                            qPos.add(types, 2);
915                            qPos.add(modes, 2);
916                            qPos.add(languages, 2);
917    
918                            return (List<DDMTemplate>)QueryUtil.list(
919                                    q, getDialect(), start, end);
920                    }
921                    catch (Exception e) {
922                            throw new SystemException(e);
923                    }
924                    finally {
925                            closeSession(session);
926                    }
927            }
928    
929            protected String getClassNameIds(long[] classNameIds) {
930                    if (ArrayUtil.isEmpty(classNameIds)) {
931                            return StringPool.BLANK;
932                    }
933    
934                    StringBundler sb = new StringBundler(classNameIds.length * 2);
935    
936                    sb.append(StringPool.OPEN_PARENTHESIS);
937    
938                    for (int i = 0; i < classNameIds.length; i++) {
939                            sb.append("classNameId = ?");
940    
941                            if ((i + 1) < classNameIds.length) {
942                                    sb.append(" OR ");
943                            }
944                    }
945    
946                    sb.append(") AND");
947    
948                    return sb.toString();
949            }
950    
951            protected String getClassPKs(long[] classPKs) {
952                    if (ArrayUtil.isEmpty(classPKs)) {
953                            return StringPool.BLANK;
954                    }
955    
956                    StringBundler sb = new StringBundler(classPKs.length * 2);
957    
958                    sb.append(StringPool.OPEN_PARENTHESIS);
959    
960                    for (int i = 0; i < classPKs.length; i++) {
961                            sb.append("classPK = ?");
962    
963                            if ((i + 1) < classPKs.length) {
964                                    sb.append(" OR ");
965                            }
966                    }
967    
968                    sb.append(") AND");
969    
970                    return sb.toString();
971            }
972    
973            protected String getGroupIds(long[] groupIds) {
974                    if (ArrayUtil.isEmpty(groupIds)) {
975                            return StringPool.BLANK;
976                    }
977    
978                    StringBundler sb = new StringBundler(groupIds.length * 2);
979    
980                    sb.append(StringPool.OPEN_PARENTHESIS);
981    
982                    for (int i = 0; i < groupIds.length; i++) {
983                            sb.append("groupId = ?");
984    
985                            if ((i + 1) < groupIds.length) {
986                                    sb.append(" OR ");
987                            }
988                    }
989    
990                    sb.append(") AND");
991    
992                    return sb.toString();
993            }
994    
995    }