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