1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.service.persistence;
16  
17  import com.liferay.portal.NoSuchLayoutException;
18  import com.liferay.portal.NoSuchModelException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.exception.SystemException;
29  import com.liferay.portal.kernel.log.Log;
30  import com.liferay.portal.kernel.log.LogFactoryUtil;
31  import com.liferay.portal.kernel.util.GetterUtil;
32  import com.liferay.portal.kernel.util.InstanceFactory;
33  import com.liferay.portal.kernel.util.OrderByComparator;
34  import com.liferay.portal.kernel.util.StringBundler;
35  import com.liferay.portal.kernel.util.StringPool;
36  import com.liferay.portal.kernel.util.StringUtil;
37  import com.liferay.portal.kernel.util.Validator;
38  import com.liferay.portal.model.Layout;
39  import com.liferay.portal.model.ModelListener;
40  import com.liferay.portal.model.impl.LayoutImpl;
41  import com.liferay.portal.model.impl.LayoutModelImpl;
42  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
43  
44  import com.liferay.portlet.documentlibrary.service.persistence.DLFolderPersistence;
45  import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
46  import com.liferay.portlet.journal.service.persistence.JournalContentSearchPersistence;
47  import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
48  import com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence;
49  import com.liferay.portlet.tasks.service.persistence.TasksProposalPersistence;
50  
51  import java.io.Serializable;
52  
53  import java.util.ArrayList;
54  import java.util.Collections;
55  import java.util.List;
56  
57  /**
58   * <a href="LayoutPersistenceImpl.java.html"><b><i>View Source</i></b></a>
59   *
60   * <p>
61   * ServiceBuilder generated this class. Modifications in this class will be
62   * overwritten the next time is generated.
63   * </p>
64   *
65   * @author    Brian Wing Shun Chan
66   * @see       LayoutPersistence
67   * @see       LayoutUtil
68   * @generated
69   */
70  public class LayoutPersistenceImpl extends BasePersistenceImpl<Layout>
71      implements LayoutPersistence {
72      public static final String FINDER_CLASS_NAME_ENTITY = LayoutImpl.class.getName();
73      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
74          ".List";
75      public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
76              LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
77              "findByGroupId",
78              new String[] {
79                  Long.class.getName(),
80                  
81              "java.lang.Integer", "java.lang.Integer",
82                  "com.liferay.portal.kernel.util.OrderByComparator"
83              });
84      public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
85              LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
86              "countByGroupId", new String[] { Long.class.getName() });
87      public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
88              LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
89              "findByCompanyId",
90              new String[] {
91                  Long.class.getName(),
92                  
93              "java.lang.Integer", "java.lang.Integer",
94                  "com.liferay.portal.kernel.util.OrderByComparator"
95              });
96      public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
97              LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
98              "countByCompanyId", new String[] { Long.class.getName() });
99      public static final FinderPath FINDER_PATH_FETCH_BY_DLFOLDERID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
100             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
101             "fetchByDLFolderId", new String[] { Long.class.getName() });
102     public static final FinderPath FINDER_PATH_COUNT_BY_DLFOLDERID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
103             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
104             "countByDLFolderId", new String[] { Long.class.getName() });
105     public static final FinderPath FINDER_PATH_FETCH_BY_ICONIMAGEID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
106             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
107             "fetchByIconImageId", new String[] { Long.class.getName() });
108     public static final FinderPath FINDER_PATH_COUNT_BY_ICONIMAGEID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
109             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
110             "countByIconImageId", new String[] { Long.class.getName() });
111     public static final FinderPath FINDER_PATH_FIND_BY_G_P = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
112             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
113             "findByG_P",
114             new String[] {
115                 Long.class.getName(), Boolean.class.getName(),
116                 
117             "java.lang.Integer", "java.lang.Integer",
118                 "com.liferay.portal.kernel.util.OrderByComparator"
119             });
120     public static final FinderPath FINDER_PATH_COUNT_BY_G_P = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
121             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
122             "countByG_P",
123             new String[] { Long.class.getName(), Boolean.class.getName() });
124     public static final FinderPath FINDER_PATH_FETCH_BY_G_P_L = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
125             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
126             "fetchByG_P_L",
127             new String[] {
128                 Long.class.getName(), Boolean.class.getName(),
129                 Long.class.getName()
130             });
131     public static final FinderPath FINDER_PATH_COUNT_BY_G_P_L = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
132             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
133             "countByG_P_L",
134             new String[] {
135                 Long.class.getName(), Boolean.class.getName(),
136                 Long.class.getName()
137             });
138     public static final FinderPath FINDER_PATH_FIND_BY_G_P_P = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
139             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
140             "findByG_P_P",
141             new String[] {
142                 Long.class.getName(), Boolean.class.getName(),
143                 Long.class.getName(),
144                 
145             "java.lang.Integer", "java.lang.Integer",
146                 "com.liferay.portal.kernel.util.OrderByComparator"
147             });
148     public static final FinderPath FINDER_PATH_COUNT_BY_G_P_P = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
149             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
150             "countByG_P_P",
151             new String[] {
152                 Long.class.getName(), Boolean.class.getName(),
153                 Long.class.getName()
154             });
155     public static final FinderPath FINDER_PATH_FETCH_BY_G_P_F = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
156             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
157             "fetchByG_P_F",
158             new String[] {
159                 Long.class.getName(), Boolean.class.getName(),
160                 String.class.getName()
161             });
162     public static final FinderPath FINDER_PATH_COUNT_BY_G_P_F = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
163             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
164             "countByG_P_F",
165             new String[] {
166                 Long.class.getName(), Boolean.class.getName(),
167                 String.class.getName()
168             });
169     public static final FinderPath FINDER_PATH_FIND_BY_G_P_T = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
170             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
171             "findByG_P_T",
172             new String[] {
173                 Long.class.getName(), Boolean.class.getName(),
174                 String.class.getName(),
175                 
176             "java.lang.Integer", "java.lang.Integer",
177                 "com.liferay.portal.kernel.util.OrderByComparator"
178             });
179     public static final FinderPath FINDER_PATH_COUNT_BY_G_P_T = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
180             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
181             "countByG_P_T",
182             new String[] {
183                 Long.class.getName(), Boolean.class.getName(),
184                 String.class.getName()
185             });
186     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
187             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
188             "findAll", new String[0]);
189     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
190             LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
191             "countAll", new String[0]);
192 
193     public void cacheResult(Layout layout) {
194         EntityCacheUtil.putResult(LayoutModelImpl.ENTITY_CACHE_ENABLED,
195             LayoutImpl.class, layout.getPrimaryKey(), layout);
196 
197         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
198             new Object[] { new Long(layout.getDlFolderId()) }, layout);
199 
200         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
201             new Object[] { new Long(layout.getIconImageId()) }, layout);
202 
203         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_L,
204             new Object[] {
205                 new Long(layout.getGroupId()),
206                 Boolean.valueOf(layout.getPrivateLayout()),
207                 new Long(layout.getLayoutId())
208             }, layout);
209 
210         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_F,
211             new Object[] {
212                 new Long(layout.getGroupId()),
213                 Boolean.valueOf(layout.getPrivateLayout()),
214                 
215             layout.getFriendlyURL()
216             }, layout);
217     }
218 
219     public void cacheResult(List<Layout> layouts) {
220         for (Layout layout : layouts) {
221             if (EntityCacheUtil.getResult(
222                         LayoutModelImpl.ENTITY_CACHE_ENABLED, LayoutImpl.class,
223                         layout.getPrimaryKey(), this) == null) {
224                 cacheResult(layout);
225             }
226         }
227     }
228 
229     public void clearCache() {
230         CacheRegistry.clear(LayoutImpl.class.getName());
231         EntityCacheUtil.clearCache(LayoutImpl.class.getName());
232         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
233         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
234     }
235 
236     public void clearCache(Layout layout) {
237         EntityCacheUtil.removeResult(LayoutModelImpl.ENTITY_CACHE_ENABLED,
238             LayoutImpl.class, layout.getPrimaryKey());
239 
240         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
241             new Object[] { new Long(layout.getDlFolderId()) });
242 
243         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
244             new Object[] { new Long(layout.getIconImageId()) });
245 
246         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_L,
247             new Object[] {
248                 new Long(layout.getGroupId()),
249                 Boolean.valueOf(layout.getPrivateLayout()),
250                 new Long(layout.getLayoutId())
251             });
252 
253         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_F,
254             new Object[] {
255                 new Long(layout.getGroupId()),
256                 Boolean.valueOf(layout.getPrivateLayout()),
257                 
258             layout.getFriendlyURL()
259             });
260     }
261 
262     public Layout create(long plid) {
263         Layout layout = new LayoutImpl();
264 
265         layout.setNew(true);
266         layout.setPrimaryKey(plid);
267 
268         return layout;
269     }
270 
271     public Layout remove(Serializable primaryKey)
272         throws NoSuchModelException, SystemException {
273         return remove(((Long)primaryKey).longValue());
274     }
275 
276     public Layout remove(long plid)
277         throws NoSuchLayoutException, SystemException {
278         Session session = null;
279 
280         try {
281             session = openSession();
282 
283             Layout layout = (Layout)session.get(LayoutImpl.class, new Long(plid));
284 
285             if (layout == null) {
286                 if (_log.isWarnEnabled()) {
287                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + plid);
288                 }
289 
290                 throw new NoSuchLayoutException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
291                     plid);
292             }
293 
294             return remove(layout);
295         }
296         catch (NoSuchLayoutException nsee) {
297             throw nsee;
298         }
299         catch (Exception e) {
300             throw processException(e);
301         }
302         finally {
303             closeSession(session);
304         }
305     }
306 
307     public Layout remove(Layout layout) throws SystemException {
308         for (ModelListener<Layout> listener : listeners) {
309             listener.onBeforeRemove(layout);
310         }
311 
312         layout = removeImpl(layout);
313 
314         for (ModelListener<Layout> listener : listeners) {
315             listener.onAfterRemove(layout);
316         }
317 
318         return layout;
319     }
320 
321     protected Layout removeImpl(Layout layout) throws SystemException {
322         layout = toUnwrappedModel(layout);
323 
324         Session session = null;
325 
326         try {
327             session = openSession();
328 
329             if (layout.isCachedModel() || BatchSessionUtil.isEnabled()) {
330                 Object staleObject = session.get(LayoutImpl.class,
331                         layout.getPrimaryKeyObj());
332 
333                 if (staleObject != null) {
334                     session.evict(staleObject);
335                 }
336             }
337 
338             session.delete(layout);
339 
340             session.flush();
341         }
342         catch (Exception e) {
343             throw processException(e);
344         }
345         finally {
346             closeSession(session);
347         }
348 
349         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
350 
351         LayoutModelImpl layoutModelImpl = (LayoutModelImpl)layout;
352 
353         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
354             new Object[] { new Long(layoutModelImpl.getOriginalDlFolderId()) });
355 
356         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
357             new Object[] { new Long(layoutModelImpl.getOriginalIconImageId()) });
358 
359         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_L,
360             new Object[] {
361                 new Long(layoutModelImpl.getOriginalGroupId()),
362                 Boolean.valueOf(layoutModelImpl.getOriginalPrivateLayout()),
363                 new Long(layoutModelImpl.getOriginalLayoutId())
364             });
365 
366         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_F,
367             new Object[] {
368                 new Long(layoutModelImpl.getOriginalGroupId()),
369                 Boolean.valueOf(layoutModelImpl.getOriginalPrivateLayout()),
370                 
371             layoutModelImpl.getOriginalFriendlyURL()
372             });
373 
374         EntityCacheUtil.removeResult(LayoutModelImpl.ENTITY_CACHE_ENABLED,
375             LayoutImpl.class, layout.getPrimaryKey());
376 
377         return layout;
378     }
379 
380     public Layout updateImpl(com.liferay.portal.model.Layout layout,
381         boolean merge) throws SystemException {
382         layout = toUnwrappedModel(layout);
383 
384         boolean isNew = layout.isNew();
385 
386         LayoutModelImpl layoutModelImpl = (LayoutModelImpl)layout;
387 
388         Session session = null;
389 
390         try {
391             session = openSession();
392 
393             BatchSessionUtil.update(session, layout, merge);
394 
395             layout.setNew(false);
396         }
397         catch (Exception e) {
398             throw processException(e);
399         }
400         finally {
401             closeSession(session);
402         }
403 
404         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
405 
406         EntityCacheUtil.putResult(LayoutModelImpl.ENTITY_CACHE_ENABLED,
407             LayoutImpl.class, layout.getPrimaryKey(), layout);
408 
409         if (!isNew &&
410                 (layout.getDlFolderId() != layoutModelImpl.getOriginalDlFolderId())) {
411             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
412                 new Object[] { new Long(layoutModelImpl.getOriginalDlFolderId()) });
413         }
414 
415         if (isNew ||
416                 (layout.getDlFolderId() != layoutModelImpl.getOriginalDlFolderId())) {
417             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
418                 new Object[] { new Long(layout.getDlFolderId()) }, layout);
419         }
420 
421         if (!isNew &&
422                 (layout.getIconImageId() != layoutModelImpl.getOriginalIconImageId())) {
423             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
424                 new Object[] { new Long(layoutModelImpl.getOriginalIconImageId()) });
425         }
426 
427         if (isNew ||
428                 (layout.getIconImageId() != layoutModelImpl.getOriginalIconImageId())) {
429             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
430                 new Object[] { new Long(layout.getIconImageId()) }, layout);
431         }
432 
433         if (!isNew &&
434                 ((layout.getGroupId() != layoutModelImpl.getOriginalGroupId()) ||
435                 (layout.getPrivateLayout() != layoutModelImpl.getOriginalPrivateLayout()) ||
436                 (layout.getLayoutId() != layoutModelImpl.getOriginalLayoutId()))) {
437             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_L,
438                 new Object[] {
439                     new Long(layoutModelImpl.getOriginalGroupId()),
440                     Boolean.valueOf(layoutModelImpl.getOriginalPrivateLayout()),
441                     new Long(layoutModelImpl.getOriginalLayoutId())
442                 });
443         }
444 
445         if (isNew ||
446                 ((layout.getGroupId() != layoutModelImpl.getOriginalGroupId()) ||
447                 (layout.getPrivateLayout() != layoutModelImpl.getOriginalPrivateLayout()) ||
448                 (layout.getLayoutId() != layoutModelImpl.getOriginalLayoutId()))) {
449             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_L,
450                 new Object[] {
451                     new Long(layout.getGroupId()),
452                     Boolean.valueOf(layout.getPrivateLayout()),
453                     new Long(layout.getLayoutId())
454                 }, layout);
455         }
456 
457         if (!isNew &&
458                 ((layout.getGroupId() != layoutModelImpl.getOriginalGroupId()) ||
459                 (layout.getPrivateLayout() != layoutModelImpl.getOriginalPrivateLayout()) ||
460                 !Validator.equals(layout.getFriendlyURL(),
461                     layoutModelImpl.getOriginalFriendlyURL()))) {
462             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_F,
463                 new Object[] {
464                     new Long(layoutModelImpl.getOriginalGroupId()),
465                     Boolean.valueOf(layoutModelImpl.getOriginalPrivateLayout()),
466                     
467                 layoutModelImpl.getOriginalFriendlyURL()
468                 });
469         }
470 
471         if (isNew ||
472                 ((layout.getGroupId() != layoutModelImpl.getOriginalGroupId()) ||
473                 (layout.getPrivateLayout() != layoutModelImpl.getOriginalPrivateLayout()) ||
474                 !Validator.equals(layout.getFriendlyURL(),
475                     layoutModelImpl.getOriginalFriendlyURL()))) {
476             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_F,
477                 new Object[] {
478                     new Long(layout.getGroupId()),
479                     Boolean.valueOf(layout.getPrivateLayout()),
480                     
481                 layout.getFriendlyURL()
482                 }, layout);
483         }
484 
485         return layout;
486     }
487 
488     protected Layout toUnwrappedModel(Layout layout) {
489         if (layout instanceof LayoutImpl) {
490             return layout;
491         }
492 
493         LayoutImpl layoutImpl = new LayoutImpl();
494 
495         layoutImpl.setNew(layout.isNew());
496         layoutImpl.setPrimaryKey(layout.getPrimaryKey());
497 
498         layoutImpl.setPlid(layout.getPlid());
499         layoutImpl.setGroupId(layout.getGroupId());
500         layoutImpl.setCompanyId(layout.getCompanyId());
501         layoutImpl.setPrivateLayout(layout.isPrivateLayout());
502         layoutImpl.setLayoutId(layout.getLayoutId());
503         layoutImpl.setParentLayoutId(layout.getParentLayoutId());
504         layoutImpl.setName(layout.getName());
505         layoutImpl.setTitle(layout.getTitle());
506         layoutImpl.setDescription(layout.getDescription());
507         layoutImpl.setType(layout.getType());
508         layoutImpl.setTypeSettings(layout.getTypeSettings());
509         layoutImpl.setHidden(layout.isHidden());
510         layoutImpl.setFriendlyURL(layout.getFriendlyURL());
511         layoutImpl.setIconImage(layout.isIconImage());
512         layoutImpl.setIconImageId(layout.getIconImageId());
513         layoutImpl.setThemeId(layout.getThemeId());
514         layoutImpl.setColorSchemeId(layout.getColorSchemeId());
515         layoutImpl.setWapThemeId(layout.getWapThemeId());
516         layoutImpl.setWapColorSchemeId(layout.getWapColorSchemeId());
517         layoutImpl.setCss(layout.getCss());
518         layoutImpl.setPriority(layout.getPriority());
519         layoutImpl.setLayoutPrototypeId(layout.getLayoutPrototypeId());
520         layoutImpl.setDlFolderId(layout.getDlFolderId());
521 
522         return layoutImpl;
523     }
524 
525     public Layout findByPrimaryKey(Serializable primaryKey)
526         throws NoSuchModelException, SystemException {
527         return findByPrimaryKey(((Long)primaryKey).longValue());
528     }
529 
530     public Layout findByPrimaryKey(long plid)
531         throws NoSuchLayoutException, SystemException {
532         Layout layout = fetchByPrimaryKey(plid);
533 
534         if (layout == null) {
535             if (_log.isWarnEnabled()) {
536                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + plid);
537             }
538 
539             throw new NoSuchLayoutException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
540                 plid);
541         }
542 
543         return layout;
544     }
545 
546     public Layout fetchByPrimaryKey(Serializable primaryKey)
547         throws SystemException {
548         return fetchByPrimaryKey(((Long)primaryKey).longValue());
549     }
550 
551     public Layout fetchByPrimaryKey(long plid) throws SystemException {
552         Layout layout = (Layout)EntityCacheUtil.getResult(LayoutModelImpl.ENTITY_CACHE_ENABLED,
553                 LayoutImpl.class, plid, this);
554 
555         if (layout == null) {
556             Session session = null;
557 
558             try {
559                 session = openSession();
560 
561                 layout = (Layout)session.get(LayoutImpl.class, new Long(plid));
562             }
563             catch (Exception e) {
564                 throw processException(e);
565             }
566             finally {
567                 if (layout != null) {
568                     cacheResult(layout);
569                 }
570 
571                 closeSession(session);
572             }
573         }
574 
575         return layout;
576     }
577 
578     public List<Layout> findByGroupId(long groupId) throws SystemException {
579         return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
580     }
581 
582     public List<Layout> findByGroupId(long groupId, int start, int end)
583         throws SystemException {
584         return findByGroupId(groupId, start, end, null);
585     }
586 
587     public List<Layout> findByGroupId(long groupId, int start, int end,
588         OrderByComparator orderByComparator) throws SystemException {
589         Object[] finderArgs = new Object[] {
590                 new Long(groupId),
591                 
592                 String.valueOf(start), String.valueOf(end),
593                 String.valueOf(orderByComparator)
594             };
595 
596         List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
597                 finderArgs, this);
598 
599         if (list == null) {
600             Session session = null;
601 
602             try {
603                 session = openSession();
604 
605                 StringBundler query = null;
606 
607                 if (orderByComparator != null) {
608                     query = new StringBundler(3 +
609                             (orderByComparator.getOrderByFields().length * 3));
610                 }
611                 else {
612                     query = new StringBundler(3);
613                 }
614 
615                 query.append(_SQL_SELECT_LAYOUT_WHERE);
616 
617                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
618 
619                 if (orderByComparator != null) {
620                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
621                         orderByComparator);
622                 }
623 
624                 else {
625                     query.append(LayoutModelImpl.ORDER_BY_JPQL);
626                 }
627 
628                 String sql = query.toString();
629 
630                 Query q = session.createQuery(sql);
631 
632                 QueryPos qPos = QueryPos.getInstance(q);
633 
634                 qPos.add(groupId);
635 
636                 list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
637             }
638             catch (Exception e) {
639                 throw processException(e);
640             }
641             finally {
642                 if (list == null) {
643                     list = new ArrayList<Layout>();
644                 }
645 
646                 cacheResult(list);
647 
648                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
649                     finderArgs, list);
650 
651                 closeSession(session);
652             }
653         }
654 
655         return list;
656     }
657 
658     public Layout findByGroupId_First(long groupId,
659         OrderByComparator orderByComparator)
660         throws NoSuchLayoutException, SystemException {
661         List<Layout> list = findByGroupId(groupId, 0, 1, orderByComparator);
662 
663         if (list.isEmpty()) {
664             StringBundler msg = new StringBundler(4);
665 
666             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
667 
668             msg.append("groupId=");
669             msg.append(groupId);
670 
671             msg.append(StringPool.CLOSE_CURLY_BRACE);
672 
673             throw new NoSuchLayoutException(msg.toString());
674         }
675         else {
676             return list.get(0);
677         }
678     }
679 
680     public Layout findByGroupId_Last(long groupId,
681         OrderByComparator orderByComparator)
682         throws NoSuchLayoutException, SystemException {
683         int count = countByGroupId(groupId);
684 
685         List<Layout> list = findByGroupId(groupId, count - 1, count,
686                 orderByComparator);
687 
688         if (list.isEmpty()) {
689             StringBundler msg = new StringBundler(4);
690 
691             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
692 
693             msg.append("groupId=");
694             msg.append(groupId);
695 
696             msg.append(StringPool.CLOSE_CURLY_BRACE);
697 
698             throw new NoSuchLayoutException(msg.toString());
699         }
700         else {
701             return list.get(0);
702         }
703     }
704 
705     public Layout[] findByGroupId_PrevAndNext(long plid, long groupId,
706         OrderByComparator orderByComparator)
707         throws NoSuchLayoutException, SystemException {
708         Layout layout = findByPrimaryKey(plid);
709 
710         Session session = null;
711 
712         try {
713             session = openSession();
714 
715             Layout[] array = new LayoutImpl[3];
716 
717             array[0] = getByGroupId_PrevAndNext(session, layout, groupId,
718                     orderByComparator, true);
719 
720             array[1] = layout;
721 
722             array[2] = getByGroupId_PrevAndNext(session, layout, groupId,
723                     orderByComparator, false);
724 
725             return array;
726         }
727         catch (Exception e) {
728             throw processException(e);
729         }
730         finally {
731             closeSession(session);
732         }
733     }
734 
735     protected Layout getByGroupId_PrevAndNext(Session session, Layout layout,
736         long groupId, OrderByComparator orderByComparator, boolean previous) {
737         StringBundler query = null;
738 
739         if (orderByComparator != null) {
740             query = new StringBundler(6 +
741                     (orderByComparator.getOrderByFields().length * 6));
742         }
743         else {
744             query = new StringBundler(3);
745         }
746 
747         query.append(_SQL_SELECT_LAYOUT_WHERE);
748 
749         query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
750 
751         if (orderByComparator != null) {
752             String[] orderByFields = orderByComparator.getOrderByFields();
753 
754             if (orderByFields.length > 0) {
755                 query.append(WHERE_AND);
756             }
757 
758             for (int i = 0; i < orderByFields.length; i++) {
759                 query.append(_ORDER_BY_ENTITY_ALIAS);
760                 query.append(orderByFields[i]);
761 
762                 if ((i + 1) < orderByFields.length) {
763                     if (orderByComparator.isAscending() ^ previous) {
764                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
765                     }
766                     else {
767                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
768                     }
769                 }
770                 else {
771                     if (orderByComparator.isAscending() ^ previous) {
772                         query.append(WHERE_GREATER_THAN);
773                     }
774                     else {
775                         query.append(WHERE_LESSER_THAN);
776                     }
777                 }
778             }
779 
780             query.append(ORDER_BY_CLAUSE);
781 
782             for (int i = 0; i < orderByFields.length; i++) {
783                 query.append(_ORDER_BY_ENTITY_ALIAS);
784                 query.append(orderByFields[i]);
785 
786                 if ((i + 1) < orderByFields.length) {
787                     if (orderByComparator.isAscending() ^ previous) {
788                         query.append(ORDER_BY_ASC_HAS_NEXT);
789                     }
790                     else {
791                         query.append(ORDER_BY_DESC_HAS_NEXT);
792                     }
793                 }
794                 else {
795                     if (orderByComparator.isAscending() ^ previous) {
796                         query.append(ORDER_BY_ASC);
797                     }
798                     else {
799                         query.append(ORDER_BY_DESC);
800                     }
801                 }
802             }
803         }
804 
805         else {
806             query.append(LayoutModelImpl.ORDER_BY_JPQL);
807         }
808 
809         String sql = query.toString();
810 
811         Query q = session.createQuery(sql);
812 
813         q.setFirstResult(0);
814         q.setMaxResults(2);
815 
816         QueryPos qPos = QueryPos.getInstance(q);
817 
818         qPos.add(groupId);
819 
820         if (orderByComparator != null) {
821             Object[] values = orderByComparator.getOrderByValues(layout);
822 
823             for (Object value : values) {
824                 qPos.add(value);
825             }
826         }
827 
828         List<Layout> list = q.list();
829 
830         if (list.size() == 2) {
831             return list.get(1);
832         }
833         else {
834             return null;
835         }
836     }
837 
838     public List<Layout> findByCompanyId(long companyId)
839         throws SystemException {
840         return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
841             null);
842     }
843 
844     public List<Layout> findByCompanyId(long companyId, int start, int end)
845         throws SystemException {
846         return findByCompanyId(companyId, start, end, null);
847     }
848 
849     public List<Layout> findByCompanyId(long companyId, int start, int end,
850         OrderByComparator orderByComparator) throws SystemException {
851         Object[] finderArgs = new Object[] {
852                 new Long(companyId),
853                 
854                 String.valueOf(start), String.valueOf(end),
855                 String.valueOf(orderByComparator)
856             };
857 
858         List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
859                 finderArgs, this);
860 
861         if (list == null) {
862             Session session = null;
863 
864             try {
865                 session = openSession();
866 
867                 StringBundler query = null;
868 
869                 if (orderByComparator != null) {
870                     query = new StringBundler(3 +
871                             (orderByComparator.getOrderByFields().length * 3));
872                 }
873                 else {
874                     query = new StringBundler(3);
875                 }
876 
877                 query.append(_SQL_SELECT_LAYOUT_WHERE);
878 
879                 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
880 
881                 if (orderByComparator != null) {
882                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
883                         orderByComparator);
884                 }
885 
886                 else {
887                     query.append(LayoutModelImpl.ORDER_BY_JPQL);
888                 }
889 
890                 String sql = query.toString();
891 
892                 Query q = session.createQuery(sql);
893 
894                 QueryPos qPos = QueryPos.getInstance(q);
895 
896                 qPos.add(companyId);
897 
898                 list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
899             }
900             catch (Exception e) {
901                 throw processException(e);
902             }
903             finally {
904                 if (list == null) {
905                     list = new ArrayList<Layout>();
906                 }
907 
908                 cacheResult(list);
909 
910                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
911                     finderArgs, list);
912 
913                 closeSession(session);
914             }
915         }
916 
917         return list;
918     }
919 
920     public Layout findByCompanyId_First(long companyId,
921         OrderByComparator orderByComparator)
922         throws NoSuchLayoutException, SystemException {
923         List<Layout> list = findByCompanyId(companyId, 0, 1, orderByComparator);
924 
925         if (list.isEmpty()) {
926             StringBundler msg = new StringBundler(4);
927 
928             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
929 
930             msg.append("companyId=");
931             msg.append(companyId);
932 
933             msg.append(StringPool.CLOSE_CURLY_BRACE);
934 
935             throw new NoSuchLayoutException(msg.toString());
936         }
937         else {
938             return list.get(0);
939         }
940     }
941 
942     public Layout findByCompanyId_Last(long companyId,
943         OrderByComparator orderByComparator)
944         throws NoSuchLayoutException, SystemException {
945         int count = countByCompanyId(companyId);
946 
947         List<Layout> list = findByCompanyId(companyId, count - 1, count,
948                 orderByComparator);
949 
950         if (list.isEmpty()) {
951             StringBundler msg = new StringBundler(4);
952 
953             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
954 
955             msg.append("companyId=");
956             msg.append(companyId);
957 
958             msg.append(StringPool.CLOSE_CURLY_BRACE);
959 
960             throw new NoSuchLayoutException(msg.toString());
961         }
962         else {
963             return list.get(0);
964         }
965     }
966 
967     public Layout[] findByCompanyId_PrevAndNext(long plid, long companyId,
968         OrderByComparator orderByComparator)
969         throws NoSuchLayoutException, SystemException {
970         Layout layout = findByPrimaryKey(plid);
971 
972         Session session = null;
973 
974         try {
975             session = openSession();
976 
977             Layout[] array = new LayoutImpl[3];
978 
979             array[0] = getByCompanyId_PrevAndNext(session, layout, companyId,
980                     orderByComparator, true);
981 
982             array[1] = layout;
983 
984             array[2] = getByCompanyId_PrevAndNext(session, layout, companyId,
985                     orderByComparator, false);
986 
987             return array;
988         }
989         catch (Exception e) {
990             throw processException(e);
991         }
992         finally {
993             closeSession(session);
994         }
995     }
996 
997     protected Layout getByCompanyId_PrevAndNext(Session session, Layout layout,
998         long companyId, OrderByComparator orderByComparator, boolean previous) {
999         StringBundler query = null;
1000
1001        if (orderByComparator != null) {
1002            query = new StringBundler(6 +
1003                    (orderByComparator.getOrderByFields().length * 6));
1004        }
1005        else {
1006            query = new StringBundler(3);
1007        }
1008
1009        query.append(_SQL_SELECT_LAYOUT_WHERE);
1010
1011        query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1012
1013        if (orderByComparator != null) {
1014            String[] orderByFields = orderByComparator.getOrderByFields();
1015
1016            if (orderByFields.length > 0) {
1017                query.append(WHERE_AND);
1018            }
1019
1020            for (int i = 0; i < orderByFields.length; i++) {
1021                query.append(_ORDER_BY_ENTITY_ALIAS);
1022                query.append(orderByFields[i]);
1023
1024                if ((i + 1) < orderByFields.length) {
1025                    if (orderByComparator.isAscending() ^ previous) {
1026                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1027                    }
1028                    else {
1029                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1030                    }
1031                }
1032                else {
1033                    if (orderByComparator.isAscending() ^ previous) {
1034                        query.append(WHERE_GREATER_THAN);
1035                    }
1036                    else {
1037                        query.append(WHERE_LESSER_THAN);
1038                    }
1039                }
1040            }
1041
1042            query.append(ORDER_BY_CLAUSE);
1043
1044            for (int i = 0; i < orderByFields.length; i++) {
1045                query.append(_ORDER_BY_ENTITY_ALIAS);
1046                query.append(orderByFields[i]);
1047
1048                if ((i + 1) < orderByFields.length) {
1049                    if (orderByComparator.isAscending() ^ previous) {
1050                        query.append(ORDER_BY_ASC_HAS_NEXT);
1051                    }
1052                    else {
1053                        query.append(ORDER_BY_DESC_HAS_NEXT);
1054                    }
1055                }
1056                else {
1057                    if (orderByComparator.isAscending() ^ previous) {
1058                        query.append(ORDER_BY_ASC);
1059                    }
1060                    else {
1061                        query.append(ORDER_BY_DESC);
1062                    }
1063                }
1064            }
1065        }
1066
1067        else {
1068            query.append(LayoutModelImpl.ORDER_BY_JPQL);
1069        }
1070
1071        String sql = query.toString();
1072
1073        Query q = session.createQuery(sql);
1074
1075        q.setFirstResult(0);
1076        q.setMaxResults(2);
1077
1078        QueryPos qPos = QueryPos.getInstance(q);
1079
1080        qPos.add(companyId);
1081
1082        if (orderByComparator != null) {
1083            Object[] values = orderByComparator.getOrderByValues(layout);
1084
1085            for (Object value : values) {
1086                qPos.add(value);
1087            }
1088        }
1089
1090        List<Layout> list = q.list();
1091
1092        if (list.size() == 2) {
1093            return list.get(1);
1094        }
1095        else {
1096            return null;
1097        }
1098    }
1099
1100    public Layout findByDLFolderId(long dlFolderId)
1101        throws NoSuchLayoutException, SystemException {
1102        Layout layout = fetchByDLFolderId(dlFolderId);
1103
1104        if (layout == null) {
1105            StringBundler msg = new StringBundler(4);
1106
1107            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1108
1109            msg.append("dlFolderId=");
1110            msg.append(dlFolderId);
1111
1112            msg.append(StringPool.CLOSE_CURLY_BRACE);
1113
1114            if (_log.isWarnEnabled()) {
1115                _log.warn(msg.toString());
1116            }
1117
1118            throw new NoSuchLayoutException(msg.toString());
1119        }
1120
1121        return layout;
1122    }
1123
1124    public Layout fetchByDLFolderId(long dlFolderId) throws SystemException {
1125        return fetchByDLFolderId(dlFolderId, true);
1126    }
1127
1128    public Layout fetchByDLFolderId(long dlFolderId, boolean retrieveFromCache)
1129        throws SystemException {
1130        Object[] finderArgs = new Object[] { new Long(dlFolderId) };
1131
1132        Object result = null;
1133
1134        if (retrieveFromCache) {
1135            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
1136                    finderArgs, this);
1137        }
1138
1139        if (result == null) {
1140            Session session = null;
1141
1142            try {
1143                session = openSession();
1144
1145                StringBundler query = new StringBundler(3);
1146
1147                query.append(_SQL_SELECT_LAYOUT_WHERE);
1148
1149                query.append(_FINDER_COLUMN_DLFOLDERID_DLFOLDERID_2);
1150
1151                query.append(LayoutModelImpl.ORDER_BY_JPQL);
1152
1153                String sql = query.toString();
1154
1155                Query q = session.createQuery(sql);
1156
1157                QueryPos qPos = QueryPos.getInstance(q);
1158
1159                qPos.add(dlFolderId);
1160
1161                List<Layout> list = q.list();
1162
1163                result = list;
1164
1165                Layout layout = null;
1166
1167                if (list.isEmpty()) {
1168                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
1169                        finderArgs, list);
1170                }
1171                else {
1172                    layout = list.get(0);
1173
1174                    cacheResult(layout);
1175
1176                    if ((layout.getDlFolderId() != dlFolderId)) {
1177                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
1178                            finderArgs, layout);
1179                    }
1180                }
1181
1182                return layout;
1183            }
1184            catch (Exception e) {
1185                throw processException(e);
1186            }
1187            finally {
1188                if (result == null) {
1189                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
1190                        finderArgs, new ArrayList<Layout>());
1191                }
1192
1193                closeSession(session);
1194            }
1195        }
1196        else {
1197            if (result instanceof List<?>) {
1198                return null;
1199            }
1200            else {
1201                return (Layout)result;
1202            }
1203        }
1204    }
1205
1206    public Layout findByIconImageId(long iconImageId)
1207        throws NoSuchLayoutException, SystemException {
1208        Layout layout = fetchByIconImageId(iconImageId);
1209
1210        if (layout == null) {
1211            StringBundler msg = new StringBundler(4);
1212
1213            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1214
1215            msg.append("iconImageId=");
1216            msg.append(iconImageId);
1217
1218            msg.append(StringPool.CLOSE_CURLY_BRACE);
1219
1220            if (_log.isWarnEnabled()) {
1221                _log.warn(msg.toString());
1222            }
1223
1224            throw new NoSuchLayoutException(msg.toString());
1225        }
1226
1227        return layout;
1228    }
1229
1230    public Layout fetchByIconImageId(long iconImageId)
1231        throws SystemException {
1232        return fetchByIconImageId(iconImageId, true);
1233    }
1234
1235    public Layout fetchByIconImageId(long iconImageId, boolean retrieveFromCache)
1236        throws SystemException {
1237        Object[] finderArgs = new Object[] { new Long(iconImageId) };
1238
1239        Object result = null;
1240
1241        if (retrieveFromCache) {
1242            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
1243                    finderArgs, this);
1244        }
1245
1246        if (result == null) {
1247            Session session = null;
1248
1249            try {
1250                session = openSession();
1251
1252                StringBundler query = new StringBundler(3);
1253
1254                query.append(_SQL_SELECT_LAYOUT_WHERE);
1255
1256                query.append(_FINDER_COLUMN_ICONIMAGEID_ICONIMAGEID_2);
1257
1258                query.append(LayoutModelImpl.ORDER_BY_JPQL);
1259
1260                String sql = query.toString();
1261
1262                Query q = session.createQuery(sql);
1263
1264                QueryPos qPos = QueryPos.getInstance(q);
1265
1266                qPos.add(iconImageId);
1267
1268                List<Layout> list = q.list();
1269
1270                result = list;
1271
1272                Layout layout = null;
1273
1274                if (list.isEmpty()) {
1275                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
1276                        finderArgs, list);
1277                }
1278                else {
1279                    layout = list.get(0);
1280
1281                    cacheResult(layout);
1282
1283                    if ((layout.getIconImageId() != iconImageId)) {
1284                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
1285                            finderArgs, layout);
1286                    }
1287                }
1288
1289                return layout;
1290            }
1291            catch (Exception e) {
1292                throw processException(e);
1293            }
1294            finally {
1295                if (result == null) {
1296                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
1297                        finderArgs, new ArrayList<Layout>());
1298                }
1299
1300                closeSession(session);
1301            }
1302        }
1303        else {
1304            if (result instanceof List<?>) {
1305                return null;
1306            }
1307            else {
1308                return (Layout)result;
1309            }
1310        }
1311    }
1312
1313    public List<Layout> findByG_P(long groupId, boolean privateLayout)
1314        throws SystemException {
1315        return findByG_P(groupId, privateLayout, QueryUtil.ALL_POS,
1316            QueryUtil.ALL_POS, null);
1317    }
1318
1319    public List<Layout> findByG_P(long groupId, boolean privateLayout,
1320        int start, int end) throws SystemException {
1321        return findByG_P(groupId, privateLayout, start, end, null);
1322    }
1323
1324    public List<Layout> findByG_P(long groupId, boolean privateLayout,
1325        int start, int end, OrderByComparator orderByComparator)
1326        throws SystemException {
1327        Object[] finderArgs = new Object[] {
1328                new Long(groupId), Boolean.valueOf(privateLayout),
1329                
1330                String.valueOf(start), String.valueOf(end),
1331                String.valueOf(orderByComparator)
1332            };
1333
1334        List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_P,
1335                finderArgs, this);
1336
1337        if (list == null) {
1338            Session session = null;
1339
1340            try {
1341                session = openSession();
1342
1343                StringBundler query = null;
1344
1345                if (orderByComparator != null) {
1346                    query = new StringBundler(4 +
1347                            (orderByComparator.getOrderByFields().length * 3));
1348                }
1349                else {
1350                    query = new StringBundler(4);
1351                }
1352
1353                query.append(_SQL_SELECT_LAYOUT_WHERE);
1354
1355                query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1356
1357                query.append(_FINDER_COLUMN_G_P_PRIVATELAYOUT_2);
1358
1359                if (orderByComparator != null) {
1360                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1361                        orderByComparator);
1362                }
1363
1364                else {
1365                    query.append(LayoutModelImpl.ORDER_BY_JPQL);
1366                }
1367
1368                String sql = query.toString();
1369
1370                Query q = session.createQuery(sql);
1371
1372                QueryPos qPos = QueryPos.getInstance(q);
1373
1374                qPos.add(groupId);
1375
1376                qPos.add(privateLayout);
1377
1378                list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
1379            }
1380            catch (Exception e) {
1381                throw processException(e);
1382            }
1383            finally {
1384                if (list == null) {
1385                    list = new ArrayList<Layout>();
1386                }
1387
1388                cacheResult(list);
1389
1390                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_P, finderArgs,
1391                    list);
1392
1393                closeSession(session);
1394            }
1395        }
1396
1397        return list;
1398    }
1399
1400    public Layout findByG_P_First(long groupId, boolean privateLayout,
1401        OrderByComparator orderByComparator)
1402        throws NoSuchLayoutException, SystemException {
1403        List<Layout> list = findByG_P(groupId, privateLayout, 0, 1,
1404                orderByComparator);
1405
1406        if (list.isEmpty()) {
1407            StringBundler msg = new StringBundler(6);
1408
1409            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1410
1411            msg.append("groupId=");
1412            msg.append(groupId);
1413
1414            msg.append(", privateLayout=");
1415            msg.append(privateLayout);
1416
1417            msg.append(StringPool.CLOSE_CURLY_BRACE);
1418
1419            throw new NoSuchLayoutException(msg.toString());
1420        }
1421        else {
1422            return list.get(0);
1423        }
1424    }
1425
1426    public Layout findByG_P_Last(long groupId, boolean privateLayout,
1427        OrderByComparator orderByComparator)
1428        throws NoSuchLayoutException, SystemException {
1429        int count = countByG_P(groupId, privateLayout);
1430
1431        List<Layout> list = findByG_P(groupId, privateLayout, count - 1, count,
1432                orderByComparator);
1433
1434        if (list.isEmpty()) {
1435            StringBundler msg = new StringBundler(6);
1436
1437            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1438
1439            msg.append("groupId=");
1440            msg.append(groupId);
1441
1442            msg.append(", privateLayout=");
1443            msg.append(privateLayout);
1444
1445            msg.append(StringPool.CLOSE_CURLY_BRACE);
1446
1447            throw new NoSuchLayoutException(msg.toString());
1448        }
1449        else {
1450            return list.get(0);
1451        }
1452    }
1453
1454    public Layout[] findByG_P_PrevAndNext(long plid, long groupId,
1455        boolean privateLayout, OrderByComparator orderByComparator)
1456        throws NoSuchLayoutException, SystemException {
1457        Layout layout = findByPrimaryKey(plid);
1458
1459        Session session = null;
1460
1461        try {
1462            session = openSession();
1463
1464            Layout[] array = new LayoutImpl[3];
1465
1466            array[0] = getByG_P_PrevAndNext(session, layout, groupId,
1467                    privateLayout, orderByComparator, true);
1468
1469            array[1] = layout;
1470
1471            array[2] = getByG_P_PrevAndNext(session, layout, groupId,
1472                    privateLayout, orderByComparator, false);
1473
1474            return array;
1475        }
1476        catch (Exception e) {
1477            throw processException(e);
1478        }
1479        finally {
1480            closeSession(session);
1481        }
1482    }
1483
1484    protected Layout getByG_P_PrevAndNext(Session session, Layout layout,
1485        long groupId, boolean privateLayout,
1486        OrderByComparator orderByComparator, boolean previous) {
1487        StringBundler query = null;
1488
1489        if (orderByComparator != null) {
1490            query = new StringBundler(6 +
1491                    (orderByComparator.getOrderByFields().length * 6));
1492        }
1493        else {
1494            query = new StringBundler(3);
1495        }
1496
1497        query.append(_SQL_SELECT_LAYOUT_WHERE);
1498
1499        query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1500
1501        query.append(_FINDER_COLUMN_G_P_PRIVATELAYOUT_2);
1502
1503        if (orderByComparator != null) {
1504            String[] orderByFields = orderByComparator.getOrderByFields();
1505
1506            if (orderByFields.length > 0) {
1507                query.append(WHERE_AND);
1508            }
1509
1510            for (int i = 0; i < orderByFields.length; i++) {
1511                query.append(_ORDER_BY_ENTITY_ALIAS);
1512                query.append(orderByFields[i]);
1513
1514                if ((i + 1) < orderByFields.length) {
1515                    if (orderByComparator.isAscending() ^ previous) {
1516                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1517                    }
1518                    else {
1519                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1520                    }
1521                }
1522                else {
1523                    if (orderByComparator.isAscending() ^ previous) {
1524                        query.append(WHERE_GREATER_THAN);
1525                    }
1526                    else {
1527                        query.append(WHERE_LESSER_THAN);
1528                    }
1529                }
1530            }
1531
1532            query.append(ORDER_BY_CLAUSE);
1533
1534            for (int i = 0; i < orderByFields.length; i++) {
1535                query.append(_ORDER_BY_ENTITY_ALIAS);
1536                query.append(orderByFields[i]);
1537
1538                if ((i + 1) < orderByFields.length) {
1539                    if (orderByComparator.isAscending() ^ previous) {
1540                        query.append(ORDER_BY_ASC_HAS_NEXT);
1541                    }
1542                    else {
1543                        query.append(ORDER_BY_DESC_HAS_NEXT);
1544                    }
1545                }
1546                else {
1547                    if (orderByComparator.isAscending() ^ previous) {
1548                        query.append(ORDER_BY_ASC);
1549                    }
1550                    else {
1551                        query.append(ORDER_BY_DESC);
1552                    }
1553                }
1554            }
1555        }
1556
1557        else {
1558            query.append(LayoutModelImpl.ORDER_BY_JPQL);
1559        }
1560
1561        String sql = query.toString();
1562
1563        Query q = session.createQuery(sql);
1564
1565        q.setFirstResult(0);
1566        q.setMaxResults(2);
1567
1568        QueryPos qPos = QueryPos.getInstance(q);
1569
1570        qPos.add(groupId);
1571
1572        qPos.add(privateLayout);
1573
1574        if (orderByComparator != null) {
1575            Object[] values = orderByComparator.getOrderByValues(layout);
1576
1577            for (Object value : values) {
1578                qPos.add(value);
1579            }
1580        }
1581
1582        List<Layout> list = q.list();
1583
1584        if (list.size() == 2) {
1585            return list.get(1);
1586        }
1587        else {
1588            return null;
1589        }
1590    }
1591
1592    public Layout findByG_P_L(long groupId, boolean privateLayout, long layoutId)
1593        throws NoSuchLayoutException, SystemException {
1594        Layout layout = fetchByG_P_L(groupId, privateLayout, layoutId);
1595
1596        if (layout == null) {
1597            StringBundler msg = new StringBundler(8);
1598
1599            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1600
1601            msg.append("groupId=");
1602            msg.append(groupId);
1603
1604            msg.append(", privateLayout=");
1605            msg.append(privateLayout);
1606
1607            msg.append(", layoutId=");
1608            msg.append(layoutId);
1609
1610            msg.append(StringPool.CLOSE_CURLY_BRACE);
1611
1612            if (_log.isWarnEnabled()) {
1613                _log.warn(msg.toString());
1614            }
1615
1616            throw new NoSuchLayoutException(msg.toString());
1617        }
1618
1619        return layout;
1620    }
1621
1622    public Layout fetchByG_P_L(long groupId, boolean privateLayout,
1623        long layoutId) throws SystemException {
1624        return fetchByG_P_L(groupId, privateLayout, layoutId, true);
1625    }
1626
1627    public Layout fetchByG_P_L(long groupId, boolean privateLayout,
1628        long layoutId, boolean retrieveFromCache) throws SystemException {
1629        Object[] finderArgs = new Object[] {
1630                new Long(groupId), Boolean.valueOf(privateLayout),
1631                new Long(layoutId)
1632            };
1633
1634        Object result = null;
1635
1636        if (retrieveFromCache) {
1637            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_P_L,
1638                    finderArgs, this);
1639        }
1640
1641        if (result == null) {
1642            Session session = null;
1643
1644            try {
1645                session = openSession();
1646
1647                StringBundler query = new StringBundler(5);
1648
1649                query.append(_SQL_SELECT_LAYOUT_WHERE);
1650
1651                query.append(_FINDER_COLUMN_G_P_L_GROUPID_2);
1652
1653                query.append(_FINDER_COLUMN_G_P_L_PRIVATELAYOUT_2);
1654
1655                query.append(_FINDER_COLUMN_G_P_L_LAYOUTID_2);
1656
1657                query.append(LayoutModelImpl.ORDER_BY_JPQL);
1658
1659                String sql = query.toString();
1660
1661                Query q = session.createQuery(sql);
1662
1663                QueryPos qPos = QueryPos.getInstance(q);
1664
1665                qPos.add(groupId);
1666
1667                qPos.add(privateLayout);
1668
1669                qPos.add(layoutId);
1670
1671                List<Layout> list = q.list();
1672
1673                result = list;
1674
1675                Layout layout = null;
1676
1677                if (list.isEmpty()) {
1678                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_L,
1679                        finderArgs, list);
1680                }
1681                else {
1682                    layout = list.get(0);
1683
1684                    cacheResult(layout);
1685
1686                    if ((layout.getGroupId() != groupId) ||
1687                            (layout.getPrivateLayout() != privateLayout) ||
1688                            (layout.getLayoutId() != layoutId)) {
1689                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_L,
1690                            finderArgs, layout);
1691                    }
1692                }
1693
1694                return layout;
1695            }
1696            catch (Exception e) {
1697                throw processException(e);
1698            }
1699            finally {
1700                if (result == null) {
1701                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_L,
1702                        finderArgs, new ArrayList<Layout>());
1703                }
1704
1705                closeSession(session);
1706            }
1707        }
1708        else {
1709            if (result instanceof List<?>) {
1710                return null;
1711            }
1712            else {
1713                return (Layout)result;
1714            }
1715        }
1716    }
1717
1718    public List<Layout> findByG_P_P(long groupId, boolean privateLayout,
1719        long parentLayoutId) throws SystemException {
1720        return findByG_P_P(groupId, privateLayout, parentLayoutId,
1721            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1722    }
1723
1724    public List<Layout> findByG_P_P(long groupId, boolean privateLayout,
1725        long parentLayoutId, int start, int end) throws SystemException {
1726        return findByG_P_P(groupId, privateLayout, parentLayoutId, start, end,
1727            null);
1728    }
1729
1730    public List<Layout> findByG_P_P(long groupId, boolean privateLayout,
1731        long parentLayoutId, int start, int end,
1732        OrderByComparator orderByComparator) throws SystemException {
1733        Object[] finderArgs = new Object[] {
1734                new Long(groupId), Boolean.valueOf(privateLayout),
1735                new Long(parentLayoutId),
1736                
1737                String.valueOf(start), String.valueOf(end),
1738                String.valueOf(orderByComparator)
1739            };
1740
1741        List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_P_P,
1742                finderArgs, this);
1743
1744        if (list == null) {
1745            Session session = null;
1746
1747            try {
1748                session = openSession();
1749
1750                StringBundler query = null;
1751
1752                if (orderByComparator != null) {
1753                    query = new StringBundler(5 +
1754                            (orderByComparator.getOrderByFields().length * 3));
1755                }
1756                else {
1757                    query = new StringBundler(5);
1758                }
1759
1760                query.append(_SQL_SELECT_LAYOUT_WHERE);
1761
1762                query.append(_FINDER_COLUMN_G_P_P_GROUPID_2);
1763
1764                query.append(_FINDER_COLUMN_G_P_P_PRIVATELAYOUT_2);
1765
1766                query.append(_FINDER_COLUMN_G_P_P_PARENTLAYOUTID_2);
1767
1768                if (orderByComparator != null) {
1769                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1770                        orderByComparator);
1771                }
1772
1773                else {
1774                    query.append(LayoutModelImpl.ORDER_BY_JPQL);
1775                }
1776
1777                String sql = query.toString();
1778
1779                Query q = session.createQuery(sql);
1780
1781                QueryPos qPos = QueryPos.getInstance(q);
1782
1783                qPos.add(groupId);
1784
1785                qPos.add(privateLayout);
1786
1787                qPos.add(parentLayoutId);
1788
1789                list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
1790            }
1791            catch (Exception e) {
1792                throw processException(e);
1793            }
1794            finally {
1795                if (list == null) {
1796                    list = new ArrayList<Layout>();
1797                }
1798
1799                cacheResult(list);
1800
1801                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_P_P,
1802                    finderArgs, list);
1803
1804                closeSession(session);
1805            }
1806        }
1807
1808        return list;
1809    }
1810
1811    public Layout findByG_P_P_First(long groupId, boolean privateLayout,
1812        long parentLayoutId, OrderByComparator orderByComparator)
1813        throws NoSuchLayoutException, SystemException {
1814        List<Layout> list = findByG_P_P(groupId, privateLayout, parentLayoutId,
1815                0, 1, orderByComparator);
1816
1817        if (list.isEmpty()) {
1818            StringBundler msg = new StringBundler(8);
1819
1820            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1821
1822            msg.append("groupId=");
1823            msg.append(groupId);
1824
1825            msg.append(", privateLayout=");
1826            msg.append(privateLayout);
1827
1828            msg.append(", parentLayoutId=");
1829            msg.append(parentLayoutId);
1830
1831            msg.append(StringPool.CLOSE_CURLY_BRACE);
1832
1833            throw new NoSuchLayoutException(msg.toString());
1834        }
1835        else {
1836            return list.get(0);
1837        }
1838    }
1839
1840    public Layout findByG_P_P_Last(long groupId, boolean privateLayout,
1841        long parentLayoutId, OrderByComparator orderByComparator)
1842        throws NoSuchLayoutException, SystemException {
1843        int count = countByG_P_P(groupId, privateLayout, parentLayoutId);
1844
1845        List<Layout> list = findByG_P_P(groupId, privateLayout, parentLayoutId,
1846                count - 1, count, orderByComparator);
1847
1848        if (list.isEmpty()) {
1849            StringBundler msg = new StringBundler(8);
1850
1851            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1852
1853            msg.append("groupId=");
1854            msg.append(groupId);
1855
1856            msg.append(", privateLayout=");
1857            msg.append(privateLayout);
1858
1859            msg.append(", parentLayoutId=");
1860            msg.append(parentLayoutId);
1861
1862            msg.append(StringPool.CLOSE_CURLY_BRACE);
1863
1864            throw new NoSuchLayoutException(msg.toString());
1865        }
1866        else {
1867            return list.get(0);
1868        }
1869    }
1870
1871    public Layout[] findByG_P_P_PrevAndNext(long plid, long groupId,
1872        boolean privateLayout, long parentLayoutId,
1873        OrderByComparator orderByComparator)
1874        throws NoSuchLayoutException, SystemException {
1875        Layout layout = findByPrimaryKey(plid);
1876
1877        Session session = null;
1878
1879        try {
1880            session = openSession();
1881
1882            Layout[] array = new LayoutImpl[3];
1883
1884            array[0] = getByG_P_P_PrevAndNext(session, layout, groupId,
1885                    privateLayout, parentLayoutId, orderByComparator, true);
1886
1887            array[1] = layout;
1888
1889            array[2] = getByG_P_P_PrevAndNext(session, layout, groupId,
1890                    privateLayout, parentLayoutId, orderByComparator, false);
1891
1892            return array;
1893        }
1894        catch (Exception e) {
1895            throw processException(e);
1896        }
1897        finally {
1898            closeSession(session);
1899        }
1900    }
1901
1902    protected Layout getByG_P_P_PrevAndNext(Session session, Layout layout,
1903        long groupId, boolean privateLayout, long parentLayoutId,
1904        OrderByComparator orderByComparator, boolean previous) {
1905        StringBundler query = null;
1906
1907        if (orderByComparator != null) {
1908            query = new StringBundler(6 +
1909                    (orderByComparator.getOrderByFields().length * 6));
1910        }
1911        else {
1912            query = new StringBundler(3);
1913        }
1914
1915        query.append(_SQL_SELECT_LAYOUT_WHERE);
1916
1917        query.append(_FINDER_COLUMN_G_P_P_GROUPID_2);
1918
1919        query.append(_FINDER_COLUMN_G_P_P_PRIVATELAYOUT_2);
1920
1921        query.append(_FINDER_COLUMN_G_P_P_PARENTLAYOUTID_2);
1922
1923        if (orderByComparator != null) {
1924            String[] orderByFields = orderByComparator.getOrderByFields();
1925
1926            if (orderByFields.length > 0) {
1927                query.append(WHERE_AND);
1928            }
1929
1930            for (int i = 0; i < orderByFields.length; i++) {
1931                query.append(_ORDER_BY_ENTITY_ALIAS);
1932                query.append(orderByFields[i]);
1933
1934                if ((i + 1) < orderByFields.length) {
1935                    if (orderByComparator.isAscending() ^ previous) {
1936                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1937                    }
1938                    else {
1939                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1940                    }
1941                }
1942                else {
1943                    if (orderByComparator.isAscending() ^ previous) {
1944                        query.append(WHERE_GREATER_THAN);
1945                    }
1946                    else {
1947                        query.append(WHERE_LESSER_THAN);
1948                    }
1949                }
1950            }
1951
1952            query.append(ORDER_BY_CLAUSE);
1953
1954            for (int i = 0; i < orderByFields.length; i++) {
1955                query.append(_ORDER_BY_ENTITY_ALIAS);
1956                query.append(orderByFields[i]);
1957
1958                if ((i + 1) < orderByFields.length) {
1959                    if (orderByComparator.isAscending() ^ previous) {
1960                        query.append(ORDER_BY_ASC_HAS_NEXT);
1961                    }
1962                    else {
1963                        query.append(ORDER_BY_DESC_HAS_NEXT);
1964                    }
1965                }
1966                else {
1967                    if (orderByComparator.isAscending() ^ previous) {
1968                        query.append(ORDER_BY_ASC);
1969                    }
1970                    else {
1971                        query.append(ORDER_BY_DESC);
1972                    }
1973                }
1974            }
1975        }
1976
1977        else {
1978            query.append(LayoutModelImpl.ORDER_BY_JPQL);
1979        }
1980
1981        String sql = query.toString();
1982
1983        Query q = session.createQuery(sql);
1984
1985        q.setFirstResult(0);
1986        q.setMaxResults(2);
1987
1988        QueryPos qPos = QueryPos.getInstance(q);
1989
1990        qPos.add(groupId);
1991
1992        qPos.add(privateLayout);
1993
1994        qPos.add(parentLayoutId);
1995
1996        if (orderByComparator != null) {
1997            Object[] values = orderByComparator.getOrderByValues(layout);
1998
1999            for (Object value : values) {
2000                qPos.add(value);
2001            }
2002        }
2003
2004        List<Layout> list = q.list();
2005
2006        if (list.size() == 2) {
2007            return list.get(1);
2008        }
2009        else {
2010            return null;
2011        }
2012    }
2013
2014    public Layout findByG_P_F(long groupId, boolean privateLayout,
2015        String friendlyURL) throws NoSuchLayoutException, SystemException {
2016        Layout layout = fetchByG_P_F(groupId, privateLayout, friendlyURL);
2017
2018        if (layout == null) {
2019            StringBundler msg = new StringBundler(8);
2020
2021            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2022
2023            msg.append("groupId=");
2024            msg.append(groupId);
2025
2026            msg.append(", privateLayout=");
2027            msg.append(privateLayout);
2028
2029            msg.append(", friendlyURL=");
2030            msg.append(friendlyURL);
2031
2032            msg.append(StringPool.CLOSE_CURLY_BRACE);
2033
2034            if (_log.isWarnEnabled()) {
2035                _log.warn(msg.toString());
2036            }
2037
2038            throw new NoSuchLayoutException(msg.toString());
2039        }
2040
2041        return layout;
2042    }
2043
2044    public Layout fetchByG_P_F(long groupId, boolean privateLayout,
2045        String friendlyURL) throws SystemException {
2046        return fetchByG_P_F(groupId, privateLayout, friendlyURL, true);
2047    }
2048
2049    public Layout fetchByG_P_F(long groupId, boolean privateLayout,
2050        String friendlyURL, boolean retrieveFromCache)
2051        throws SystemException {
2052        Object[] finderArgs = new Object[] {
2053                new Long(groupId), Boolean.valueOf(privateLayout),
2054                
2055                friendlyURL
2056            };
2057
2058        Object result = null;
2059
2060        if (retrieveFromCache) {
2061            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_P_F,
2062                    finderArgs, this);
2063        }
2064
2065        if (result == null) {
2066            Session session = null;
2067
2068            try {
2069                session = openSession();
2070
2071                StringBundler query = new StringBundler(5);
2072
2073                query.append(_SQL_SELECT_LAYOUT_WHERE);
2074
2075                query.append(_FINDER_COLUMN_G_P_F_GROUPID_2);
2076
2077                query.append(_FINDER_COLUMN_G_P_F_PRIVATELAYOUT_2);
2078
2079                if (friendlyURL == null) {
2080                    query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_1);
2081                }
2082                else {
2083                    if (friendlyURL.equals(StringPool.BLANK)) {
2084                        query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_3);
2085                    }
2086                    else {
2087                        query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_2);
2088                    }
2089                }
2090
2091                query.append(LayoutModelImpl.ORDER_BY_JPQL);
2092
2093                String sql = query.toString();
2094
2095                Query q = session.createQuery(sql);
2096
2097                QueryPos qPos = QueryPos.getInstance(q);
2098
2099                qPos.add(groupId);
2100
2101                qPos.add(privateLayout);
2102
2103                if (friendlyURL != null) {
2104                    qPos.add(friendlyURL);
2105                }
2106
2107                List<Layout> list = q.list();
2108
2109                result = list;
2110
2111                Layout layout = null;
2112
2113                if (list.isEmpty()) {
2114                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_F,
2115                        finderArgs, list);
2116                }
2117                else {
2118                    layout = list.get(0);
2119
2120                    cacheResult(layout);
2121
2122                    if ((layout.getGroupId() != groupId) ||
2123                            (layout.getPrivateLayout() != privateLayout) ||
2124                            (layout.getFriendlyURL() == null) ||
2125                            !layout.getFriendlyURL().equals(friendlyURL)) {
2126                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_F,
2127                            finderArgs, layout);
2128                    }
2129                }
2130
2131                return layout;
2132            }
2133            catch (Exception e) {
2134                throw processException(e);
2135            }
2136            finally {
2137                if (result == null) {
2138                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_F,
2139                        finderArgs, new ArrayList<Layout>());
2140                }
2141
2142                closeSession(session);
2143            }
2144        }
2145        else {
2146            if (result instanceof List<?>) {
2147                return null;
2148            }
2149            else {
2150                return (Layout)result;
2151            }
2152        }
2153    }
2154
2155    public List<Layout> findByG_P_T(long groupId, boolean privateLayout,
2156        String type) throws SystemException {
2157        return findByG_P_T(groupId, privateLayout, type, QueryUtil.ALL_POS,
2158            QueryUtil.ALL_POS, null);
2159    }
2160
2161    public List<Layout> findByG_P_T(long groupId, boolean privateLayout,
2162        String type, int start, int end) throws SystemException {
2163        return findByG_P_T(groupId, privateLayout, type, start, end, null);
2164    }
2165
2166    public List<Layout> findByG_P_T(long groupId, boolean privateLayout,
2167        String type, int start, int end, OrderByComparator orderByComparator)
2168        throws SystemException {
2169        Object[] finderArgs = new Object[] {
2170                new Long(groupId), Boolean.valueOf(privateLayout),
2171                
2172                type,
2173                
2174                String.valueOf(start), String.valueOf(end),
2175                String.valueOf(orderByComparator)
2176            };
2177
2178        List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_P_T,
2179                finderArgs, this);
2180
2181        if (list == null) {
2182            Session session = null;
2183
2184            try {
2185                session = openSession();
2186
2187                StringBundler query = null;
2188
2189                if (orderByComparator != null) {
2190                    query = new StringBundler(5 +
2191                            (orderByComparator.getOrderByFields().length * 3));
2192                }
2193                else {
2194                    query = new StringBundler(5);
2195                }
2196
2197                query.append(_SQL_SELECT_LAYOUT_WHERE);
2198
2199                query.append(_FINDER_COLUMN_G_P_T_GROUPID_2);
2200
2201                query.append(_FINDER_COLUMN_G_P_T_PRIVATELAYOUT_2);
2202
2203                if (type == null) {
2204                    query.append(_FINDER_COLUMN_G_P_T_TYPE_1);
2205                }
2206                else {
2207                    if (type.equals(StringPool.BLANK)) {
2208                        query.append(_FINDER_COLUMN_G_P_T_TYPE_3);
2209                    }
2210                    else {
2211                        query.append(_FINDER_COLUMN_G_P_T_TYPE_2);
2212                    }
2213                }
2214
2215                if (orderByComparator != null) {
2216                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2217                        orderByComparator);
2218                }
2219
2220                else {
2221                    query.append(LayoutModelImpl.ORDER_BY_JPQL);
2222                }
2223
2224                String sql = query.toString();
2225
2226                Query q = session.createQuery(sql);
2227
2228                QueryPos qPos = QueryPos.getInstance(q);
2229
2230                qPos.add(groupId);
2231
2232                qPos.add(privateLayout);
2233
2234                if (type != null) {
2235                    qPos.add(type);
2236                }
2237
2238                list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
2239            }
2240            catch (Exception e) {
2241                throw processException(e);
2242            }
2243            finally {
2244                if (list == null) {
2245                    list = new ArrayList<Layout>();
2246                }
2247
2248                cacheResult(list);
2249
2250                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_P_T,
2251                    finderArgs, list);
2252
2253                closeSession(session);
2254            }
2255        }
2256
2257        return list;
2258    }
2259
2260    public Layout findByG_P_T_First(long groupId, boolean privateLayout,
2261        String type, OrderByComparator orderByComparator)
2262        throws NoSuchLayoutException, SystemException {
2263        List<Layout> list = findByG_P_T(groupId, privateLayout, type, 0, 1,
2264                orderByComparator);
2265
2266        if (list.isEmpty()) {
2267            StringBundler msg = new StringBundler(8);
2268
2269            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2270
2271            msg.append("groupId=");
2272            msg.append(groupId);
2273
2274            msg.append(", privateLayout=");
2275            msg.append(privateLayout);
2276
2277            msg.append(", type=");
2278            msg.append(type);
2279
2280            msg.append(StringPool.CLOSE_CURLY_BRACE);
2281
2282            throw new NoSuchLayoutException(msg.toString());
2283        }
2284        else {
2285            return list.get(0);
2286        }
2287    }
2288
2289    public Layout findByG_P_T_Last(long groupId, boolean privateLayout,
2290        String type, OrderByComparator orderByComparator)
2291        throws NoSuchLayoutException, SystemException {
2292        int count = countByG_P_T(groupId, privateLayout, type);
2293
2294        List<Layout> list = findByG_P_T(groupId, privateLayout, type,
2295                count - 1, count, orderByComparator);
2296
2297        if (list.isEmpty()) {
2298            StringBundler msg = new StringBundler(8);
2299
2300            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2301
2302            msg.append("groupId=");
2303            msg.append(groupId);
2304
2305            msg.append(", privateLayout=");
2306            msg.append(privateLayout);
2307
2308            msg.append(", type=");
2309            msg.append(type);
2310
2311            msg.append(StringPool.CLOSE_CURLY_BRACE);
2312
2313            throw new NoSuchLayoutException(msg.toString());
2314        }
2315        else {
2316            return list.get(0);
2317        }
2318    }
2319
2320    public Layout[] findByG_P_T_PrevAndNext(long plid, long groupId,
2321        boolean privateLayout, String type, OrderByComparator orderByComparator)
2322        throws NoSuchLayoutException, SystemException {
2323        Layout layout = findByPrimaryKey(plid);
2324
2325        Session session = null;
2326
2327        try {
2328            session = openSession();
2329
2330            Layout[] array = new LayoutImpl[3];
2331
2332            array[0] = getByG_P_T_PrevAndNext(session, layout, groupId,
2333                    privateLayout, type, orderByComparator, true);
2334
2335            array[1] = layout;
2336
2337            array[2] = getByG_P_T_PrevAndNext(session, layout, groupId,
2338                    privateLayout, type, orderByComparator, false);
2339
2340            return array;
2341        }
2342        catch (Exception e) {
2343            throw processException(e);
2344        }
2345        finally {
2346            closeSession(session);
2347        }
2348    }
2349
2350    protected Layout getByG_P_T_PrevAndNext(Session session, Layout layout,
2351        long groupId, boolean privateLayout, String type,
2352        OrderByComparator orderByComparator, boolean previous) {
2353        StringBundler query = null;
2354
2355        if (orderByComparator != null) {
2356            query = new StringBundler(6 +
2357                    (orderByComparator.getOrderByFields().length * 6));
2358        }
2359        else {
2360            query = new StringBundler(3);
2361        }
2362
2363        query.append(_SQL_SELECT_LAYOUT_WHERE);
2364
2365        query.append(_FINDER_COLUMN_G_P_T_GROUPID_2);
2366
2367        query.append(_FINDER_COLUMN_G_P_T_PRIVATELAYOUT_2);
2368
2369        if (type == null) {
2370            query.append(_FINDER_COLUMN_G_P_T_TYPE_1);
2371        }
2372        else {
2373            if (type.equals(StringPool.BLANK)) {
2374                query.append(_FINDER_COLUMN_G_P_T_TYPE_3);
2375            }
2376            else {
2377                query.append(_FINDER_COLUMN_G_P_T_TYPE_2);
2378            }
2379        }
2380
2381        if (orderByComparator != null) {
2382            String[] orderByFields = orderByComparator.getOrderByFields();
2383
2384            if (orderByFields.length > 0) {
2385                query.append(WHERE_AND);
2386            }
2387
2388            for (int i = 0; i < orderByFields.length; i++) {
2389                query.append(_ORDER_BY_ENTITY_ALIAS);
2390                query.append(orderByFields[i]);
2391
2392                if ((i + 1) < orderByFields.length) {
2393                    if (orderByComparator.isAscending() ^ previous) {
2394                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
2395                    }
2396                    else {
2397                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
2398                    }
2399                }
2400                else {
2401                    if (orderByComparator.isAscending() ^ previous) {
2402                        query.append(WHERE_GREATER_THAN);
2403                    }
2404                    else {
2405                        query.append(WHERE_LESSER_THAN);
2406                    }
2407                }
2408            }
2409
2410            query.append(ORDER_BY_CLAUSE);
2411
2412            for (int i = 0; i < orderByFields.length; i++) {
2413                query.append(_ORDER_BY_ENTITY_ALIAS);
2414                query.append(orderByFields[i]);
2415
2416                if ((i + 1) < orderByFields.length) {
2417                    if (orderByComparator.isAscending() ^ previous) {
2418                        query.append(ORDER_BY_ASC_HAS_NEXT);
2419                    }
2420                    else {
2421                        query.append(ORDER_BY_DESC_HAS_NEXT);
2422                    }
2423                }
2424                else {
2425                    if (orderByComparator.isAscending() ^ previous) {
2426                        query.append(ORDER_BY_ASC);
2427                    }
2428                    else {
2429                        query.append(ORDER_BY_DESC);
2430                    }
2431                }
2432            }
2433        }
2434
2435        else {
2436            query.append(LayoutModelImpl.ORDER_BY_JPQL);
2437        }
2438
2439        String sql = query.toString();
2440
2441        Query q = session.createQuery(sql);
2442
2443        q.setFirstResult(0);
2444        q.setMaxResults(2);
2445
2446        QueryPos qPos = QueryPos.getInstance(q);
2447
2448        qPos.add(groupId);
2449
2450        qPos.add(privateLayout);
2451
2452        if (type != null) {
2453            qPos.add(type);
2454        }
2455
2456        if (orderByComparator != null) {
2457            Object[] values = orderByComparator.getOrderByValues(layout);
2458
2459            for (Object value : values) {
2460                qPos.add(value);
2461            }
2462        }
2463
2464        List<Layout> list = q.list();
2465
2466        if (list.size() == 2) {
2467            return list.get(1);
2468        }
2469        else {
2470            return null;
2471        }
2472    }
2473
2474    public List<Layout> findAll() throws SystemException {
2475        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2476    }
2477
2478    public List<Layout> findAll(int start, int end) throws SystemException {
2479        return findAll(start, end, null);
2480    }
2481
2482    public List<Layout> findAll(int start, int end,
2483        OrderByComparator orderByComparator) throws SystemException {
2484        Object[] finderArgs = new Object[] {
2485                String.valueOf(start), String.valueOf(end),
2486                String.valueOf(orderByComparator)
2487            };
2488
2489        List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
2490                finderArgs, this);
2491
2492        if (list == null) {
2493            Session session = null;
2494
2495            try {
2496                session = openSession();
2497
2498                StringBundler query = null;
2499                String sql = null;
2500
2501                if (orderByComparator != null) {
2502                    query = new StringBundler(2 +
2503                            (orderByComparator.getOrderByFields().length * 3));
2504
2505                    query.append(_SQL_SELECT_LAYOUT);
2506
2507                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2508                        orderByComparator);
2509
2510                    sql = query.toString();
2511                }
2512
2513                else {
2514                    sql = _SQL_SELECT_LAYOUT.concat(LayoutModelImpl.ORDER_BY_JPQL);
2515                }
2516
2517                Query q = session.createQuery(sql);
2518
2519                if (orderByComparator == null) {
2520                    list = (List<Layout>)QueryUtil.list(q, getDialect(), start,
2521                            end, false);
2522
2523                    Collections.sort(list);
2524                }
2525                else {
2526                    list = (List<Layout>)QueryUtil.list(q, getDialect(), start,
2527                            end);
2528                }
2529            }
2530            catch (Exception e) {
2531                throw processException(e);
2532            }
2533            finally {
2534                if (list == null) {
2535                    list = new ArrayList<Layout>();
2536                }
2537
2538                cacheResult(list);
2539
2540                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
2541
2542                closeSession(session);
2543            }
2544        }
2545
2546        return list;
2547    }
2548
2549    public void removeByGroupId(long groupId) throws SystemException {
2550        for (Layout layout : findByGroupId(groupId)) {
2551            remove(layout);
2552        }
2553    }
2554
2555    public void removeByCompanyId(long companyId) throws SystemException {
2556        for (Layout layout : findByCompanyId(companyId)) {
2557            remove(layout);
2558        }
2559    }
2560
2561    public void removeByDLFolderId(long dlFolderId)
2562        throws NoSuchLayoutException, SystemException {
2563        Layout layout = findByDLFolderId(dlFolderId);
2564
2565        remove(layout);
2566    }
2567
2568    public void removeByIconImageId(long iconImageId)
2569        throws NoSuchLayoutException, SystemException {
2570        Layout layout = findByIconImageId(iconImageId);
2571
2572        remove(layout);
2573    }
2574
2575    public void removeByG_P(long groupId, boolean privateLayout)
2576        throws SystemException {
2577        for (Layout layout : findByG_P(groupId, privateLayout)) {
2578            remove(layout);
2579        }
2580    }
2581
2582    public void removeByG_P_L(long groupId, boolean privateLayout, long layoutId)
2583        throws NoSuchLayoutException, SystemException {
2584        Layout layout = findByG_P_L(groupId, privateLayout, layoutId);
2585
2586        remove(layout);
2587    }
2588
2589    public void removeByG_P_P(long groupId, boolean privateLayout,
2590        long parentLayoutId) throws SystemException {
2591        for (Layout layout : findByG_P_P(groupId, privateLayout, parentLayoutId)) {
2592            remove(layout);
2593        }
2594    }
2595
2596    public void removeByG_P_F(long groupId, boolean privateLayout,
2597        String friendlyURL) throws NoSuchLayoutException, SystemException {
2598        Layout layout = findByG_P_F(groupId, privateLayout, friendlyURL);
2599
2600        remove(layout);
2601    }
2602
2603    public void removeByG_P_T(long groupId, boolean privateLayout, String type)
2604        throws SystemException {
2605        for (Layout layout : findByG_P_T(groupId, privateLayout, type)) {
2606            remove(layout);
2607        }
2608    }
2609
2610    public void removeAll() throws SystemException {
2611        for (Layout layout : findAll()) {
2612            remove(layout);
2613        }
2614    }
2615
2616    public int countByGroupId(long groupId) throws SystemException {
2617        Object[] finderArgs = new Object[] { new Long(groupId) };
2618
2619        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
2620                finderArgs, this);
2621
2622        if (count == null) {
2623            Session session = null;
2624
2625            try {
2626                session = openSession();
2627
2628                StringBundler query = new StringBundler(2);
2629
2630                query.append(_SQL_COUNT_LAYOUT_WHERE);
2631
2632                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2633
2634                String sql = query.toString();
2635
2636                Query q = session.createQuery(sql);
2637
2638                QueryPos qPos = QueryPos.getInstance(q);
2639
2640                qPos.add(groupId);
2641
2642                count = (Long)q.uniqueResult();
2643            }
2644            catch (Exception e) {
2645                throw processException(e);
2646            }
2647            finally {
2648                if (count == null) {
2649                    count = Long.valueOf(0);
2650                }
2651
2652                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
2653                    finderArgs, count);
2654
2655                closeSession(session);
2656            }
2657        }
2658
2659        return count.intValue();
2660    }
2661
2662    public int countByCompanyId(long companyId) throws SystemException {
2663        Object[] finderArgs = new Object[] { new Long(companyId) };
2664
2665        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
2666                finderArgs, this);
2667
2668        if (count == null) {
2669            Session session = null;
2670
2671            try {
2672                session = openSession();
2673
2674                StringBundler query = new StringBundler(2);
2675
2676                query.append(_SQL_COUNT_LAYOUT_WHERE);
2677
2678                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
2679
2680                String sql = query.toString();
2681
2682                Query q = session.createQuery(sql);
2683
2684                QueryPos qPos = QueryPos.getInstance(q);
2685
2686                qPos.add(companyId);
2687
2688                count = (Long)q.uniqueResult();
2689            }
2690            catch (Exception e) {
2691                throw processException(e);
2692            }
2693            finally {
2694                if (count == null) {
2695                    count = Long.valueOf(0);
2696                }
2697
2698                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
2699                    finderArgs, count);
2700
2701                closeSession(session);
2702            }
2703        }
2704
2705        return count.intValue();
2706    }
2707
2708    public int countByDLFolderId(long dlFolderId) throws SystemException {
2709        Object[] finderArgs = new Object[] { new Long(dlFolderId) };
2710
2711        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_DLFOLDERID,
2712                finderArgs, this);
2713
2714        if (count == null) {
2715            Session session = null;
2716
2717            try {
2718                session = openSession();
2719
2720                StringBundler query = new StringBundler(2);
2721
2722                query.append(_SQL_COUNT_LAYOUT_WHERE);
2723
2724                query.append(_FINDER_COLUMN_DLFOLDERID_DLFOLDERID_2);
2725
2726                String sql = query.toString();
2727
2728                Query q = session.createQuery(sql);
2729
2730                QueryPos qPos = QueryPos.getInstance(q);
2731
2732                qPos.add(dlFolderId);
2733
2734                count = (Long)q.uniqueResult();
2735            }
2736            catch (Exception e) {
2737                throw processException(e);
2738            }
2739            finally {
2740                if (count == null) {
2741                    count = Long.valueOf(0);
2742                }
2743
2744                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_DLFOLDERID,
2745                    finderArgs, count);
2746
2747                closeSession(session);
2748            }
2749        }
2750
2751        return count.intValue();
2752    }
2753
2754    public int countByIconImageId(long iconImageId) throws SystemException {
2755        Object[] finderArgs = new Object[] { new Long(iconImageId) };
2756
2757        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_ICONIMAGEID,
2758                finderArgs, this);
2759
2760        if (count == null) {
2761            Session session = null;
2762
2763            try {
2764                session = openSession();
2765
2766                StringBundler query = new StringBundler(2);
2767
2768                query.append(_SQL_COUNT_LAYOUT_WHERE);
2769
2770                query.append(_FINDER_COLUMN_ICONIMAGEID_ICONIMAGEID_2);
2771
2772                String sql = query.toString();
2773
2774                Query q = session.createQuery(sql);
2775
2776                QueryPos qPos = QueryPos.getInstance(q);
2777
2778                qPos.add(iconImageId);
2779
2780                count = (Long)q.uniqueResult();
2781            }
2782            catch (Exception e) {
2783                throw processException(e);
2784            }
2785            finally {
2786                if (count == null) {
2787                    count = Long.valueOf(0);
2788                }
2789
2790                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_ICONIMAGEID,
2791                    finderArgs, count);
2792
2793                closeSession(session);
2794            }
2795        }
2796
2797        return count.intValue();
2798    }
2799
2800    public int countByG_P(long groupId, boolean privateLayout)
2801        throws SystemException {
2802        Object[] finderArgs = new Object[] {
2803                new Long(groupId), Boolean.valueOf(privateLayout)
2804            };
2805
2806        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P,
2807                finderArgs, this);
2808
2809        if (count == null) {
2810            Session session = null;
2811
2812            try {
2813                session = openSession();
2814
2815                StringBundler query = new StringBundler(3);
2816
2817                query.append(_SQL_COUNT_LAYOUT_WHERE);
2818
2819                query.append(_FINDER_COLUMN_G_P_GROUPID_2);
2820
2821                query.append(_FINDER_COLUMN_G_P_PRIVATELAYOUT_2);
2822
2823                String sql = query.toString();
2824
2825                Query q = session.createQuery(sql);
2826
2827                QueryPos qPos = QueryPos.getInstance(q);
2828
2829                qPos.add(groupId);
2830
2831                qPos.add(privateLayout);
2832
2833                count = (Long)q.uniqueResult();
2834            }
2835            catch (Exception e) {
2836                throw processException(e);
2837            }
2838            finally {
2839                if (count == null) {
2840                    count = Long.valueOf(0);
2841                }
2842
2843                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P, finderArgs,
2844                    count);
2845
2846                closeSession(session);
2847            }
2848        }
2849
2850        return count.intValue();
2851    }
2852
2853    public int countByG_P_L(long groupId, boolean privateLayout, long layoutId)
2854        throws SystemException {
2855        Object[] finderArgs = new Object[] {
2856                new Long(groupId), Boolean.valueOf(privateLayout),
2857                new Long(layoutId)
2858            };
2859
2860        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P_L,
2861                finderArgs, this);
2862
2863        if (count == null) {
2864            Session session = null;
2865
2866            try {
2867                session = openSession();
2868
2869                StringBundler query = new StringBundler(4);
2870
2871                query.append(_SQL_COUNT_LAYOUT_WHERE);
2872
2873                query.append(_FINDER_COLUMN_G_P_L_GROUPID_2);
2874
2875                query.append(_FINDER_COLUMN_G_P_L_PRIVATELAYOUT_2);
2876
2877                query.append(_FINDER_COLUMN_G_P_L_LAYOUTID_2);
2878
2879                String sql = query.toString();
2880
2881                Query q = session.createQuery(sql);
2882
2883                QueryPos qPos = QueryPos.getInstance(q);
2884
2885                qPos.add(groupId);
2886
2887                qPos.add(privateLayout);
2888
2889                qPos.add(layoutId);
2890
2891                count = (Long)q.uniqueResult();
2892            }
2893            catch (Exception e) {
2894                throw processException(e);
2895            }
2896            finally {
2897                if (count == null) {
2898                    count = Long.valueOf(0);
2899                }
2900
2901                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P_L,
2902                    finderArgs, count);
2903
2904                closeSession(session);
2905            }
2906        }
2907
2908        return count.intValue();
2909    }
2910
2911    public int countByG_P_P(long groupId, boolean privateLayout,
2912        long parentLayoutId) throws SystemException {
2913        Object[] finderArgs = new Object[] {
2914                new Long(groupId), Boolean.valueOf(privateLayout),
2915                new Long(parentLayoutId)
2916            };
2917
2918        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P_P,
2919                finderArgs, this);
2920
2921        if (count == null) {
2922            Session session = null;
2923
2924            try {
2925                session = openSession();
2926
2927                StringBundler query = new StringBundler(4);
2928
2929                query.append(_SQL_COUNT_LAYOUT_WHERE);
2930
2931                query.append(_FINDER_COLUMN_G_P_P_GROUPID_2);
2932
2933                query.append(_FINDER_COLUMN_G_P_P_PRIVATELAYOUT_2);
2934
2935                query.append(_FINDER_COLUMN_G_P_P_PARENTLAYOUTID_2);
2936
2937                String sql = query.toString();
2938
2939                Query q = session.createQuery(sql);
2940
2941                QueryPos qPos = QueryPos.getInstance(q);
2942
2943                qPos.add(groupId);
2944
2945                qPos.add(privateLayout);
2946
2947                qPos.add(parentLayoutId);
2948
2949                count = (Long)q.uniqueResult();
2950            }
2951            catch (Exception e) {
2952                throw processException(e);
2953            }
2954            finally {
2955                if (count == null) {
2956                    count = Long.valueOf(0);
2957                }
2958
2959                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P_P,
2960                    finderArgs, count);
2961
2962                closeSession(session);
2963            }
2964        }
2965
2966        return count.intValue();
2967    }
2968
2969    public int countByG_P_F(long groupId, boolean privateLayout,
2970        String friendlyURL) throws SystemException {
2971        Object[] finderArgs = new Object[] {
2972                new Long(groupId), Boolean.valueOf(privateLayout),
2973                
2974                friendlyURL
2975            };
2976
2977        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P_F,
2978                finderArgs, this);
2979
2980        if (count == null) {
2981            Session session = null;
2982
2983            try {
2984                session = openSession();
2985
2986                StringBundler query = new StringBundler(4);
2987
2988                query.append(_SQL_COUNT_LAYOUT_WHERE);
2989
2990                query.append(_FINDER_COLUMN_G_P_F_GROUPID_2);
2991
2992                query.append(_FINDER_COLUMN_G_P_F_PRIVATELAYOUT_2);
2993
2994                if (friendlyURL == null) {
2995                    query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_1);
2996                }
2997                else {
2998                    if (friendlyURL.equals(StringPool.BLANK)) {
2999                        query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_3);
3000                    }
3001                    else {
3002                        query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_2);
3003                    }
3004                }
3005
3006                String sql = query.toString();
3007
3008                Query q = session.createQuery(sql);
3009
3010                QueryPos qPos = QueryPos.getInstance(q);
3011
3012                qPos.add(groupId);
3013
3014                qPos.add(privateLayout);
3015
3016                if (friendlyURL != null) {
3017                    qPos.add(friendlyURL);
3018                }
3019
3020                count = (Long)q.uniqueResult();
3021            }
3022            catch (Exception e) {
3023                throw processException(e);
3024            }
3025            finally {
3026                if (count == null) {
3027                    count = Long.valueOf(0);
3028                }
3029
3030                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P_F,
3031                    finderArgs, count);
3032
3033                closeSession(session);
3034            }
3035        }
3036
3037        return count.intValue();
3038    }
3039
3040    public int countByG_P_T(long groupId, boolean privateLayout, String type)
3041        throws SystemException {
3042        Object[] finderArgs = new Object[] {
3043                new Long(groupId), Boolean.valueOf(privateLayout),
3044                
3045                type
3046            };
3047
3048        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P_T,
3049                finderArgs, this);
3050
3051        if (count == null) {
3052            Session session = null;
3053
3054            try {
3055                session = openSession();
3056
3057                StringBundler query = new StringBundler(4);
3058
3059                query.append(_SQL_COUNT_LAYOUT_WHERE);
3060
3061                query.append(_FINDER_COLUMN_G_P_T_GROUPID_2);
3062
3063                query.append(_FINDER_COLUMN_G_P_T_PRIVATELAYOUT_2);
3064
3065                if (type == null) {
3066                    query.append(_FINDER_COLUMN_G_P_T_TYPE_1);
3067                }
3068                else {
3069                    if (type.equals(StringPool.BLANK)) {
3070                        query.append(_FINDER_COLUMN_G_P_T_TYPE_3);
3071                    }
3072                    else {
3073                        query.append(_FINDER_COLUMN_G_P_T_TYPE_2);
3074                    }
3075                }
3076
3077                String sql = query.toString();
3078
3079                Query q = session.createQuery(sql);
3080
3081                QueryPos qPos = QueryPos.getInstance(q);
3082
3083                qPos.add(groupId);
3084
3085                qPos.add(privateLayout);
3086
3087                if (type != null) {
3088                    qPos.add(type);
3089                }
3090
3091                count = (Long)q.uniqueResult();
3092            }
3093            catch (Exception e) {
3094                throw processException(e);
3095            }
3096            finally {
3097                if (count == null) {
3098                    count = Long.valueOf(0);
3099                }
3100
3101                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P_T,
3102                    finderArgs, count);
3103
3104                closeSession(session);
3105            }
3106        }
3107
3108        return count.intValue();
3109    }
3110
3111    public int countAll() throws SystemException {
3112        Object[] finderArgs = new Object[0];
3113
3114        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
3115                finderArgs, this);
3116
3117        if (count == null) {
3118            Session session = null;
3119
3120            try {
3121                session = openSession();
3122
3123                Query q = session.createQuery(_SQL_COUNT_LAYOUT);
3124
3125                count = (Long)q.uniqueResult();
3126            }
3127            catch (Exception e) {
3128                throw processException(e);
3129            }
3130            finally {
3131                if (count == null) {
3132                    count = Long.valueOf(0);
3133                }
3134
3135                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
3136                    count);
3137
3138                closeSession(session);
3139            }
3140        }
3141
3142        return count.intValue();
3143    }
3144
3145    public void afterPropertiesSet() {
3146        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
3147                    com.liferay.portal.util.PropsUtil.get(
3148                        "value.object.listener.com.liferay.portal.model.Layout")));
3149
3150        if (listenerClassNames.length > 0) {
3151            try {
3152                List<ModelListener<Layout>> listenersList = new ArrayList<ModelListener<Layout>>();
3153
3154                for (String listenerClassName : listenerClassNames) {
3155                    listenersList.add((ModelListener<Layout>)InstanceFactory.newInstance(
3156                            listenerClassName));
3157                }
3158
3159                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
3160            }
3161            catch (Exception e) {
3162                _log.error(e);
3163            }
3164        }
3165    }
3166
3167    @BeanReference(type = AccountPersistence.class)
3168    protected AccountPersistence accountPersistence;
3169    @BeanReference(type = AddressPersistence.class)
3170    protected AddressPersistence addressPersistence;
3171    @BeanReference(type = BrowserTrackerPersistence.class)
3172    protected BrowserTrackerPersistence browserTrackerPersistence;
3173    @BeanReference(type = ClassNamePersistence.class)
3174    protected ClassNamePersistence classNamePersistence;
3175    @BeanReference(type = CompanyPersistence.class)
3176    protected CompanyPersistence companyPersistence;
3177    @BeanReference(type = ContactPersistence.class)
3178    protected ContactPersistence contactPersistence;
3179    @BeanReference(type = CountryPersistence.class)
3180    protected CountryPersistence countryPersistence;
3181    @BeanReference(type = EmailAddressPersistence.class)
3182    protected EmailAddressPersistence emailAddressPersistence;
3183    @BeanReference(type = GroupPersistence.class)
3184    protected GroupPersistence groupPersistence;
3185    @BeanReference(type = ImagePersistence.class)
3186    protected ImagePersistence imagePersistence;
3187    @BeanReference(type = LayoutPersistence.class)
3188    protected LayoutPersistence layoutPersistence;
3189    @BeanReference(type = LayoutPrototypePersistence.class)
3190    protected LayoutPrototypePersistence layoutPrototypePersistence;
3191    @BeanReference(type = LayoutSetPersistence.class)
3192    protected LayoutSetPersistence layoutSetPersistence;
3193    @BeanReference(type = LayoutSetPrototypePersistence.class)
3194    protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
3195    @BeanReference(type = ListTypePersistence.class)
3196    protected ListTypePersistence listTypePersistence;
3197    @BeanReference(type = LockPersistence.class)
3198    protected LockPersistence lockPersistence;
3199    @BeanReference(type = MembershipRequestPersistence.class)
3200    protected MembershipRequestPersistence membershipRequestPersistence;
3201    @BeanReference(type = OrganizationPersistence.class)
3202    protected OrganizationPersistence organizationPersistence;
3203    @BeanReference(type = OrgGroupPermissionPersistence.class)
3204    protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
3205    @BeanReference(type = OrgGroupRolePersistence.class)
3206    protected OrgGroupRolePersistence orgGroupRolePersistence;
3207    @BeanReference(type = OrgLaborPersistence.class)
3208    protected OrgLaborPersistence orgLaborPersistence;
3209    @BeanReference(type = PasswordPolicyPersistence.class)
3210    protected PasswordPolicyPersistence passwordPolicyPersistence;
3211    @BeanReference(type = PasswordPolicyRelPersistence.class)
3212    protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
3213    @BeanReference(type = PasswordTrackerPersistence.class)
3214    protected PasswordTrackerPersistence passwordTrackerPersistence;
3215    @BeanReference(type = PermissionPersistence.class)
3216    protected PermissionPersistence permissionPersistence;
3217    @BeanReference(type = PhonePersistence.class)
3218    protected PhonePersistence phonePersistence;
3219    @BeanReference(type = PluginSettingPersistence.class)
3220    protected PluginSettingPersistence pluginSettingPersistence;
3221    @BeanReference(type = PortletPersistence.class)
3222    protected PortletPersistence portletPersistence;
3223    @BeanReference(type = PortletItemPersistence.class)
3224    protected PortletItemPersistence portletItemPersistence;
3225    @BeanReference(type = PortletPreferencesPersistence.class)
3226    protected PortletPreferencesPersistence portletPreferencesPersistence;
3227    @BeanReference(type = RegionPersistence.class)
3228    protected RegionPersistence regionPersistence;
3229    @BeanReference(type = ReleasePersistence.class)
3230    protected ReleasePersistence releasePersistence;
3231    @BeanReference(type = ResourcePersistence.class)
3232    protected ResourcePersistence resourcePersistence;
3233    @BeanReference(type = ResourceActionPersistence.class)
3234    protected ResourceActionPersistence resourceActionPersistence;
3235    @BeanReference(type = ResourceCodePersistence.class)
3236    protected ResourceCodePersistence resourceCodePersistence;
3237    @BeanReference(type = ResourcePermissionPersistence.class)
3238    protected ResourcePermissionPersistence resourcePermissionPersistence;
3239    @BeanReference(type = RolePersistence.class)
3240    protected RolePersistence rolePersistence;
3241    @BeanReference(type = ServiceComponentPersistence.class)
3242    protected ServiceComponentPersistence serviceComponentPersistence;
3243    @BeanReference(type = ShardPersistence.class)
3244    protected ShardPersistence shardPersistence;
3245    @BeanReference(type = SubscriptionPersistence.class)
3246    protected SubscriptionPersistence subscriptionPersistence;
3247    @BeanReference(type = TicketPersistence.class)
3248    protected TicketPersistence ticketPersistence;
3249    @BeanReference(type = TeamPersistence.class)
3250    protected TeamPersistence teamPersistence;
3251    @BeanReference(type = UserPersistence.class)
3252    protected UserPersistence userPersistence;
3253    @BeanReference(type = UserGroupPersistence.class)
3254    protected UserGroupPersistence userGroupPersistence;
3255    @BeanReference(type = UserGroupGroupRolePersistence.class)
3256    protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
3257    @BeanReference(type = UserGroupRolePersistence.class)
3258    protected UserGroupRolePersistence userGroupRolePersistence;
3259    @BeanReference(type = UserIdMapperPersistence.class)
3260    protected UserIdMapperPersistence userIdMapperPersistence;
3261    @BeanReference(type = UserTrackerPersistence.class)
3262    protected UserTrackerPersistence userTrackerPersistence;
3263    @BeanReference(type = UserTrackerPathPersistence.class)
3264    protected UserTrackerPathPersistence userTrackerPathPersistence;
3265    @BeanReference(type = WebDAVPropsPersistence.class)
3266    protected WebDAVPropsPersistence webDAVPropsPersistence;
3267    @BeanReference(type = WebsitePersistence.class)
3268    protected WebsitePersistence websitePersistence;
3269    @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
3270    protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
3271    @BeanReference(type = WorkflowInstanceLinkPersistence.class)
3272    protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
3273    @BeanReference(type = DLFolderPersistence.class)
3274    protected DLFolderPersistence dlFolderPersistence;
3275    @BeanReference(type = ExpandoValuePersistence.class)
3276    protected ExpandoValuePersistence expandoValuePersistence;
3277    @BeanReference(type = JournalContentSearchPersistence.class)
3278    protected JournalContentSearchPersistence journalContentSearchPersistence;
3279    @BeanReference(type = MBMessagePersistence.class)
3280    protected MBMessagePersistence mbMessagePersistence;
3281    @BeanReference(type = RatingsStatsPersistence.class)
3282    protected RatingsStatsPersistence ratingsStatsPersistence;
3283    @BeanReference(type = TasksProposalPersistence.class)
3284    protected TasksProposalPersistence tasksProposalPersistence;
3285    private static final String _SQL_SELECT_LAYOUT = "SELECT layout FROM Layout layout";
3286    private static final String _SQL_SELECT_LAYOUT_WHERE = "SELECT layout FROM Layout layout WHERE ";
3287    private static final String _SQL_COUNT_LAYOUT = "SELECT COUNT(layout) FROM Layout layout";
3288    private static final String _SQL_COUNT_LAYOUT_WHERE = "SELECT COUNT(layout) FROM Layout layout WHERE ";
3289    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "layout.groupId = ?";
3290    private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "layout.companyId = ?";
3291    private static final String _FINDER_COLUMN_DLFOLDERID_DLFOLDERID_2 = "layout.dlFolderId = ?";
3292    private static final String _FINDER_COLUMN_ICONIMAGEID_ICONIMAGEID_2 = "layout.iconImageId = ?";
3293    private static final String _FINDER_COLUMN_G_P_GROUPID_2 = "layout.groupId = ? AND ";
3294    private static final String _FINDER_COLUMN_G_P_PRIVATELAYOUT_2 = "layout.privateLayout = ?";
3295    private static final String _FINDER_COLUMN_G_P_L_GROUPID_2 = "layout.groupId = ? AND ";
3296    private static final String _FINDER_COLUMN_G_P_L_PRIVATELAYOUT_2 = "layout.privateLayout = ? AND ";
3297    private static final String _FINDER_COLUMN_G_P_L_LAYOUTID_2 = "layout.layoutId = ?";
3298    private static final String _FINDER_COLUMN_G_P_P_GROUPID_2 = "layout.groupId = ? AND ";
3299    private static final String _FINDER_COLUMN_G_P_P_PRIVATELAYOUT_2 = "layout.privateLayout = ? AND ";
3300    private static final String _FINDER_COLUMN_G_P_P_PARENTLAYOUTID_2 = "layout.parentLayoutId = ?";
3301    private static final String _FINDER_COLUMN_G_P_F_GROUPID_2 = "layout.groupId = ? AND ";
3302    private static final String _FINDER_COLUMN_G_P_F_PRIVATELAYOUT_2 = "layout.privateLayout = ? AND ";
3303    private static final String _FINDER_COLUMN_G_P_F_FRIENDLYURL_1 = "layout.friendlyURL IS NULL";
3304    private static final String _FINDER_COLUMN_G_P_F_FRIENDLYURL_2 = "layout.friendlyURL = ?";
3305    private static final String _FINDER_COLUMN_G_P_F_FRIENDLYURL_3 = "(layout.friendlyURL IS NULL OR layout.friendlyURL = ?)";
3306    private static final String _FINDER_COLUMN_G_P_T_GROUPID_2 = "layout.groupId = ? AND ";
3307    private static final String _FINDER_COLUMN_G_P_T_PRIVATELAYOUT_2 = "layout.privateLayout = ? AND ";
3308    private static final String _FINDER_COLUMN_G_P_T_TYPE_1 = "layout.type IS NULL";
3309    private static final String _FINDER_COLUMN_G_P_T_TYPE_2 = "layout.type = ?";
3310    private static final String _FINDER_COLUMN_G_P_T_TYPE_3 = "(layout.type IS NULL OR layout.type = ?)";
3311    private static final String _ORDER_BY_ENTITY_ALIAS = "layout.";
3312    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No Layout exists with the primary key ";
3313    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No Layout exists with the key {";
3314    private static Log _log = LogFactoryUtil.getLog(LayoutPersistenceImpl.class);
3315}