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