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