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