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.portlet.messageboards.service.persistence;
21  
22  import com.liferay.portal.SystemException;
23  import com.liferay.portal.kernel.annotation.BeanReference;
24  import com.liferay.portal.kernel.cache.CacheRegistry;
25  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
26  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
27  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
28  import com.liferay.portal.kernel.dao.orm.FinderPath;
29  import com.liferay.portal.kernel.dao.orm.Query;
30  import com.liferay.portal.kernel.dao.orm.QueryPos;
31  import com.liferay.portal.kernel.dao.orm.QueryUtil;
32  import com.liferay.portal.kernel.dao.orm.Session;
33  import com.liferay.portal.kernel.log.Log;
34  import com.liferay.portal.kernel.log.LogFactoryUtil;
35  import com.liferay.portal.kernel.util.GetterUtil;
36  import com.liferay.portal.kernel.util.OrderByComparator;
37  import com.liferay.portal.kernel.util.StringPool;
38  import com.liferay.portal.kernel.util.StringUtil;
39  import com.liferay.portal.kernel.util.Validator;
40  import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
41  import com.liferay.portal.model.ModelListener;
42  import com.liferay.portal.service.persistence.BatchSessionUtil;
43  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
44  
45  import com.liferay.portlet.messageboards.NoSuchMessageException;
46  import com.liferay.portlet.messageboards.model.MBMessage;
47  import com.liferay.portlet.messageboards.model.impl.MBMessageImpl;
48  import com.liferay.portlet.messageboards.model.impl.MBMessageModelImpl;
49  
50  import java.util.ArrayList;
51  import java.util.Collections;
52  import java.util.List;
53  
54  /**
55   * <a href="MBMessagePersistenceImpl.java.html"><b><i>View Source</i></b></a>
56   *
57   * @author Brian Wing Shun Chan
58   *
59   */
60  public class MBMessagePersistenceImpl extends BasePersistenceImpl
61      implements MBMessagePersistence {
62      public static final String FINDER_CLASS_NAME_ENTITY = MBMessageImpl.class.getName();
63      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
64          ".List";
65      public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
66              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
67              "findByUuid", new String[] { String.class.getName() });
68      public static final FinderPath FINDER_PATH_FIND_BY_OBC_UUID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
69              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
70              "findByUuid",
71              new String[] {
72                  String.class.getName(),
73                  
74              "java.lang.Integer", "java.lang.Integer",
75                  "com.liferay.portal.kernel.util.OrderByComparator"
76              });
77      public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
78              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
79              "countByUuid", new String[] { String.class.getName() });
80      public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
81              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
82              "fetchByUUID_G",
83              new String[] { String.class.getName(), Long.class.getName() });
84      public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
85              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
86              "countByUUID_G",
87              new String[] { String.class.getName(), Long.class.getName() });
88      public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
89              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
90              "findByCompanyId", new String[] { Long.class.getName() });
91      public static final FinderPath FINDER_PATH_FIND_BY_OBC_COMPANYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
92              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
93              "findByCompanyId",
94              new String[] {
95                  Long.class.getName(),
96                  
97              "java.lang.Integer", "java.lang.Integer",
98                  "com.liferay.portal.kernel.util.OrderByComparator"
99              });
100     public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
101             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
102             "countByCompanyId", new String[] { Long.class.getName() });
103     public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
104             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
105             "findByGroupId", new String[] { Long.class.getName() });
106     public static final FinderPath FINDER_PATH_FIND_BY_OBC_GROUPID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
107             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
108             "findByGroupId",
109             new String[] {
110                 Long.class.getName(),
111                 
112             "java.lang.Integer", "java.lang.Integer",
113                 "com.liferay.portal.kernel.util.OrderByComparator"
114             });
115     public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
116             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
117             "countByGroupId", new String[] { Long.class.getName() });
118     public static final FinderPath FINDER_PATH_FIND_BY_CATEGORYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
119             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
120             "findByCategoryId", new String[] { Long.class.getName() });
121     public static final FinderPath FINDER_PATH_FIND_BY_OBC_CATEGORYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
122             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
123             "findByCategoryId",
124             new String[] {
125                 Long.class.getName(),
126                 
127             "java.lang.Integer", "java.lang.Integer",
128                 "com.liferay.portal.kernel.util.OrderByComparator"
129             });
130     public static final FinderPath FINDER_PATH_COUNT_BY_CATEGORYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
131             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
132             "countByCategoryId", new String[] { Long.class.getName() });
133     public static final FinderPath FINDER_PATH_FIND_BY_THREADID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
134             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
135             "findByThreadId", new String[] { Long.class.getName() });
136     public static final FinderPath FINDER_PATH_FIND_BY_OBC_THREADID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
137             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
138             "findByThreadId",
139             new String[] {
140                 Long.class.getName(),
141                 
142             "java.lang.Integer", "java.lang.Integer",
143                 "com.liferay.portal.kernel.util.OrderByComparator"
144             });
145     public static final FinderPath FINDER_PATH_COUNT_BY_THREADID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
146             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
147             "countByThreadId", new String[] { Long.class.getName() });
148     public static final FinderPath FINDER_PATH_FIND_BY_THREADREPLIES = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
149             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
150             "findByThreadReplies", new String[] { Long.class.getName() });
151     public static final FinderPath FINDER_PATH_FIND_BY_OBC_THREADREPLIES = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
152             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
153             "findByThreadReplies",
154             new String[] {
155                 Long.class.getName(),
156                 
157             "java.lang.Integer", "java.lang.Integer",
158                 "com.liferay.portal.kernel.util.OrderByComparator"
159             });
160     public static final FinderPath FINDER_PATH_COUNT_BY_THREADREPLIES = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
161             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
162             "countByThreadReplies", new String[] { Long.class.getName() });
163     public static final FinderPath FINDER_PATH_FIND_BY_G_U = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
164             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
165             "findByG_U",
166             new String[] { Long.class.getName(), Long.class.getName() });
167     public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_U = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
168             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
169             "findByG_U",
170             new String[] {
171                 Long.class.getName(), Long.class.getName(),
172                 
173             "java.lang.Integer", "java.lang.Integer",
174                 "com.liferay.portal.kernel.util.OrderByComparator"
175             });
176     public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
177             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
178             "countByG_U",
179             new String[] { Long.class.getName(), Long.class.getName() });
180     public static final FinderPath FINDER_PATH_FIND_BY_C_C = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
181             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
182             "findByC_C",
183             new String[] { Long.class.getName(), Long.class.getName() });
184     public static final FinderPath FINDER_PATH_FIND_BY_OBC_C_C = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
185             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
186             "findByC_C",
187             new String[] {
188                 Long.class.getName(), Long.class.getName(),
189                 
190             "java.lang.Integer", "java.lang.Integer",
191                 "com.liferay.portal.kernel.util.OrderByComparator"
192             });
193     public static final FinderPath FINDER_PATH_COUNT_BY_C_C = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
194             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
195             "countByC_C",
196             new String[] { Long.class.getName(), Long.class.getName() });
197     public static final FinderPath FINDER_PATH_FIND_BY_C_T = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
198             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
199             "findByC_T",
200             new String[] { Long.class.getName(), Long.class.getName() });
201     public static final FinderPath FINDER_PATH_FIND_BY_OBC_C_T = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
202             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
203             "findByC_T",
204             new String[] {
205                 Long.class.getName(), Long.class.getName(),
206                 
207             "java.lang.Integer", "java.lang.Integer",
208                 "com.liferay.portal.kernel.util.OrderByComparator"
209             });
210     public static final FinderPath FINDER_PATH_COUNT_BY_C_T = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
211             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
212             "countByC_T",
213             new String[] { Long.class.getName(), Long.class.getName() });
214     public static final FinderPath FINDER_PATH_FIND_BY_T_P = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
215             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
216             "findByT_P",
217             new String[] { Long.class.getName(), Long.class.getName() });
218     public static final FinderPath FINDER_PATH_FIND_BY_OBC_T_P = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
219             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
220             "findByT_P",
221             new String[] {
222                 Long.class.getName(), Long.class.getName(),
223                 
224             "java.lang.Integer", "java.lang.Integer",
225                 "com.liferay.portal.kernel.util.OrderByComparator"
226             });
227     public static final FinderPath FINDER_PATH_COUNT_BY_T_P = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
228             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
229             "countByT_P",
230             new String[] { Long.class.getName(), Long.class.getName() });
231     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
232             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
233             "findAll", new String[0]);
234     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
235             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
236             "countAll", new String[0]);
237 
238     public void cacheResult(MBMessage mbMessage) {
239         EntityCacheUtil.putResult(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
240             MBMessageImpl.class, mbMessage.getPrimaryKey(), mbMessage);
241 
242         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
243             new Object[] { mbMessage.getUuid(), new Long(mbMessage.getGroupId()) },
244             mbMessage);
245     }
246 
247     public void cacheResult(List<MBMessage> mbMessages) {
248         for (MBMessage mbMessage : mbMessages) {
249             if (EntityCacheUtil.getResult(
250                         MBMessageModelImpl.ENTITY_CACHE_ENABLED,
251                         MBMessageImpl.class, mbMessage.getPrimaryKey(), this) == null) {
252                 cacheResult(mbMessage);
253             }
254         }
255     }
256 
257     public void clearCache() {
258         CacheRegistry.clear(MBMessageImpl.class.getName());
259         EntityCacheUtil.clearCache(MBMessageImpl.class.getName());
260         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
261         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
262     }
263 
264     public MBMessage create(long messageId) {
265         MBMessage mbMessage = new MBMessageImpl();
266 
267         mbMessage.setNew(true);
268         mbMessage.setPrimaryKey(messageId);
269 
270         String uuid = PortalUUIDUtil.generate();
271 
272         mbMessage.setUuid(uuid);
273 
274         return mbMessage;
275     }
276 
277     public MBMessage remove(long messageId)
278         throws NoSuchMessageException, SystemException {
279         Session session = null;
280 
281         try {
282             session = openSession();
283 
284             MBMessage mbMessage = (MBMessage)session.get(MBMessageImpl.class,
285                     new Long(messageId));
286 
287             if (mbMessage == null) {
288                 if (_log.isWarnEnabled()) {
289                     _log.warn("No MBMessage exists with the primary key " +
290                         messageId);
291                 }
292 
293                 throw new NoSuchMessageException(
294                     "No MBMessage exists with the primary key " + messageId);
295             }
296 
297             return remove(mbMessage);
298         }
299         catch (NoSuchMessageException nsee) {
300             throw nsee;
301         }
302         catch (Exception e) {
303             throw processException(e);
304         }
305         finally {
306             closeSession(session);
307         }
308     }
309 
310     public MBMessage remove(MBMessage mbMessage) throws SystemException {
311         for (ModelListener<MBMessage> listener : listeners) {
312             listener.onBeforeRemove(mbMessage);
313         }
314 
315         mbMessage = removeImpl(mbMessage);
316 
317         for (ModelListener<MBMessage> listener : listeners) {
318             listener.onAfterRemove(mbMessage);
319         }
320 
321         return mbMessage;
322     }
323 
324     protected MBMessage removeImpl(MBMessage mbMessage)
325         throws SystemException {
326         Session session = null;
327 
328         try {
329             session = openSession();
330 
331             if (mbMessage.isCachedModel() || BatchSessionUtil.isEnabled()) {
332                 Object staleObject = session.get(MBMessageImpl.class,
333                         mbMessage.getPrimaryKeyObj());
334 
335                 if (staleObject != null) {
336                     session.evict(staleObject);
337                 }
338             }
339 
340             session.delete(mbMessage);
341 
342             session.flush();
343         }
344         catch (Exception e) {
345             throw processException(e);
346         }
347         finally {
348             closeSession(session);
349         }
350 
351         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
352 
353         MBMessageModelImpl mbMessageModelImpl = (MBMessageModelImpl)mbMessage;
354 
355         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
356             new Object[] {
357                 mbMessageModelImpl.getOriginalUuid(),
358                 new Long(mbMessageModelImpl.getOriginalGroupId())
359             });
360 
361         EntityCacheUtil.removeResult(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
362             MBMessageImpl.class, mbMessage.getPrimaryKey());
363 
364         return mbMessage;
365     }
366 
367     /**
368      * @deprecated Use <code>update(MBMessage mbMessage, boolean merge)</code>.
369      */
370     public MBMessage update(MBMessage mbMessage) throws SystemException {
371         if (_log.isWarnEnabled()) {
372             _log.warn(
373                 "Using the deprecated update(MBMessage mbMessage) method. Use update(MBMessage mbMessage, boolean merge) instead.");
374         }
375 
376         return update(mbMessage, false);
377     }
378 
379     /**
380      * Add, update, or merge, the entity. This method also calls the model
381      * listeners to trigger the proper events associated with adding, deleting,
382      * or updating an entity.
383      *
384      * @param        mbMessage the entity to add, update, or merge
385      * @param        merge boolean value for whether to merge the entity. The
386      *                default value is false. Setting merge to true is more
387      *                expensive and should only be true when mbMessage is
388      *                transient. See LEP-5473 for a detailed discussion of this
389      *                method.
390      * @return        true if the portlet can be displayed via Ajax
391      */
392     public MBMessage update(MBMessage mbMessage, boolean merge)
393         throws SystemException {
394         boolean isNew = mbMessage.isNew();
395 
396         for (ModelListener<MBMessage> listener : listeners) {
397             if (isNew) {
398                 listener.onBeforeCreate(mbMessage);
399             }
400             else {
401                 listener.onBeforeUpdate(mbMessage);
402             }
403         }
404 
405         mbMessage = updateImpl(mbMessage, merge);
406 
407         for (ModelListener<MBMessage> listener : listeners) {
408             if (isNew) {
409                 listener.onAfterCreate(mbMessage);
410             }
411             else {
412                 listener.onAfterUpdate(mbMessage);
413             }
414         }
415 
416         return mbMessage;
417     }
418 
419     public MBMessage updateImpl(
420         com.liferay.portlet.messageboards.model.MBMessage mbMessage,
421         boolean merge) throws SystemException {
422         boolean isNew = mbMessage.isNew();
423 
424         MBMessageModelImpl mbMessageModelImpl = (MBMessageModelImpl)mbMessage;
425 
426         if (Validator.isNull(mbMessage.getUuid())) {
427             String uuid = PortalUUIDUtil.generate();
428 
429             mbMessage.setUuid(uuid);
430         }
431 
432         Session session = null;
433 
434         try {
435             session = openSession();
436 
437             BatchSessionUtil.update(session, mbMessage, merge);
438 
439             mbMessage.setNew(false);
440         }
441         catch (Exception e) {
442             throw processException(e);
443         }
444         finally {
445             closeSession(session);
446         }
447 
448         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
449 
450         EntityCacheUtil.putResult(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
451             MBMessageImpl.class, mbMessage.getPrimaryKey(), mbMessage);
452 
453         if (!isNew &&
454                 (!Validator.equals(mbMessage.getUuid(),
455                     mbMessageModelImpl.getOriginalUuid()) ||
456                 (mbMessage.getGroupId() != mbMessageModelImpl.getOriginalGroupId()))) {
457             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
458                 new Object[] {
459                     mbMessageModelImpl.getOriginalUuid(),
460                     new Long(mbMessageModelImpl.getOriginalGroupId())
461                 });
462         }
463 
464         if (isNew ||
465                 (!Validator.equals(mbMessage.getUuid(),
466                     mbMessageModelImpl.getOriginalUuid()) ||
467                 (mbMessage.getGroupId() != mbMessageModelImpl.getOriginalGroupId()))) {
468             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
469                 new Object[] {
470                     mbMessage.getUuid(), new Long(mbMessage.getGroupId())
471                 }, mbMessage);
472         }
473 
474         return mbMessage;
475     }
476 
477     public MBMessage findByPrimaryKey(long messageId)
478         throws NoSuchMessageException, SystemException {
479         MBMessage mbMessage = fetchByPrimaryKey(messageId);
480 
481         if (mbMessage == null) {
482             if (_log.isWarnEnabled()) {
483                 _log.warn("No MBMessage exists with the primary key " +
484                     messageId);
485             }
486 
487             throw new NoSuchMessageException(
488                 "No MBMessage exists with the primary key " + messageId);
489         }
490 
491         return mbMessage;
492     }
493 
494     public MBMessage fetchByPrimaryKey(long messageId)
495         throws SystemException {
496         MBMessage mbMessage = (MBMessage)EntityCacheUtil.getResult(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
497                 MBMessageImpl.class, messageId, this);
498 
499         if (mbMessage == null) {
500             Session session = null;
501 
502             try {
503                 session = openSession();
504 
505                 mbMessage = (MBMessage)session.get(MBMessageImpl.class,
506                         new Long(messageId));
507             }
508             catch (Exception e) {
509                 throw processException(e);
510             }
511             finally {
512                 if (mbMessage != null) {
513                     cacheResult(mbMessage);
514                 }
515 
516                 closeSession(session);
517             }
518         }
519 
520         return mbMessage;
521     }
522 
523     public List<MBMessage> findByUuid(String uuid) throws SystemException {
524         Object[] finderArgs = new Object[] { uuid };
525 
526         List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
527                 finderArgs, this);
528 
529         if (list == null) {
530             Session session = null;
531 
532             try {
533                 session = openSession();
534 
535                 StringBuilder query = new StringBuilder();
536 
537                 query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
538 
539                 if (uuid == null) {
540                     query.append("mbMessage.uuid IS NULL");
541                 }
542                 else {
543                     query.append("mbMessage.uuid = ?");
544                 }
545 
546                 query.append(" ");
547 
548                 query.append("ORDER BY ");
549 
550                 query.append("mbMessage.createDate ASC, ");
551                 query.append("mbMessage.messageId ASC");
552 
553                 Query q = session.createQuery(query.toString());
554 
555                 QueryPos qPos = QueryPos.getInstance(q);
556 
557                 if (uuid != null) {
558                     qPos.add(uuid);
559                 }
560 
561                 list = q.list();
562             }
563             catch (Exception e) {
564                 throw processException(e);
565             }
566             finally {
567                 if (list == null) {
568                     list = new ArrayList<MBMessage>();
569                 }
570 
571                 cacheResult(list);
572 
573                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
574                     list);
575 
576                 closeSession(session);
577             }
578         }
579 
580         return list;
581     }
582 
583     public List<MBMessage> findByUuid(String uuid, int start, int end)
584         throws SystemException {
585         return findByUuid(uuid, start, end, null);
586     }
587 
588     public List<MBMessage> findByUuid(String uuid, int start, int end,
589         OrderByComparator obc) throws SystemException {
590         Object[] finderArgs = new Object[] {
591                 uuid,
592                 
593                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
594             };
595 
596         List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_UUID,
597                 finderArgs, this);
598 
599         if (list == null) {
600             Session session = null;
601 
602             try {
603                 session = openSession();
604 
605                 StringBuilder query = new StringBuilder();
606 
607                 query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
608 
609                 if (uuid == null) {
610                     query.append("mbMessage.uuid IS NULL");
611                 }
612                 else {
613                     query.append("mbMessage.uuid = ?");
614                 }
615 
616                 query.append(" ");
617 
618                 if (obc != null) {
619                     query.append("ORDER BY ");
620 
621                     String[] orderByFields = obc.getOrderByFields();
622 
623                     for (int i = 0; i < orderByFields.length; i++) {
624                         query.append("mbMessage.");
625                         query.append(orderByFields[i]);
626 
627                         if (obc.isAscending()) {
628                             query.append(" ASC");
629                         }
630                         else {
631                             query.append(" DESC");
632                         }
633 
634                         if ((i + 1) < orderByFields.length) {
635                             query.append(", ");
636                         }
637                     }
638                 }
639 
640                 else {
641                     query.append("ORDER BY ");
642 
643                     query.append("mbMessage.createDate ASC, ");
644                     query.append("mbMessage.messageId ASC");
645                 }
646 
647                 Query q = session.createQuery(query.toString());
648 
649                 QueryPos qPos = QueryPos.getInstance(q);
650 
651                 if (uuid != null) {
652                     qPos.add(uuid);
653                 }
654 
655                 list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
656                         end);
657             }
658             catch (Exception e) {
659                 throw processException(e);
660             }
661             finally {
662                 if (list == null) {
663                     list = new ArrayList<MBMessage>();
664                 }
665 
666                 cacheResult(list);
667 
668                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_UUID,
669                     finderArgs, list);
670 
671                 closeSession(session);
672             }
673         }
674 
675         return list;
676     }
677 
678     public MBMessage findByUuid_First(String uuid, OrderByComparator obc)
679         throws NoSuchMessageException, SystemException {
680         List<MBMessage> list = findByUuid(uuid, 0, 1, obc);
681 
682         if (list.isEmpty()) {
683             StringBuilder msg = new StringBuilder();
684 
685             msg.append("No MBMessage exists with the key {");
686 
687             msg.append("uuid=" + uuid);
688 
689             msg.append(StringPool.CLOSE_CURLY_BRACE);
690 
691             throw new NoSuchMessageException(msg.toString());
692         }
693         else {
694             return list.get(0);
695         }
696     }
697 
698     public MBMessage findByUuid_Last(String uuid, OrderByComparator obc)
699         throws NoSuchMessageException, SystemException {
700         int count = countByUuid(uuid);
701 
702         List<MBMessage> list = findByUuid(uuid, count - 1, count, obc);
703 
704         if (list.isEmpty()) {
705             StringBuilder msg = new StringBuilder();
706 
707             msg.append("No MBMessage exists with the key {");
708 
709             msg.append("uuid=" + uuid);
710 
711             msg.append(StringPool.CLOSE_CURLY_BRACE);
712 
713             throw new NoSuchMessageException(msg.toString());
714         }
715         else {
716             return list.get(0);
717         }
718     }
719 
720     public MBMessage[] findByUuid_PrevAndNext(long messageId, String uuid,
721         OrderByComparator obc) throws NoSuchMessageException, SystemException {
722         MBMessage mbMessage = findByPrimaryKey(messageId);
723 
724         int count = countByUuid(uuid);
725 
726         Session session = null;
727 
728         try {
729             session = openSession();
730 
731             StringBuilder query = new StringBuilder();
732 
733             query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
734 
735             if (uuid == null) {
736                 query.append("mbMessage.uuid IS NULL");
737             }
738             else {
739                 query.append("mbMessage.uuid = ?");
740             }
741 
742             query.append(" ");
743 
744             if (obc != null) {
745                 query.append("ORDER BY ");
746 
747                 String[] orderByFields = obc.getOrderByFields();
748 
749                 for (int i = 0; i < orderByFields.length; i++) {
750                     query.append("mbMessage.");
751                     query.append(orderByFields[i]);
752 
753                     if (obc.isAscending()) {
754                         query.append(" ASC");
755                     }
756                     else {
757                         query.append(" DESC");
758                     }
759 
760                     if ((i + 1) < orderByFields.length) {
761                         query.append(", ");
762                     }
763                 }
764             }
765 
766             else {
767                 query.append("ORDER BY ");
768 
769                 query.append("mbMessage.createDate ASC, ");
770                 query.append("mbMessage.messageId ASC");
771             }
772 
773             Query q = session.createQuery(query.toString());
774 
775             QueryPos qPos = QueryPos.getInstance(q);
776 
777             if (uuid != null) {
778                 qPos.add(uuid);
779             }
780 
781             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
782                     mbMessage);
783 
784             MBMessage[] array = new MBMessageImpl[3];
785 
786             array[0] = (MBMessage)objArray[0];
787             array[1] = (MBMessage)objArray[1];
788             array[2] = (MBMessage)objArray[2];
789 
790             return array;
791         }
792         catch (Exception e) {
793             throw processException(e);
794         }
795         finally {
796             closeSession(session);
797         }
798     }
799 
800     public MBMessage findByUUID_G(String uuid, long groupId)
801         throws NoSuchMessageException, SystemException {
802         MBMessage mbMessage = fetchByUUID_G(uuid, groupId);
803 
804         if (mbMessage == null) {
805             StringBuilder msg = new StringBuilder();
806 
807             msg.append("No MBMessage exists with the key {");
808 
809             msg.append("uuid=" + uuid);
810 
811             msg.append(", ");
812             msg.append("groupId=" + groupId);
813 
814             msg.append(StringPool.CLOSE_CURLY_BRACE);
815 
816             if (_log.isWarnEnabled()) {
817                 _log.warn(msg.toString());
818             }
819 
820             throw new NoSuchMessageException(msg.toString());
821         }
822 
823         return mbMessage;
824     }
825 
826     public MBMessage fetchByUUID_G(String uuid, long groupId)
827         throws SystemException {
828         return fetchByUUID_G(uuid, groupId, true);
829     }
830 
831     public MBMessage fetchByUUID_G(String uuid, long groupId,
832         boolean retrieveFromCache) throws SystemException {
833         Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
834 
835         Object result = null;
836 
837         if (retrieveFromCache) {
838             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
839                     finderArgs, this);
840         }
841 
842         if (result == null) {
843             Session session = null;
844 
845             try {
846                 session = openSession();
847 
848                 StringBuilder query = new StringBuilder();
849 
850                 query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
851 
852                 if (uuid == null) {
853                     query.append("mbMessage.uuid IS NULL");
854                 }
855                 else {
856                     query.append("mbMessage.uuid = ?");
857                 }
858 
859                 query.append(" AND ");
860 
861                 query.append("mbMessage.groupId = ?");
862 
863                 query.append(" ");
864 
865                 query.append("ORDER BY ");
866 
867                 query.append("mbMessage.createDate ASC, ");
868                 query.append("mbMessage.messageId ASC");
869 
870                 Query q = session.createQuery(query.toString());
871 
872                 QueryPos qPos = QueryPos.getInstance(q);
873 
874                 if (uuid != null) {
875                     qPos.add(uuid);
876                 }
877 
878                 qPos.add(groupId);
879 
880                 List<MBMessage> list = q.list();
881 
882                 result = list;
883 
884                 MBMessage mbMessage = null;
885 
886                 if (list.isEmpty()) {
887                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
888                         finderArgs, list);
889                 }
890                 else {
891                     mbMessage = list.get(0);
892 
893                     cacheResult(mbMessage);
894 
895                     if ((mbMessage.getUuid() == null) ||
896                             !mbMessage.getUuid().equals(uuid) ||
897                             (mbMessage.getGroupId() != groupId)) {
898                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
899                             finderArgs, mbMessage);
900                     }
901                 }
902 
903                 return mbMessage;
904             }
905             catch (Exception e) {
906                 throw processException(e);
907             }
908             finally {
909                 if (result == null) {
910                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
911                         finderArgs, new ArrayList<MBMessage>());
912                 }
913 
914                 closeSession(session);
915             }
916         }
917         else {
918             if (result instanceof List) {
919                 return null;
920             }
921             else {
922                 return (MBMessage)result;
923             }
924         }
925     }
926 
927     public List<MBMessage> findByCompanyId(long companyId)
928         throws SystemException {
929         Object[] finderArgs = new Object[] { new Long(companyId) };
930 
931         List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
932                 finderArgs, this);
933 
934         if (list == null) {
935             Session session = null;
936 
937             try {
938                 session = openSession();
939 
940                 StringBuilder query = new StringBuilder();
941 
942                 query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
943 
944                 query.append("mbMessage.companyId = ?");
945 
946                 query.append(" ");
947 
948                 query.append("ORDER BY ");
949 
950                 query.append("mbMessage.createDate ASC, ");
951                 query.append("mbMessage.messageId ASC");
952 
953                 Query q = session.createQuery(query.toString());
954 
955                 QueryPos qPos = QueryPos.getInstance(q);
956 
957                 qPos.add(companyId);
958 
959                 list = q.list();
960             }
961             catch (Exception e) {
962                 throw processException(e);
963             }
964             finally {
965                 if (list == null) {
966                     list = new ArrayList<MBMessage>();
967                 }
968 
969                 cacheResult(list);
970 
971                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
972                     finderArgs, list);
973 
974                 closeSession(session);
975             }
976         }
977 
978         return list;
979     }
980 
981     public List<MBMessage> findByCompanyId(long companyId, int start, int end)
982         throws SystemException {
983         return findByCompanyId(companyId, start, end, null);
984     }
985 
986     public List<MBMessage> findByCompanyId(long companyId, int start, int end,
987         OrderByComparator obc) throws SystemException {
988         Object[] finderArgs = new Object[] {
989                 new Long(companyId),
990                 
991                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
992             };
993 
994         List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
995                 finderArgs, this);
996 
997         if (list == null) {
998             Session session = null;
999 
1000            try {
1001                session = openSession();
1002
1003                StringBuilder query = new StringBuilder();
1004
1005                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1006
1007                query.append("mbMessage.companyId = ?");
1008
1009                query.append(" ");
1010
1011                if (obc != null) {
1012                    query.append("ORDER BY ");
1013
1014                    String[] orderByFields = obc.getOrderByFields();
1015
1016                    for (int i = 0; i < orderByFields.length; i++) {
1017                        query.append("mbMessage.");
1018                        query.append(orderByFields[i]);
1019
1020                        if (obc.isAscending()) {
1021                            query.append(" ASC");
1022                        }
1023                        else {
1024                            query.append(" DESC");
1025                        }
1026
1027                        if ((i + 1) < orderByFields.length) {
1028                            query.append(", ");
1029                        }
1030                    }
1031                }
1032
1033                else {
1034                    query.append("ORDER BY ");
1035
1036                    query.append("mbMessage.createDate ASC, ");
1037                    query.append("mbMessage.messageId ASC");
1038                }
1039
1040                Query q = session.createQuery(query.toString());
1041
1042                QueryPos qPos = QueryPos.getInstance(q);
1043
1044                qPos.add(companyId);
1045
1046                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
1047                        end);
1048            }
1049            catch (Exception e) {
1050                throw processException(e);
1051            }
1052            finally {
1053                if (list == null) {
1054                    list = new ArrayList<MBMessage>();
1055                }
1056
1057                cacheResult(list);
1058
1059                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
1060                    finderArgs, list);
1061
1062                closeSession(session);
1063            }
1064        }
1065
1066        return list;
1067    }
1068
1069    public MBMessage findByCompanyId_First(long companyId, OrderByComparator obc)
1070        throws NoSuchMessageException, SystemException {
1071        List<MBMessage> list = findByCompanyId(companyId, 0, 1, obc);
1072
1073        if (list.isEmpty()) {
1074            StringBuilder msg = new StringBuilder();
1075
1076            msg.append("No MBMessage exists with the key {");
1077
1078            msg.append("companyId=" + companyId);
1079
1080            msg.append(StringPool.CLOSE_CURLY_BRACE);
1081
1082            throw new NoSuchMessageException(msg.toString());
1083        }
1084        else {
1085            return list.get(0);
1086        }
1087    }
1088
1089    public MBMessage findByCompanyId_Last(long companyId, OrderByComparator obc)
1090        throws NoSuchMessageException, SystemException {
1091        int count = countByCompanyId(companyId);
1092
1093        List<MBMessage> list = findByCompanyId(companyId, count - 1, count, obc);
1094
1095        if (list.isEmpty()) {
1096            StringBuilder msg = new StringBuilder();
1097
1098            msg.append("No MBMessage exists with the key {");
1099
1100            msg.append("companyId=" + companyId);
1101
1102            msg.append(StringPool.CLOSE_CURLY_BRACE);
1103
1104            throw new NoSuchMessageException(msg.toString());
1105        }
1106        else {
1107            return list.get(0);
1108        }
1109    }
1110
1111    public MBMessage[] findByCompanyId_PrevAndNext(long messageId,
1112        long companyId, OrderByComparator obc)
1113        throws NoSuchMessageException, SystemException {
1114        MBMessage mbMessage = findByPrimaryKey(messageId);
1115
1116        int count = countByCompanyId(companyId);
1117
1118        Session session = null;
1119
1120        try {
1121            session = openSession();
1122
1123            StringBuilder query = new StringBuilder();
1124
1125            query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1126
1127            query.append("mbMessage.companyId = ?");
1128
1129            query.append(" ");
1130
1131            if (obc != null) {
1132                query.append("ORDER BY ");
1133
1134                String[] orderByFields = obc.getOrderByFields();
1135
1136                for (int i = 0; i < orderByFields.length; i++) {
1137                    query.append("mbMessage.");
1138                    query.append(orderByFields[i]);
1139
1140                    if (obc.isAscending()) {
1141                        query.append(" ASC");
1142                    }
1143                    else {
1144                        query.append(" DESC");
1145                    }
1146
1147                    if ((i + 1) < orderByFields.length) {
1148                        query.append(", ");
1149                    }
1150                }
1151            }
1152
1153            else {
1154                query.append("ORDER BY ");
1155
1156                query.append("mbMessage.createDate ASC, ");
1157                query.append("mbMessage.messageId ASC");
1158            }
1159
1160            Query q = session.createQuery(query.toString());
1161
1162            QueryPos qPos = QueryPos.getInstance(q);
1163
1164            qPos.add(companyId);
1165
1166            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1167                    mbMessage);
1168
1169            MBMessage[] array = new MBMessageImpl[3];
1170
1171            array[0] = (MBMessage)objArray[0];
1172            array[1] = (MBMessage)objArray[1];
1173            array[2] = (MBMessage)objArray[2];
1174
1175            return array;
1176        }
1177        catch (Exception e) {
1178            throw processException(e);
1179        }
1180        finally {
1181            closeSession(session);
1182        }
1183    }
1184
1185    public List<MBMessage> findByGroupId(long groupId)
1186        throws SystemException {
1187        Object[] finderArgs = new Object[] { new Long(groupId) };
1188
1189        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
1190                finderArgs, this);
1191
1192        if (list == null) {
1193            Session session = null;
1194
1195            try {
1196                session = openSession();
1197
1198                StringBuilder query = new StringBuilder();
1199
1200                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1201
1202                query.append("mbMessage.groupId = ?");
1203
1204                query.append(" ");
1205
1206                query.append("ORDER BY ");
1207
1208                query.append("mbMessage.createDate ASC, ");
1209                query.append("mbMessage.messageId ASC");
1210
1211                Query q = session.createQuery(query.toString());
1212
1213                QueryPos qPos = QueryPos.getInstance(q);
1214
1215                qPos.add(groupId);
1216
1217                list = q.list();
1218            }
1219            catch (Exception e) {
1220                throw processException(e);
1221            }
1222            finally {
1223                if (list == null) {
1224                    list = new ArrayList<MBMessage>();
1225                }
1226
1227                cacheResult(list);
1228
1229                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
1230                    finderArgs, list);
1231
1232                closeSession(session);
1233            }
1234        }
1235
1236        return list;
1237    }
1238
1239    public List<MBMessage> findByGroupId(long groupId, int start, int end)
1240        throws SystemException {
1241        return findByGroupId(groupId, start, end, null);
1242    }
1243
1244    public List<MBMessage> findByGroupId(long groupId, int start, int end,
1245        OrderByComparator obc) throws SystemException {
1246        Object[] finderArgs = new Object[] {
1247                new Long(groupId),
1248                
1249                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1250            };
1251
1252        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
1253                finderArgs, this);
1254
1255        if (list == null) {
1256            Session session = null;
1257
1258            try {
1259                session = openSession();
1260
1261                StringBuilder query = new StringBuilder();
1262
1263                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1264
1265                query.append("mbMessage.groupId = ?");
1266
1267                query.append(" ");
1268
1269                if (obc != null) {
1270                    query.append("ORDER BY ");
1271
1272                    String[] orderByFields = obc.getOrderByFields();
1273
1274                    for (int i = 0; i < orderByFields.length; i++) {
1275                        query.append("mbMessage.");
1276                        query.append(orderByFields[i]);
1277
1278                        if (obc.isAscending()) {
1279                            query.append(" ASC");
1280                        }
1281                        else {
1282                            query.append(" DESC");
1283                        }
1284
1285                        if ((i + 1) < orderByFields.length) {
1286                            query.append(", ");
1287                        }
1288                    }
1289                }
1290
1291                else {
1292                    query.append("ORDER BY ");
1293
1294                    query.append("mbMessage.createDate ASC, ");
1295                    query.append("mbMessage.messageId ASC");
1296                }
1297
1298                Query q = session.createQuery(query.toString());
1299
1300                QueryPos qPos = QueryPos.getInstance(q);
1301
1302                qPos.add(groupId);
1303
1304                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
1305                        end);
1306            }
1307            catch (Exception e) {
1308                throw processException(e);
1309            }
1310            finally {
1311                if (list == null) {
1312                    list = new ArrayList<MBMessage>();
1313                }
1314
1315                cacheResult(list);
1316
1317                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
1318                    finderArgs, list);
1319
1320                closeSession(session);
1321            }
1322        }
1323
1324        return list;
1325    }
1326
1327    public MBMessage findByGroupId_First(long groupId, OrderByComparator obc)
1328        throws NoSuchMessageException, SystemException {
1329        List<MBMessage> list = findByGroupId(groupId, 0, 1, obc);
1330
1331        if (list.isEmpty()) {
1332            StringBuilder msg = new StringBuilder();
1333
1334            msg.append("No MBMessage exists with the key {");
1335
1336            msg.append("groupId=" + groupId);
1337
1338            msg.append(StringPool.CLOSE_CURLY_BRACE);
1339
1340            throw new NoSuchMessageException(msg.toString());
1341        }
1342        else {
1343            return list.get(0);
1344        }
1345    }
1346
1347    public MBMessage findByGroupId_Last(long groupId, OrderByComparator obc)
1348        throws NoSuchMessageException, SystemException {
1349        int count = countByGroupId(groupId);
1350
1351        List<MBMessage> list = findByGroupId(groupId, count - 1, count, obc);
1352
1353        if (list.isEmpty()) {
1354            StringBuilder msg = new StringBuilder();
1355
1356            msg.append("No MBMessage exists with the key {");
1357
1358            msg.append("groupId=" + groupId);
1359
1360            msg.append(StringPool.CLOSE_CURLY_BRACE);
1361
1362            throw new NoSuchMessageException(msg.toString());
1363        }
1364        else {
1365            return list.get(0);
1366        }
1367    }
1368
1369    public MBMessage[] findByGroupId_PrevAndNext(long messageId, long groupId,
1370        OrderByComparator obc) throws NoSuchMessageException, SystemException {
1371        MBMessage mbMessage = findByPrimaryKey(messageId);
1372
1373        int count = countByGroupId(groupId);
1374
1375        Session session = null;
1376
1377        try {
1378            session = openSession();
1379
1380            StringBuilder query = new StringBuilder();
1381
1382            query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1383
1384            query.append("mbMessage.groupId = ?");
1385
1386            query.append(" ");
1387
1388            if (obc != null) {
1389                query.append("ORDER BY ");
1390
1391                String[] orderByFields = obc.getOrderByFields();
1392
1393                for (int i = 0; i < orderByFields.length; i++) {
1394                    query.append("mbMessage.");
1395                    query.append(orderByFields[i]);
1396
1397                    if (obc.isAscending()) {
1398                        query.append(" ASC");
1399                    }
1400                    else {
1401                        query.append(" DESC");
1402                    }
1403
1404                    if ((i + 1) < orderByFields.length) {
1405                        query.append(", ");
1406                    }
1407                }
1408            }
1409
1410            else {
1411                query.append("ORDER BY ");
1412
1413                query.append("mbMessage.createDate ASC, ");
1414                query.append("mbMessage.messageId ASC");
1415            }
1416
1417            Query q = session.createQuery(query.toString());
1418
1419            QueryPos qPos = QueryPos.getInstance(q);
1420
1421            qPos.add(groupId);
1422
1423            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1424                    mbMessage);
1425
1426            MBMessage[] array = new MBMessageImpl[3];
1427
1428            array[0] = (MBMessage)objArray[0];
1429            array[1] = (MBMessage)objArray[1];
1430            array[2] = (MBMessage)objArray[2];
1431
1432            return array;
1433        }
1434        catch (Exception e) {
1435            throw processException(e);
1436        }
1437        finally {
1438            closeSession(session);
1439        }
1440    }
1441
1442    public List<MBMessage> findByCategoryId(long categoryId)
1443        throws SystemException {
1444        Object[] finderArgs = new Object[] { new Long(categoryId) };
1445
1446        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_CATEGORYID,
1447                finderArgs, this);
1448
1449        if (list == null) {
1450            Session session = null;
1451
1452            try {
1453                session = openSession();
1454
1455                StringBuilder query = new StringBuilder();
1456
1457                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1458
1459                query.append("mbMessage.categoryId = ?");
1460
1461                query.append(" ");
1462
1463                query.append("ORDER BY ");
1464
1465                query.append("mbMessage.createDate ASC, ");
1466                query.append("mbMessage.messageId ASC");
1467
1468                Query q = session.createQuery(query.toString());
1469
1470                QueryPos qPos = QueryPos.getInstance(q);
1471
1472                qPos.add(categoryId);
1473
1474                list = q.list();
1475            }
1476            catch (Exception e) {
1477                throw processException(e);
1478            }
1479            finally {
1480                if (list == null) {
1481                    list = new ArrayList<MBMessage>();
1482                }
1483
1484                cacheResult(list);
1485
1486                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_CATEGORYID,
1487                    finderArgs, list);
1488
1489                closeSession(session);
1490            }
1491        }
1492
1493        return list;
1494    }
1495
1496    public List<MBMessage> findByCategoryId(long categoryId, int start, int end)
1497        throws SystemException {
1498        return findByCategoryId(categoryId, start, end, null);
1499    }
1500
1501    public List<MBMessage> findByCategoryId(long categoryId, int start,
1502        int end, OrderByComparator obc) throws SystemException {
1503        Object[] finderArgs = new Object[] {
1504                new Long(categoryId),
1505                
1506                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1507            };
1508
1509        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_CATEGORYID,
1510                finderArgs, this);
1511
1512        if (list == null) {
1513            Session session = null;
1514
1515            try {
1516                session = openSession();
1517
1518                StringBuilder query = new StringBuilder();
1519
1520                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1521
1522                query.append("mbMessage.categoryId = ?");
1523
1524                query.append(" ");
1525
1526                if (obc != null) {
1527                    query.append("ORDER BY ");
1528
1529                    String[] orderByFields = obc.getOrderByFields();
1530
1531                    for (int i = 0; i < orderByFields.length; i++) {
1532                        query.append("mbMessage.");
1533                        query.append(orderByFields[i]);
1534
1535                        if (obc.isAscending()) {
1536                            query.append(" ASC");
1537                        }
1538                        else {
1539                            query.append(" DESC");
1540                        }
1541
1542                        if ((i + 1) < orderByFields.length) {
1543                            query.append(", ");
1544                        }
1545                    }
1546                }
1547
1548                else {
1549                    query.append("ORDER BY ");
1550
1551                    query.append("mbMessage.createDate ASC, ");
1552                    query.append("mbMessage.messageId ASC");
1553                }
1554
1555                Query q = session.createQuery(query.toString());
1556
1557                QueryPos qPos = QueryPos.getInstance(q);
1558
1559                qPos.add(categoryId);
1560
1561                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
1562                        end);
1563            }
1564            catch (Exception e) {
1565                throw processException(e);
1566            }
1567            finally {
1568                if (list == null) {
1569                    list = new ArrayList<MBMessage>();
1570                }
1571
1572                cacheResult(list);
1573
1574                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_CATEGORYID,
1575                    finderArgs, list);
1576
1577                closeSession(session);
1578            }
1579        }
1580
1581        return list;
1582    }
1583
1584    public MBMessage findByCategoryId_First(long categoryId,
1585        OrderByComparator obc) throws NoSuchMessageException, SystemException {
1586        List<MBMessage> list = findByCategoryId(categoryId, 0, 1, obc);
1587
1588        if (list.isEmpty()) {
1589            StringBuilder msg = new StringBuilder();
1590
1591            msg.append("No MBMessage exists with the key {");
1592
1593            msg.append("categoryId=" + categoryId);
1594
1595            msg.append(StringPool.CLOSE_CURLY_BRACE);
1596
1597            throw new NoSuchMessageException(msg.toString());
1598        }
1599        else {
1600            return list.get(0);
1601        }
1602    }
1603
1604    public MBMessage findByCategoryId_Last(long categoryId,
1605        OrderByComparator obc) throws NoSuchMessageException, SystemException {
1606        int count = countByCategoryId(categoryId);
1607
1608        List<MBMessage> list = findByCategoryId(categoryId, count - 1, count,
1609                obc);
1610
1611        if (list.isEmpty()) {
1612            StringBuilder msg = new StringBuilder();
1613
1614            msg.append("No MBMessage exists with the key {");
1615
1616            msg.append("categoryId=" + categoryId);
1617
1618            msg.append(StringPool.CLOSE_CURLY_BRACE);
1619
1620            throw new NoSuchMessageException(msg.toString());
1621        }
1622        else {
1623            return list.get(0);
1624        }
1625    }
1626
1627    public MBMessage[] findByCategoryId_PrevAndNext(long messageId,
1628        long categoryId, OrderByComparator obc)
1629        throws NoSuchMessageException, SystemException {
1630        MBMessage mbMessage = findByPrimaryKey(messageId);
1631
1632        int count = countByCategoryId(categoryId);
1633
1634        Session session = null;
1635
1636        try {
1637            session = openSession();
1638
1639            StringBuilder query = new StringBuilder();
1640
1641            query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1642
1643            query.append("mbMessage.categoryId = ?");
1644
1645            query.append(" ");
1646
1647            if (obc != null) {
1648                query.append("ORDER BY ");
1649
1650                String[] orderByFields = obc.getOrderByFields();
1651
1652                for (int i = 0; i < orderByFields.length; i++) {
1653                    query.append("mbMessage.");
1654                    query.append(orderByFields[i]);
1655
1656                    if (obc.isAscending()) {
1657                        query.append(" ASC");
1658                    }
1659                    else {
1660                        query.append(" DESC");
1661                    }
1662
1663                    if ((i + 1) < orderByFields.length) {
1664                        query.append(", ");
1665                    }
1666                }
1667            }
1668
1669            else {
1670                query.append("ORDER BY ");
1671
1672                query.append("mbMessage.createDate ASC, ");
1673                query.append("mbMessage.messageId ASC");
1674            }
1675
1676            Query q = session.createQuery(query.toString());
1677
1678            QueryPos qPos = QueryPos.getInstance(q);
1679
1680            qPos.add(categoryId);
1681
1682            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1683                    mbMessage);
1684
1685            MBMessage[] array = new MBMessageImpl[3];
1686
1687            array[0] = (MBMessage)objArray[0];
1688            array[1] = (MBMessage)objArray[1];
1689            array[2] = (MBMessage)objArray[2];
1690
1691            return array;
1692        }
1693        catch (Exception e) {
1694            throw processException(e);
1695        }
1696        finally {
1697            closeSession(session);
1698        }
1699    }
1700
1701    public List<MBMessage> findByThreadId(long threadId)
1702        throws SystemException {
1703        Object[] finderArgs = new Object[] { new Long(threadId) };
1704
1705        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_THREADID,
1706                finderArgs, this);
1707
1708        if (list == null) {
1709            Session session = null;
1710
1711            try {
1712                session = openSession();
1713
1714                StringBuilder query = new StringBuilder();
1715
1716                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1717
1718                query.append("mbMessage.threadId = ?");
1719
1720                query.append(" ");
1721
1722                query.append("ORDER BY ");
1723
1724                query.append("mbMessage.createDate ASC, ");
1725                query.append("mbMessage.messageId ASC");
1726
1727                Query q = session.createQuery(query.toString());
1728
1729                QueryPos qPos = QueryPos.getInstance(q);
1730
1731                qPos.add(threadId);
1732
1733                list = q.list();
1734            }
1735            catch (Exception e) {
1736                throw processException(e);
1737            }
1738            finally {
1739                if (list == null) {
1740                    list = new ArrayList<MBMessage>();
1741                }
1742
1743                cacheResult(list);
1744
1745                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_THREADID,
1746                    finderArgs, list);
1747
1748                closeSession(session);
1749            }
1750        }
1751
1752        return list;
1753    }
1754
1755    public List<MBMessage> findByThreadId(long threadId, int start, int end)
1756        throws SystemException {
1757        return findByThreadId(threadId, start, end, null);
1758    }
1759
1760    public List<MBMessage> findByThreadId(long threadId, int start, int end,
1761        OrderByComparator obc) throws SystemException {
1762        Object[] finderArgs = new Object[] {
1763                new Long(threadId),
1764                
1765                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1766            };
1767
1768        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_THREADID,
1769                finderArgs, this);
1770
1771        if (list == null) {
1772            Session session = null;
1773
1774            try {
1775                session = openSession();
1776
1777                StringBuilder query = new StringBuilder();
1778
1779                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1780
1781                query.append("mbMessage.threadId = ?");
1782
1783                query.append(" ");
1784
1785                if (obc != null) {
1786                    query.append("ORDER BY ");
1787
1788                    String[] orderByFields = obc.getOrderByFields();
1789
1790                    for (int i = 0; i < orderByFields.length; i++) {
1791                        query.append("mbMessage.");
1792                        query.append(orderByFields[i]);
1793
1794                        if (obc.isAscending()) {
1795                            query.append(" ASC");
1796                        }
1797                        else {
1798                            query.append(" DESC");
1799                        }
1800
1801                        if ((i + 1) < orderByFields.length) {
1802                            query.append(", ");
1803                        }
1804                    }
1805                }
1806
1807                else {
1808                    query.append("ORDER BY ");
1809
1810                    query.append("mbMessage.createDate ASC, ");
1811                    query.append("mbMessage.messageId ASC");
1812                }
1813
1814                Query q = session.createQuery(query.toString());
1815
1816                QueryPos qPos = QueryPos.getInstance(q);
1817
1818                qPos.add(threadId);
1819
1820                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
1821                        end);
1822            }
1823            catch (Exception e) {
1824                throw processException(e);
1825            }
1826            finally {
1827                if (list == null) {
1828                    list = new ArrayList<MBMessage>();
1829                }
1830
1831                cacheResult(list);
1832
1833                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_THREADID,
1834                    finderArgs, list);
1835
1836                closeSession(session);
1837            }
1838        }
1839
1840        return list;
1841    }
1842
1843    public MBMessage findByThreadId_First(long threadId, OrderByComparator obc)
1844        throws NoSuchMessageException, SystemException {
1845        List<MBMessage> list = findByThreadId(threadId, 0, 1, obc);
1846
1847        if (list.isEmpty()) {
1848            StringBuilder msg = new StringBuilder();
1849
1850            msg.append("No MBMessage exists with the key {");
1851
1852            msg.append("threadId=" + threadId);
1853
1854            msg.append(StringPool.CLOSE_CURLY_BRACE);
1855
1856            throw new NoSuchMessageException(msg.toString());
1857        }
1858        else {
1859            return list.get(0);
1860        }
1861    }
1862
1863    public MBMessage findByThreadId_Last(long threadId, OrderByComparator obc)
1864        throws NoSuchMessageException, SystemException {
1865        int count = countByThreadId(threadId);
1866
1867        List<MBMessage> list = findByThreadId(threadId, count - 1, count, obc);
1868
1869        if (list.isEmpty()) {
1870            StringBuilder msg = new StringBuilder();
1871
1872            msg.append("No MBMessage exists with the key {");
1873
1874            msg.append("threadId=" + threadId);
1875
1876            msg.append(StringPool.CLOSE_CURLY_BRACE);
1877
1878            throw new NoSuchMessageException(msg.toString());
1879        }
1880        else {
1881            return list.get(0);
1882        }
1883    }
1884
1885    public MBMessage[] findByThreadId_PrevAndNext(long messageId,
1886        long threadId, OrderByComparator obc)
1887        throws NoSuchMessageException, SystemException {
1888        MBMessage mbMessage = findByPrimaryKey(messageId);
1889
1890        int count = countByThreadId(threadId);
1891
1892        Session session = null;
1893
1894        try {
1895            session = openSession();
1896
1897            StringBuilder query = new StringBuilder();
1898
1899            query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1900
1901            query.append("mbMessage.threadId = ?");
1902
1903            query.append(" ");
1904
1905            if (obc != null) {
1906                query.append("ORDER BY ");
1907
1908                String[] orderByFields = obc.getOrderByFields();
1909
1910                for (int i = 0; i < orderByFields.length; i++) {
1911                    query.append("mbMessage.");
1912                    query.append(orderByFields[i]);
1913
1914                    if (obc.isAscending()) {
1915                        query.append(" ASC");
1916                    }
1917                    else {
1918                        query.append(" DESC");
1919                    }
1920
1921                    if ((i + 1) < orderByFields.length) {
1922                        query.append(", ");
1923                    }
1924                }
1925            }
1926
1927            else {
1928                query.append("ORDER BY ");
1929
1930                query.append("mbMessage.createDate ASC, ");
1931                query.append("mbMessage.messageId ASC");
1932            }
1933
1934            Query q = session.createQuery(query.toString());
1935
1936            QueryPos qPos = QueryPos.getInstance(q);
1937
1938            qPos.add(threadId);
1939
1940            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1941                    mbMessage);
1942
1943            MBMessage[] array = new MBMessageImpl[3];
1944
1945            array[0] = (MBMessage)objArray[0];
1946            array[1] = (MBMessage)objArray[1];
1947            array[2] = (MBMessage)objArray[2];
1948
1949            return array;
1950        }
1951        catch (Exception e) {
1952            throw processException(e);
1953        }
1954        finally {
1955            closeSession(session);
1956        }
1957    }
1958
1959    public List<MBMessage> findByThreadReplies(long threadId)
1960        throws SystemException {
1961        Object[] finderArgs = new Object[] { new Long(threadId) };
1962
1963        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_THREADREPLIES,
1964                finderArgs, this);
1965
1966        if (list == null) {
1967            Session session = null;
1968
1969            try {
1970                session = openSession();
1971
1972                StringBuilder query = new StringBuilder();
1973
1974                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
1975
1976                query.append("mbMessage.threadId = ?");
1977
1978                query.append(" AND parentMessageId != 0 ");
1979
1980                query.append("ORDER BY ");
1981
1982                query.append("mbMessage.createDate ASC, ");
1983                query.append("mbMessage.messageId ASC");
1984
1985                Query q = session.createQuery(query.toString());
1986
1987                QueryPos qPos = QueryPos.getInstance(q);
1988
1989                qPos.add(threadId);
1990
1991                list = q.list();
1992            }
1993            catch (Exception e) {
1994                throw processException(e);
1995            }
1996            finally {
1997                if (list == null) {
1998                    list = new ArrayList<MBMessage>();
1999                }
2000
2001                cacheResult(list);
2002
2003                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_THREADREPLIES,
2004                    finderArgs, list);
2005
2006                closeSession(session);
2007            }
2008        }
2009
2010        return list;
2011    }
2012
2013    public List<MBMessage> findByThreadReplies(long threadId, int start, int end)
2014        throws SystemException {
2015        return findByThreadReplies(threadId, start, end, null);
2016    }
2017
2018    public List<MBMessage> findByThreadReplies(long threadId, int start,
2019        int end, OrderByComparator obc) throws SystemException {
2020        Object[] finderArgs = new Object[] {
2021                new Long(threadId),
2022                
2023                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2024            };
2025
2026        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_THREADREPLIES,
2027                finderArgs, this);
2028
2029        if (list == null) {
2030            Session session = null;
2031
2032            try {
2033                session = openSession();
2034
2035                StringBuilder query = new StringBuilder();
2036
2037                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
2038
2039                query.append("mbMessage.threadId = ?");
2040
2041                query.append(" AND parentMessageId != 0 ");
2042
2043                if (obc != null) {
2044                    query.append("ORDER BY ");
2045
2046                    String[] orderByFields = obc.getOrderByFields();
2047
2048                    for (int i = 0; i < orderByFields.length; i++) {
2049                        query.append("mbMessage.");
2050                        query.append(orderByFields[i]);
2051
2052                        if (obc.isAscending()) {
2053                            query.append(" ASC");
2054                        }
2055                        else {
2056                            query.append(" DESC");
2057                        }
2058
2059                        if ((i + 1) < orderByFields.length) {
2060                            query.append(", ");
2061                        }
2062                    }
2063                }
2064
2065                else {
2066                    query.append("ORDER BY ");
2067
2068                    query.append("mbMessage.createDate ASC, ");
2069                    query.append("mbMessage.messageId ASC");
2070                }
2071
2072                Query q = session.createQuery(query.toString());
2073
2074                QueryPos qPos = QueryPos.getInstance(q);
2075
2076                qPos.add(threadId);
2077
2078                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
2079                        end);
2080            }
2081            catch (Exception e) {
2082                throw processException(e);
2083            }
2084            finally {
2085                if (list == null) {
2086                    list = new ArrayList<MBMessage>();
2087                }
2088
2089                cacheResult(list);
2090
2091                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_THREADREPLIES,
2092                    finderArgs, list);
2093
2094                closeSession(session);
2095            }
2096        }
2097
2098        return list;
2099    }
2100
2101    public MBMessage findByThreadReplies_First(long threadId,
2102        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2103        List<MBMessage> list = findByThreadReplies(threadId, 0, 1, obc);
2104
2105        if (list.isEmpty()) {
2106            StringBuilder msg = new StringBuilder();
2107
2108            msg.append("No MBMessage exists with the key {");
2109
2110            msg.append("threadId=" + threadId);
2111
2112            msg.append(StringPool.CLOSE_CURLY_BRACE);
2113
2114            throw new NoSuchMessageException(msg.toString());
2115        }
2116        else {
2117            return list.get(0);
2118        }
2119    }
2120
2121    public MBMessage findByThreadReplies_Last(long threadId,
2122        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2123        int count = countByThreadReplies(threadId);
2124
2125        List<MBMessage> list = findByThreadReplies(threadId, count - 1, count,
2126                obc);
2127
2128        if (list.isEmpty()) {
2129            StringBuilder msg = new StringBuilder();
2130
2131            msg.append("No MBMessage exists with the key {");
2132
2133            msg.append("threadId=" + threadId);
2134
2135            msg.append(StringPool.CLOSE_CURLY_BRACE);
2136
2137            throw new NoSuchMessageException(msg.toString());
2138        }
2139        else {
2140            return list.get(0);
2141        }
2142    }
2143
2144    public MBMessage[] findByThreadReplies_PrevAndNext(long messageId,
2145        long threadId, OrderByComparator obc)
2146        throws NoSuchMessageException, SystemException {
2147        MBMessage mbMessage = findByPrimaryKey(messageId);
2148
2149        int count = countByThreadReplies(threadId);
2150
2151        Session session = null;
2152
2153        try {
2154            session = openSession();
2155
2156            StringBuilder query = new StringBuilder();
2157
2158            query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
2159
2160            query.append("mbMessage.threadId = ?");
2161
2162            query.append(" AND parentMessageId != 0 ");
2163
2164            if (obc != null) {
2165                query.append("ORDER BY ");
2166
2167                String[] orderByFields = obc.getOrderByFields();
2168
2169                for (int i = 0; i < orderByFields.length; i++) {
2170                    query.append("mbMessage.");
2171                    query.append(orderByFields[i]);
2172
2173                    if (obc.isAscending()) {
2174                        query.append(" ASC");
2175                    }
2176                    else {
2177                        query.append(" DESC");
2178                    }
2179
2180                    if ((i + 1) < orderByFields.length) {
2181                        query.append(", ");
2182                    }
2183                }
2184            }
2185
2186            else {
2187                query.append("ORDER BY ");
2188
2189                query.append("mbMessage.createDate ASC, ");
2190                query.append("mbMessage.messageId ASC");
2191            }
2192
2193            Query q = session.createQuery(query.toString());
2194
2195            QueryPos qPos = QueryPos.getInstance(q);
2196
2197            qPos.add(threadId);
2198
2199            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
2200                    mbMessage);
2201
2202            MBMessage[] array = new MBMessageImpl[3];
2203
2204            array[0] = (MBMessage)objArray[0];
2205            array[1] = (MBMessage)objArray[1];
2206            array[2] = (MBMessage)objArray[2];
2207
2208            return array;
2209        }
2210        catch (Exception e) {
2211            throw processException(e);
2212        }
2213        finally {
2214            closeSession(session);
2215        }
2216    }
2217
2218    public List<MBMessage> findByG_U(long groupId, long userId)
2219        throws SystemException {
2220        Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
2221
2222        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U,
2223                finderArgs, this);
2224
2225        if (list == null) {
2226            Session session = null;
2227
2228            try {
2229                session = openSession();
2230
2231                StringBuilder query = new StringBuilder();
2232
2233                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
2234
2235                query.append("mbMessage.groupId = ?");
2236
2237                query.append(" AND ");
2238
2239                query.append("mbMessage.userId = ?");
2240
2241                query.append(" ");
2242
2243                query.append("ORDER BY ");
2244
2245                query.append("mbMessage.createDate ASC, ");
2246                query.append("mbMessage.messageId ASC");
2247
2248                Query q = session.createQuery(query.toString());
2249
2250                QueryPos qPos = QueryPos.getInstance(q);
2251
2252                qPos.add(groupId);
2253
2254                qPos.add(userId);
2255
2256                list = q.list();
2257            }
2258            catch (Exception e) {
2259                throw processException(e);
2260            }
2261            finally {
2262                if (list == null) {
2263                    list = new ArrayList<MBMessage>();
2264                }
2265
2266                cacheResult(list);
2267
2268                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U, finderArgs,
2269                    list);
2270
2271                closeSession(session);
2272            }
2273        }
2274
2275        return list;
2276    }
2277
2278    public List<MBMessage> findByG_U(long groupId, long userId, int start,
2279        int end) throws SystemException {
2280        return findByG_U(groupId, userId, start, end, null);
2281    }
2282
2283    public List<MBMessage> findByG_U(long groupId, long userId, int start,
2284        int end, OrderByComparator obc) throws SystemException {
2285        Object[] finderArgs = new Object[] {
2286                new Long(groupId), new Long(userId),
2287                
2288                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2289            };
2290
2291        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_U,
2292                finderArgs, this);
2293
2294        if (list == null) {
2295            Session session = null;
2296
2297            try {
2298                session = openSession();
2299
2300                StringBuilder query = new StringBuilder();
2301
2302                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
2303
2304                query.append("mbMessage.groupId = ?");
2305
2306                query.append(" AND ");
2307
2308                query.append("mbMessage.userId = ?");
2309
2310                query.append(" ");
2311
2312                if (obc != null) {
2313                    query.append("ORDER BY ");
2314
2315                    String[] orderByFields = obc.getOrderByFields();
2316
2317                    for (int i = 0; i < orderByFields.length; i++) {
2318                        query.append("mbMessage.");
2319                        query.append(orderByFields[i]);
2320
2321                        if (obc.isAscending()) {
2322                            query.append(" ASC");
2323                        }
2324                        else {
2325                            query.append(" DESC");
2326                        }
2327
2328                        if ((i + 1) < orderByFields.length) {
2329                            query.append(", ");
2330                        }
2331                    }
2332                }
2333
2334                else {
2335                    query.append("ORDER BY ");
2336
2337                    query.append("mbMessage.createDate ASC, ");
2338                    query.append("mbMessage.messageId ASC");
2339                }
2340
2341                Query q = session.createQuery(query.toString());
2342
2343                QueryPos qPos = QueryPos.getInstance(q);
2344
2345                qPos.add(groupId);
2346
2347                qPos.add(userId);
2348
2349                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
2350                        end);
2351            }
2352            catch (Exception e) {
2353                throw processException(e);
2354            }
2355            finally {
2356                if (list == null) {
2357                    list = new ArrayList<MBMessage>();
2358                }
2359
2360                cacheResult(list);
2361
2362                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_U,
2363                    finderArgs, list);
2364
2365                closeSession(session);
2366            }
2367        }
2368
2369        return list;
2370    }
2371
2372    public MBMessage findByG_U_First(long groupId, long userId,
2373        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2374        List<MBMessage> list = findByG_U(groupId, userId, 0, 1, obc);
2375
2376        if (list.isEmpty()) {
2377            StringBuilder msg = new StringBuilder();
2378
2379            msg.append("No MBMessage exists with the key {");
2380
2381            msg.append("groupId=" + groupId);
2382
2383            msg.append(", ");
2384            msg.append("userId=" + userId);
2385
2386            msg.append(StringPool.CLOSE_CURLY_BRACE);
2387
2388            throw new NoSuchMessageException(msg.toString());
2389        }
2390        else {
2391            return list.get(0);
2392        }
2393    }
2394
2395    public MBMessage findByG_U_Last(long groupId, long userId,
2396        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2397        int count = countByG_U(groupId, userId);
2398
2399        List<MBMessage> list = findByG_U(groupId, userId, count - 1, count, obc);
2400
2401        if (list.isEmpty()) {
2402            StringBuilder msg = new StringBuilder();
2403
2404            msg.append("No MBMessage exists with the key {");
2405
2406            msg.append("groupId=" + groupId);
2407
2408            msg.append(", ");
2409            msg.append("userId=" + userId);
2410
2411            msg.append(StringPool.CLOSE_CURLY_BRACE);
2412
2413            throw new NoSuchMessageException(msg.toString());
2414        }
2415        else {
2416            return list.get(0);
2417        }
2418    }
2419
2420    public MBMessage[] findByG_U_PrevAndNext(long messageId, long groupId,
2421        long userId, OrderByComparator obc)
2422        throws NoSuchMessageException, SystemException {
2423        MBMessage mbMessage = findByPrimaryKey(messageId);
2424
2425        int count = countByG_U(groupId, userId);
2426
2427        Session session = null;
2428
2429        try {
2430            session = openSession();
2431
2432            StringBuilder query = new StringBuilder();
2433
2434            query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
2435
2436            query.append("mbMessage.groupId = ?");
2437
2438            query.append(" AND ");
2439
2440            query.append("mbMessage.userId = ?");
2441
2442            query.append(" ");
2443
2444            if (obc != null) {
2445                query.append("ORDER BY ");
2446
2447                String[] orderByFields = obc.getOrderByFields();
2448
2449                for (int i = 0; i < orderByFields.length; i++) {
2450                    query.append("mbMessage.");
2451                    query.append(orderByFields[i]);
2452
2453                    if (obc.isAscending()) {
2454                        query.append(" ASC");
2455                    }
2456                    else {
2457                        query.append(" DESC");
2458                    }
2459
2460                    if ((i + 1) < orderByFields.length) {
2461                        query.append(", ");
2462                    }
2463                }
2464            }
2465
2466            else {
2467                query.append("ORDER BY ");
2468
2469                query.append("mbMessage.createDate ASC, ");
2470                query.append("mbMessage.messageId ASC");
2471            }
2472
2473            Query q = session.createQuery(query.toString());
2474
2475            QueryPos qPos = QueryPos.getInstance(q);
2476
2477            qPos.add(groupId);
2478
2479            qPos.add(userId);
2480
2481            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
2482                    mbMessage);
2483
2484            MBMessage[] array = new MBMessageImpl[3];
2485
2486            array[0] = (MBMessage)objArray[0];
2487            array[1] = (MBMessage)objArray[1];
2488            array[2] = (MBMessage)objArray[2];
2489
2490            return array;
2491        }
2492        catch (Exception e) {
2493            throw processException(e);
2494        }
2495        finally {
2496            closeSession(session);
2497        }
2498    }
2499
2500    public List<MBMessage> findByC_C(long classNameId, long classPK)
2501        throws SystemException {
2502        Object[] finderArgs = new Object[] {
2503                new Long(classNameId), new Long(classPK)
2504            };
2505
2506        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_C,
2507                finderArgs, this);
2508
2509        if (list == null) {
2510            Session session = null;
2511
2512            try {
2513                session = openSession();
2514
2515                StringBuilder query = new StringBuilder();
2516
2517                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
2518
2519                query.append("mbMessage.classNameId = ?");
2520
2521                query.append(" AND ");
2522
2523                query.append("mbMessage.classPK = ?");
2524
2525                query.append(" ");
2526
2527                query.append("ORDER BY ");
2528
2529                query.append("mbMessage.createDate ASC, ");
2530                query.append("mbMessage.messageId ASC");
2531
2532                Query q = session.createQuery(query.toString());
2533
2534                QueryPos qPos = QueryPos.getInstance(q);
2535
2536                qPos.add(classNameId);
2537
2538                qPos.add(classPK);
2539
2540                list = q.list();
2541            }
2542            catch (Exception e) {
2543                throw processException(e);
2544            }
2545            finally {
2546                if (list == null) {
2547                    list = new ArrayList<MBMessage>();
2548                }
2549
2550                cacheResult(list);
2551
2552                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_C, finderArgs,
2553                    list);
2554
2555                closeSession(session);
2556            }
2557        }
2558
2559        return list;
2560    }
2561
2562    public List<MBMessage> findByC_C(long classNameId, long classPK, int start,
2563        int end) throws SystemException {
2564        return findByC_C(classNameId, classPK, start, end, null);
2565    }
2566
2567    public List<MBMessage> findByC_C(long classNameId, long classPK, int start,
2568        int end, OrderByComparator obc) throws SystemException {
2569        Object[] finderArgs = new Object[] {
2570                new Long(classNameId), new Long(classPK),
2571                
2572                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2573            };
2574
2575        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_C_C,
2576                finderArgs, this);
2577
2578        if (list == null) {
2579            Session session = null;
2580
2581            try {
2582                session = openSession();
2583
2584                StringBuilder query = new StringBuilder();
2585
2586                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
2587
2588                query.append("mbMessage.classNameId = ?");
2589
2590                query.append(" AND ");
2591
2592                query.append("mbMessage.classPK = ?");
2593
2594                query.append(" ");
2595
2596                if (obc != null) {
2597                    query.append("ORDER BY ");
2598
2599                    String[] orderByFields = obc.getOrderByFields();
2600
2601                    for (int i = 0; i < orderByFields.length; i++) {
2602                        query.append("mbMessage.");
2603                        query.append(orderByFields[i]);
2604
2605                        if (obc.isAscending()) {
2606                            query.append(" ASC");
2607                        }
2608                        else {
2609                            query.append(" DESC");
2610                        }
2611
2612                        if ((i + 1) < orderByFields.length) {
2613                            query.append(", ");
2614                        }
2615                    }
2616                }
2617
2618                else {
2619                    query.append("ORDER BY ");
2620
2621                    query.append("mbMessage.createDate ASC, ");
2622                    query.append("mbMessage.messageId ASC");
2623                }
2624
2625                Query q = session.createQuery(query.toString());
2626
2627                QueryPos qPos = QueryPos.getInstance(q);
2628
2629                qPos.add(classNameId);
2630
2631                qPos.add(classPK);
2632
2633                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
2634                        end);
2635            }
2636            catch (Exception e) {
2637                throw processException(e);
2638            }
2639            finally {
2640                if (list == null) {
2641                    list = new ArrayList<MBMessage>();
2642                }
2643
2644                cacheResult(list);
2645
2646                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_C_C,
2647                    finderArgs, list);
2648
2649                closeSession(session);
2650            }
2651        }
2652
2653        return list;
2654    }
2655
2656    public MBMessage findByC_C_First(long classNameId, long classPK,
2657        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2658        List<MBMessage> list = findByC_C(classNameId, classPK, 0, 1, obc);
2659
2660        if (list.isEmpty()) {
2661            StringBuilder msg = new StringBuilder();
2662
2663            msg.append("No MBMessage exists with the key {");
2664
2665            msg.append("classNameId=" + classNameId);
2666
2667            msg.append(", ");
2668            msg.append("classPK=" + classPK);
2669
2670            msg.append(StringPool.CLOSE_CURLY_BRACE);
2671
2672            throw new NoSuchMessageException(msg.toString());
2673        }
2674        else {
2675            return list.get(0);
2676        }
2677    }
2678
2679    public MBMessage findByC_C_Last(long classNameId, long classPK,
2680        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2681        int count = countByC_C(classNameId, classPK);
2682
2683        List<MBMessage> list = findByC_C(classNameId, classPK, count - 1,
2684                count, obc);
2685
2686        if (list.isEmpty()) {
2687            StringBuilder msg = new StringBuilder();
2688
2689            msg.append("No MBMessage exists with the key {");
2690
2691            msg.append("classNameId=" + classNameId);
2692
2693            msg.append(", ");
2694            msg.append("classPK=" + classPK);
2695
2696            msg.append(StringPool.CLOSE_CURLY_BRACE);
2697
2698            throw new NoSuchMessageException(msg.toString());
2699        }
2700        else {
2701            return list.get(0);
2702        }
2703    }
2704
2705    public MBMessage[] findByC_C_PrevAndNext(long messageId, long classNameId,
2706        long classPK, OrderByComparator obc)
2707        throws NoSuchMessageException, SystemException {
2708        MBMessage mbMessage = findByPrimaryKey(messageId);
2709
2710        int count = countByC_C(classNameId, classPK);
2711
2712        Session session = null;
2713
2714        try {
2715            session = openSession();
2716
2717            StringBuilder query = new StringBuilder();
2718
2719            query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
2720
2721            query.append("mbMessage.classNameId = ?");
2722
2723            query.append(" AND ");
2724
2725            query.append("mbMessage.classPK = ?");
2726
2727            query.append(" ");
2728
2729            if (obc != null) {
2730                query.append("ORDER BY ");
2731
2732                String[] orderByFields = obc.getOrderByFields();
2733
2734                for (int i = 0; i < orderByFields.length; i++) {
2735                    query.append("mbMessage.");
2736                    query.append(orderByFields[i]);
2737
2738                    if (obc.isAscending()) {
2739                        query.append(" ASC");
2740                    }
2741                    else {
2742                        query.append(" DESC");
2743                    }
2744
2745                    if ((i + 1) < orderByFields.length) {
2746                        query.append(", ");
2747                    }
2748                }
2749            }
2750
2751            else {
2752                query.append("ORDER BY ");
2753
2754                query.append("mbMessage.createDate ASC, ");
2755                query.append("mbMessage.messageId ASC");
2756            }
2757
2758            Query q = session.createQuery(query.toString());
2759
2760            QueryPos qPos = QueryPos.getInstance(q);
2761
2762            qPos.add(classNameId);
2763
2764            qPos.add(classPK);
2765
2766            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
2767                    mbMessage);
2768
2769            MBMessage[] array = new MBMessageImpl[3];
2770
2771            array[0] = (MBMessage)objArray[0];
2772            array[1] = (MBMessage)objArray[1];
2773            array[2] = (MBMessage)objArray[2];
2774
2775            return array;
2776        }
2777        catch (Exception e) {
2778            throw processException(e);
2779        }
2780        finally {
2781            closeSession(session);
2782        }
2783    }
2784
2785    public List<MBMessage> findByC_T(long categoryId, long threadId)
2786        throws SystemException {
2787        Object[] finderArgs = new Object[] {
2788                new Long(categoryId), new Long(threadId)
2789            };
2790
2791        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_T,
2792                finderArgs, this);
2793
2794        if (list == null) {
2795            Session session = null;
2796
2797            try {
2798                session = openSession();
2799
2800                StringBuilder query = new StringBuilder();
2801
2802                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
2803
2804                query.append("mbMessage.categoryId = ?");
2805
2806                query.append(" AND ");
2807
2808                query.append("mbMessage.threadId = ?");
2809
2810                query.append(" ");
2811
2812                query.append("ORDER BY ");
2813
2814                query.append("mbMessage.createDate ASC, ");
2815                query.append("mbMessage.messageId ASC");
2816
2817                Query q = session.createQuery(query.toString());
2818
2819                QueryPos qPos = QueryPos.getInstance(q);
2820
2821                qPos.add(categoryId);
2822
2823                qPos.add(threadId);
2824
2825                list = q.list();
2826            }
2827            catch (Exception e) {
2828                throw processException(e);
2829            }
2830            finally {
2831                if (list == null) {
2832                    list = new ArrayList<MBMessage>();
2833                }
2834
2835                cacheResult(list);
2836
2837                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_T, finderArgs,
2838                    list);
2839
2840                closeSession(session);
2841            }
2842        }
2843
2844        return list;
2845    }
2846
2847    public List<MBMessage> findByC_T(long categoryId, long threadId, int start,
2848        int end) throws SystemException {
2849        return findByC_T(categoryId, threadId, start, end, null);
2850    }
2851
2852    public List<MBMessage> findByC_T(long categoryId, long threadId, int start,
2853        int end, OrderByComparator obc) throws SystemException {
2854        Object[] finderArgs = new Object[] {
2855                new Long(categoryId), new Long(threadId),
2856                
2857                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2858            };
2859
2860        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_C_T,
2861                finderArgs, this);
2862
2863        if (list == null) {
2864            Session session = null;
2865
2866            try {
2867                session = openSession();
2868
2869                StringBuilder query = new StringBuilder();
2870
2871                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
2872
2873                query.append("mbMessage.categoryId = ?");
2874
2875                query.append(" AND ");
2876
2877                query.append("mbMessage.threadId = ?");
2878
2879                query.append(" ");
2880
2881                if (obc != null) {
2882                    query.append("ORDER BY ");
2883
2884                    String[] orderByFields = obc.getOrderByFields();
2885
2886                    for (int i = 0; i < orderByFields.length; i++) {
2887                        query.append("mbMessage.");
2888                        query.append(orderByFields[i]);
2889
2890                        if (obc.isAscending()) {
2891                            query.append(" ASC");
2892                        }
2893                        else {
2894                            query.append(" DESC");
2895                        }
2896
2897                        if ((i + 1) < orderByFields.length) {
2898                            query.append(", ");
2899                        }
2900                    }
2901                }
2902
2903                else {
2904                    query.append("ORDER BY ");
2905
2906                    query.append("mbMessage.createDate ASC, ");
2907                    query.append("mbMessage.messageId ASC");
2908                }
2909
2910                Query q = session.createQuery(query.toString());
2911
2912                QueryPos qPos = QueryPos.getInstance(q);
2913
2914                qPos.add(categoryId);
2915
2916                qPos.add(threadId);
2917
2918                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
2919                        end);
2920            }
2921            catch (Exception e) {
2922                throw processException(e);
2923            }
2924            finally {
2925                if (list == null) {
2926                    list = new ArrayList<MBMessage>();
2927                }
2928
2929                cacheResult(list);
2930
2931                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_C_T,
2932                    finderArgs, list);
2933
2934                closeSession(session);
2935            }
2936        }
2937
2938        return list;
2939    }
2940
2941    public MBMessage findByC_T_First(long categoryId, long threadId,
2942        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2943        List<MBMessage> list = findByC_T(categoryId, threadId, 0, 1, obc);
2944
2945        if (list.isEmpty()) {
2946            StringBuilder msg = new StringBuilder();
2947
2948            msg.append("No MBMessage exists with the key {");
2949
2950            msg.append("categoryId=" + categoryId);
2951
2952            msg.append(", ");
2953            msg.append("threadId=" + threadId);
2954
2955            msg.append(StringPool.CLOSE_CURLY_BRACE);
2956
2957            throw new NoSuchMessageException(msg.toString());
2958        }
2959        else {
2960            return list.get(0);
2961        }
2962    }
2963
2964    public MBMessage findByC_T_Last(long categoryId, long threadId,
2965        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2966        int count = countByC_T(categoryId, threadId);
2967
2968        List<MBMessage> list = findByC_T(categoryId, threadId, count - 1,
2969                count, obc);
2970
2971        if (list.isEmpty()) {
2972            StringBuilder msg = new StringBuilder();
2973
2974            msg.append("No MBMessage exists with the key {");
2975
2976            msg.append("categoryId=" + categoryId);
2977
2978            msg.append(", ");
2979            msg.append("threadId=" + threadId);
2980
2981            msg.append(StringPool.CLOSE_CURLY_BRACE);
2982
2983            throw new NoSuchMessageException(msg.toString());
2984        }
2985        else {
2986            return list.get(0);
2987        }
2988    }
2989
2990    public MBMessage[] findByC_T_PrevAndNext(long messageId, long categoryId,
2991        long threadId, OrderByComparator obc)
2992        throws NoSuchMessageException, SystemException {
2993        MBMessage mbMessage = findByPrimaryKey(messageId);
2994
2995        int count = countByC_T(categoryId, threadId);
2996
2997        Session session = null;
2998
2999        try {
3000            session = openSession();
3001
3002            StringBuilder query = new StringBuilder();
3003
3004            query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
3005
3006            query.append("mbMessage.categoryId = ?");
3007
3008            query.append(" AND ");
3009
3010            query.append("mbMessage.threadId = ?");
3011
3012            query.append(" ");
3013
3014            if (obc != null) {
3015                query.append("ORDER BY ");
3016
3017                String[] orderByFields = obc.getOrderByFields();
3018
3019                for (int i = 0; i < orderByFields.length; i++) {
3020                    query.append("mbMessage.");
3021                    query.append(orderByFields[i]);
3022
3023                    if (obc.isAscending()) {
3024                        query.append(" ASC");
3025                    }
3026                    else {
3027                        query.append(" DESC");
3028                    }
3029
3030                    if ((i + 1) < orderByFields.length) {
3031                        query.append(", ");
3032                    }
3033                }
3034            }
3035
3036            else {
3037                query.append("ORDER BY ");
3038
3039                query.append("mbMessage.createDate ASC, ");
3040                query.append("mbMessage.messageId ASC");
3041            }
3042
3043            Query q = session.createQuery(query.toString());
3044
3045            QueryPos qPos = QueryPos.getInstance(q);
3046
3047            qPos.add(categoryId);
3048
3049            qPos.add(threadId);
3050
3051            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
3052                    mbMessage);
3053
3054            MBMessage[] array = new MBMessageImpl[3];
3055
3056            array[0] = (MBMessage)objArray[0];
3057            array[1] = (MBMessage)objArray[1];
3058            array[2] = (MBMessage)objArray[2];
3059
3060            return array;
3061        }
3062        catch (Exception e) {
3063            throw processException(e);
3064        }
3065        finally {
3066            closeSession(session);
3067        }
3068    }
3069
3070    public List<MBMessage> findByT_P(long threadId, long parentMessageId)
3071        throws SystemException {
3072        Object[] finderArgs = new Object[] {
3073                new Long(threadId), new Long(parentMessageId)
3074            };
3075
3076        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_T_P,
3077                finderArgs, this);
3078
3079        if (list == null) {
3080            Session session = null;
3081
3082            try {
3083                session = openSession();
3084
3085                StringBuilder query = new StringBuilder();
3086
3087                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
3088
3089                query.append("mbMessage.threadId = ?");
3090
3091                query.append(" AND ");
3092
3093                query.append("mbMessage.parentMessageId = ?");
3094
3095                query.append(" ");
3096
3097                query.append("ORDER BY ");
3098
3099                query.append("mbMessage.createDate ASC, ");
3100                query.append("mbMessage.messageId ASC");
3101
3102                Query q = session.createQuery(query.toString());
3103
3104                QueryPos qPos = QueryPos.getInstance(q);
3105
3106                qPos.add(threadId);
3107
3108                qPos.add(parentMessageId);
3109
3110                list = q.list();
3111            }
3112            catch (Exception e) {
3113                throw processException(e);
3114            }
3115            finally {
3116                if (list == null) {
3117                    list = new ArrayList<MBMessage>();
3118                }
3119
3120                cacheResult(list);
3121
3122                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_T_P, finderArgs,
3123                    list);
3124
3125                closeSession(session);
3126            }
3127        }
3128
3129        return list;
3130    }
3131
3132    public List<MBMessage> findByT_P(long threadId, long parentMessageId,
3133        int start, int end) throws SystemException {
3134        return findByT_P(threadId, parentMessageId, start, end, null);
3135    }
3136
3137    public List<MBMessage> findByT_P(long threadId, long parentMessageId,
3138        int start, int end, OrderByComparator obc) throws SystemException {
3139        Object[] finderArgs = new Object[] {
3140                new Long(threadId), new Long(parentMessageId),
3141                
3142                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
3143            };
3144
3145        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_T_P,
3146                finderArgs, this);
3147
3148        if (list == null) {
3149            Session session = null;
3150
3151            try {
3152                session = openSession();
3153
3154                StringBuilder query = new StringBuilder();
3155
3156                query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
3157
3158                query.append("mbMessage.threadId = ?");
3159
3160                query.append(" AND ");
3161
3162                query.append("mbMessage.parentMessageId = ?");
3163
3164                query.append(" ");
3165
3166                if (obc != null) {
3167                    query.append("ORDER BY ");
3168
3169                    String[] orderByFields = obc.getOrderByFields();
3170
3171                    for (int i = 0; i < orderByFields.length; i++) {
3172                        query.append("mbMessage.");
3173                        query.append(orderByFields[i]);
3174
3175                        if (obc.isAscending()) {
3176                            query.append(" ASC");
3177                        }
3178                        else {
3179                            query.append(" DESC");
3180                        }
3181
3182                        if ((i + 1) < orderByFields.length) {
3183                            query.append(", ");
3184                        }
3185                    }
3186                }
3187
3188                else {
3189                    query.append("ORDER BY ");
3190
3191                    query.append("mbMessage.createDate ASC, ");
3192                    query.append("mbMessage.messageId ASC");
3193                }
3194
3195                Query q = session.createQuery(query.toString());
3196
3197                QueryPos qPos = QueryPos.getInstance(q);
3198
3199                qPos.add(threadId);
3200
3201                qPos.add(parentMessageId);
3202
3203                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
3204                        end);
3205            }
3206            catch (Exception e) {
3207                throw processException(e);
3208            }
3209            finally {
3210                if (list == null) {
3211                    list = new ArrayList<MBMessage>();
3212                }
3213
3214                cacheResult(list);
3215
3216                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_T_P,
3217                    finderArgs, list);
3218
3219                closeSession(session);
3220            }
3221        }
3222
3223        return list;
3224    }
3225
3226    public MBMessage findByT_P_First(long threadId, long parentMessageId,
3227        OrderByComparator obc) throws NoSuchMessageException, SystemException {
3228        List<MBMessage> list = findByT_P(threadId, parentMessageId, 0, 1, obc);
3229
3230        if (list.isEmpty()) {
3231            StringBuilder msg = new StringBuilder();
3232
3233            msg.append("No MBMessage exists with the key {");
3234
3235            msg.append("threadId=" + threadId);
3236
3237            msg.append(", ");
3238            msg.append("parentMessageId=" + parentMessageId);
3239
3240            msg.append(StringPool.CLOSE_CURLY_BRACE);
3241
3242            throw new NoSuchMessageException(msg.toString());
3243        }
3244        else {
3245            return list.get(0);
3246        }
3247    }
3248
3249    public MBMessage findByT_P_Last(long threadId, long parentMessageId,
3250        OrderByComparator obc) throws NoSuchMessageException, SystemException {
3251        int count = countByT_P(threadId, parentMessageId);
3252
3253        List<MBMessage> list = findByT_P(threadId, parentMessageId, count - 1,
3254                count, obc);
3255
3256        if (list.isEmpty()) {
3257            StringBuilder msg = new StringBuilder();
3258
3259            msg.append("No MBMessage exists with the key {");
3260
3261            msg.append("threadId=" + threadId);
3262
3263            msg.append(", ");
3264            msg.append("parentMessageId=" + parentMessageId);
3265
3266            msg.append(StringPool.CLOSE_CURLY_BRACE);
3267
3268            throw new NoSuchMessageException(msg.toString());
3269        }
3270        else {
3271            return list.get(0);
3272        }
3273    }
3274
3275    public MBMessage[] findByT_P_PrevAndNext(long messageId, long threadId,
3276        long parentMessageId, OrderByComparator obc)
3277        throws NoSuchMessageException, SystemException {
3278        MBMessage mbMessage = findByPrimaryKey(messageId);
3279
3280        int count = countByT_P(threadId, parentMessageId);
3281
3282        Session session = null;
3283
3284        try {
3285            session = openSession();
3286
3287            StringBuilder query = new StringBuilder();
3288
3289            query.append("SELECT mbMessage FROM MBMessage mbMessage WHERE ");
3290
3291            query.append("mbMessage.threadId = ?");
3292
3293            query.append(" AND ");
3294
3295            query.append("mbMessage.parentMessageId = ?");
3296
3297            query.append(" ");
3298
3299            if (obc != null) {
3300                query.append("ORDER BY ");
3301
3302                String[] orderByFields = obc.getOrderByFields();
3303
3304                for (int i = 0; i < orderByFields.length; i++) {
3305                    query.append("mbMessage.");
3306                    query.append(orderByFields[i]);
3307
3308                    if (obc.isAscending()) {
3309                        query.append(" ASC");
3310                    }
3311                    else {
3312                        query.append(" DESC");
3313                    }
3314
3315                    if ((i + 1) < orderByFields.length) {
3316                        query.append(", ");
3317                    }
3318                }
3319            }
3320
3321            else {
3322                query.append("ORDER BY ");
3323
3324                query.append("mbMessage.createDate ASC, ");
3325                query.append("mbMessage.messageId ASC");
3326            }
3327
3328            Query q = session.createQuery(query.toString());
3329
3330            QueryPos qPos = QueryPos.getInstance(q);
3331
3332            qPos.add(threadId);
3333
3334            qPos.add(parentMessageId);
3335
3336            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
3337                    mbMessage);
3338
3339            MBMessage[] array = new MBMessageImpl[3];
3340
3341            array[0] = (MBMessage)objArray[0];
3342            array[1] = (MBMessage)objArray[1];
3343            array[2] = (MBMessage)objArray[2];
3344
3345            return array;
3346        }
3347        catch (Exception e) {
3348            throw processException(e);
3349        }
3350        finally {
3351            closeSession(session);
3352        }
3353    }
3354
3355    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
3356        throws SystemException {
3357        Session session = null;
3358
3359        try {
3360            session = openSession();
3361
3362            dynamicQuery.compile(session);
3363
3364            return dynamicQuery.list();
3365        }
3366        catch (Exception e) {
3367            throw processException(e);
3368        }
3369        finally {
3370            closeSession(session);
3371        }
3372    }
3373
3374    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
3375        int start, int end) throws SystemException {
3376        Session session = null;
3377
3378        try {
3379            session = openSession();
3380
3381            dynamicQuery.setLimit(start, end);
3382
3383            dynamicQuery.compile(session);
3384
3385            return dynamicQuery.list();
3386        }
3387        catch (Exception e) {
3388            throw processException(e);
3389        }
3390        finally {
3391            closeSession(session);
3392        }
3393    }
3394
3395    public List<MBMessage> findAll() throws SystemException {
3396        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
3397    }
3398
3399    public List<MBMessage> findAll(int start, int end)
3400        throws SystemException {
3401        return findAll(start, end, null);
3402    }
3403
3404    public List<MBMessage> findAll(int start, int end, OrderByComparator obc)
3405        throws SystemException {
3406        Object[] finderArgs = new Object[] {
3407                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
3408            };
3409
3410        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
3411                finderArgs, this);
3412
3413        if (list == null) {
3414            Session session = null;
3415
3416            try {
3417                session = openSession();
3418
3419                StringBuilder query = new StringBuilder();
3420
3421                query.append("SELECT mbMessage FROM MBMessage mbMessage ");
3422
3423                if (obc != null) {
3424                    query.append("ORDER BY ");
3425
3426                    String[] orderByFields = obc.getOrderByFields();
3427
3428                    for (int i = 0; i < orderByFields.length; i++) {
3429                        query.append("mbMessage.");
3430                        query.append(orderByFields[i]);
3431
3432                        if (obc.isAscending()) {
3433                            query.append(" ASC");
3434                        }
3435                        else {
3436                            query.append(" DESC");
3437                        }
3438
3439                        if ((i + 1) < orderByFields.length) {
3440                            query.append(", ");
3441                        }
3442                    }
3443                }
3444
3445                else {
3446                    query.append("ORDER BY ");
3447
3448                    query.append("mbMessage.createDate ASC, ");
3449                    query.append("mbMessage.messageId ASC");
3450                }
3451
3452                Query q = session.createQuery(query.toString());
3453
3454                if (obc == null) {
3455                    list = (List<MBMessage>)QueryUtil.list(q, getDialect(),
3456                            start, end, false);
3457
3458                    Collections.sort(list);
3459                }
3460                else {
3461                    list = (List<MBMessage>)QueryUtil.list(q, getDialect(),
3462                            start, end);
3463                }
3464            }
3465            catch (Exception e) {
3466                throw processException(e);
3467            }
3468            finally {
3469                if (list == null) {
3470                    list = new ArrayList<MBMessage>();
3471                }
3472
3473                cacheResult(list);
3474
3475                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
3476
3477                closeSession(session);
3478            }
3479        }
3480
3481        return list;
3482    }
3483
3484    public void removeByUuid(String uuid) throws SystemException {
3485        for (MBMessage mbMessage : findByUuid(uuid)) {
3486            remove(mbMessage);
3487        }
3488    }
3489
3490    public void removeByUUID_G(String uuid, long groupId)
3491        throws NoSuchMessageException, SystemException {
3492        MBMessage mbMessage = findByUUID_G(uuid, groupId);
3493
3494        remove(mbMessage);
3495    }
3496
3497    public void removeByCompanyId(long companyId) throws SystemException {
3498        for (MBMessage mbMessage : findByCompanyId(companyId)) {
3499            remove(mbMessage);
3500        }
3501    }
3502
3503    public void removeByGroupId(long groupId) throws SystemException {
3504        for (MBMessage mbMessage : findByGroupId(groupId)) {
3505            remove(mbMessage);
3506        }
3507    }
3508
3509    public void removeByCategoryId(long categoryId) throws SystemException {
3510        for (MBMessage mbMessage : findByCategoryId(categoryId)) {
3511            remove(mbMessage);
3512        }
3513    }
3514
3515    public void removeByThreadId(long threadId) throws SystemException {
3516        for (MBMessage mbMessage : findByThreadId(threadId)) {
3517            remove(mbMessage);
3518        }
3519    }
3520
3521    public void removeByThreadReplies(long threadId) throws SystemException {
3522        for (MBMessage mbMessage : findByThreadReplies(threadId)) {
3523            remove(mbMessage);
3524        }
3525    }
3526
3527    public void removeByG_U(long groupId, long userId)
3528        throws SystemException {
3529        for (MBMessage mbMessage : findByG_U(groupId, userId)) {
3530            remove(mbMessage);
3531        }
3532    }
3533
3534    public void removeByC_C(long classNameId, long classPK)
3535        throws SystemException {
3536        for (MBMessage mbMessage : findByC_C(classNameId, classPK)) {
3537            remove(mbMessage);
3538        }
3539    }
3540
3541    public void removeByC_T(long categoryId, long threadId)
3542        throws SystemException {
3543        for (MBMessage mbMessage : findByC_T(categoryId, threadId)) {
3544            remove(mbMessage);
3545        }
3546    }
3547
3548    public void removeByT_P(long threadId, long parentMessageId)
3549        throws SystemException {
3550        for (MBMessage mbMessage : findByT_P(threadId, parentMessageId)) {
3551            remove(mbMessage);
3552        }
3553    }
3554
3555    public void removeAll() throws SystemException {
3556        for (MBMessage mbMessage : findAll()) {
3557            remove(mbMessage);
3558        }
3559    }
3560
3561    public int countByUuid(String uuid) throws SystemException {
3562        Object[] finderArgs = new Object[] { uuid };
3563
3564        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
3565                finderArgs, this);
3566
3567        if (count == null) {
3568            Session session = null;
3569
3570            try {
3571                session = openSession();
3572
3573                StringBuilder query = new StringBuilder();
3574
3575                query.append("SELECT COUNT(mbMessage) ");
3576                query.append("FROM MBMessage mbMessage WHERE ");
3577
3578                if (uuid == null) {
3579                    query.append("mbMessage.uuid IS NULL");
3580                }
3581                else {
3582                    query.append("mbMessage.uuid = ?");
3583                }
3584
3585                query.append(" ");
3586
3587                Query q = session.createQuery(query.toString());
3588
3589                QueryPos qPos = QueryPos.getInstance(q);
3590
3591                if (uuid != null) {
3592                    qPos.add(uuid);
3593                }
3594
3595                count = (Long)q.uniqueResult();
3596            }
3597            catch (Exception e) {
3598                throw processException(e);
3599            }
3600            finally {
3601                if (count == null) {
3602                    count = Long.valueOf(0);
3603                }
3604
3605                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
3606                    finderArgs, count);
3607
3608                closeSession(session);
3609            }
3610        }
3611
3612        return count.intValue();
3613    }
3614
3615    public int countByUUID_G(String uuid, long groupId)
3616        throws SystemException {
3617        Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
3618
3619        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
3620                finderArgs, this);
3621
3622        if (count == null) {
3623            Session session = null;
3624
3625            try {
3626                session = openSession();
3627
3628                StringBuilder query = new StringBuilder();
3629
3630                query.append("SELECT COUNT(mbMessage) ");
3631                query.append("FROM MBMessage mbMessage WHERE ");
3632
3633                if (uuid == null) {
3634                    query.append("mbMessage.uuid IS NULL");
3635                }
3636                else {
3637                    query.append("mbMessage.uuid = ?");
3638                }
3639
3640                query.append(" AND ");
3641
3642                query.append("mbMessage.groupId = ?");
3643
3644                query.append(" ");
3645
3646                Query q = session.createQuery(query.toString());
3647
3648                QueryPos qPos = QueryPos.getInstance(q);
3649
3650                if (uuid != null) {
3651                    qPos.add(uuid);
3652                }
3653
3654                qPos.add(groupId);
3655
3656                count = (Long)q.uniqueResult();
3657            }
3658            catch (Exception e) {
3659                throw processException(e);
3660            }
3661            finally {
3662                if (count == null) {
3663                    count = Long.valueOf(0);
3664                }
3665
3666                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
3667                    finderArgs, count);
3668
3669                closeSession(session);
3670            }
3671        }
3672
3673        return count.intValue();
3674    }
3675
3676    public int countByCompanyId(long companyId) throws SystemException {
3677        Object[] finderArgs = new Object[] { new Long(companyId) };
3678
3679        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
3680                finderArgs, this);
3681
3682        if (count == null) {
3683            Session session = null;
3684
3685            try {
3686                session = openSession();
3687
3688                StringBuilder query = new StringBuilder();
3689
3690                query.append("SELECT COUNT(mbMessage) ");
3691                query.append("FROM MBMessage mbMessage WHERE ");
3692
3693                query.append("mbMessage.companyId = ?");
3694
3695                query.append(" ");
3696
3697                Query q = session.createQuery(query.toString());
3698
3699                QueryPos qPos = QueryPos.getInstance(q);
3700
3701                qPos.add(companyId);
3702
3703                count = (Long)q.uniqueResult();
3704            }
3705            catch (Exception e) {
3706                throw processException(e);
3707            }
3708            finally {
3709                if (count == null) {
3710                    count = Long.valueOf(0);
3711                }
3712
3713                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
3714                    finderArgs, count);
3715
3716                closeSession(session);
3717            }
3718        }
3719
3720        return count.intValue();
3721    }
3722
3723    public int countByGroupId(long groupId) throws SystemException {
3724        Object[] finderArgs = new Object[] { new Long(groupId) };
3725
3726        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
3727                finderArgs, this);
3728
3729        if (count == null) {
3730            Session session = null;
3731
3732            try {
3733                session = openSession();
3734
3735                StringBuilder query = new StringBuilder();
3736
3737                query.append("SELECT COUNT(mbMessage) ");
3738                query.append("FROM MBMessage mbMessage WHERE ");
3739
3740                query.append("mbMessage.groupId = ?");
3741
3742                query.append(" ");
3743
3744                Query q = session.createQuery(query.toString());
3745
3746                QueryPos qPos = QueryPos.getInstance(q);
3747
3748                qPos.add(groupId);
3749
3750                count = (Long)q.uniqueResult();
3751            }
3752            catch (Exception e) {
3753                throw processException(e);
3754            }
3755            finally {
3756                if (count == null) {
3757                    count = Long.valueOf(0);
3758                }
3759
3760                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
3761                    finderArgs, count);
3762
3763                closeSession(session);
3764            }
3765        }
3766
3767        return count.intValue();
3768    }
3769
3770    public int countByCategoryId(long categoryId) throws SystemException {
3771        Object[] finderArgs = new Object[] { new Long(categoryId) };
3772
3773        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_CATEGORYID,
3774                finderArgs, this);
3775
3776        if (count == null) {
3777            Session session = null;
3778
3779            try {
3780                session = openSession();
3781
3782                StringBuilder query = new StringBuilder();
3783
3784                query.append("SELECT COUNT(mbMessage) ");
3785                query.append("FROM MBMessage mbMessage WHERE ");
3786
3787                query.append("mbMessage.categoryId = ?");
3788
3789                query.append(" ");
3790
3791                Query q = session.createQuery(query.toString());
3792
3793                QueryPos qPos = QueryPos.getInstance(q);
3794
3795                qPos.add(categoryId);
3796
3797                count = (Long)q.uniqueResult();
3798            }
3799            catch (Exception e) {
3800                throw processException(e);
3801            }
3802            finally {
3803                if (count == null) {
3804                    count = Long.valueOf(0);
3805                }
3806
3807                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_CATEGORYID,
3808                    finderArgs, count);
3809
3810                closeSession(session);
3811            }
3812        }
3813
3814        return count.intValue();
3815    }
3816
3817    public int countByThreadId(long threadId) throws SystemException {
3818        Object[] finderArgs = new Object[] { new Long(threadId) };
3819
3820        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_THREADID,
3821                finderArgs, this);
3822
3823        if (count == null) {
3824            Session session = null;
3825
3826            try {
3827                session = openSession();
3828
3829                StringBuilder query = new StringBuilder();
3830
3831                query.append("SELECT COUNT(mbMessage) ");
3832                query.append("FROM MBMessage mbMessage WHERE ");
3833
3834                query.append("mbMessage.threadId = ?");
3835
3836                query.append(" ");
3837
3838                Query q = session.createQuery(query.toString());
3839
3840                QueryPos qPos = QueryPos.getInstance(q);
3841
3842                qPos.add(threadId);
3843
3844                count = (Long)q.uniqueResult();
3845            }
3846            catch (Exception e) {
3847                throw processException(e);
3848            }
3849            finally {
3850                if (count == null) {
3851                    count = Long.valueOf(0);
3852                }
3853
3854                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_THREADID,
3855                    finderArgs, count);
3856
3857                closeSession(session);
3858            }
3859        }
3860
3861        return count.intValue();
3862    }
3863
3864    public int countByThreadReplies(long threadId) throws SystemException {
3865        Object[] finderArgs = new Object[] { new Long(threadId) };
3866
3867        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_THREADREPLIES,
3868                finderArgs, this);
3869
3870        if (count == null) {
3871            Session session = null;
3872
3873            try {
3874                session = openSession();
3875
3876                StringBuilder query = new StringBuilder();
3877
3878                query.append("SELECT COUNT(mbMessage) ");
3879                query.append("FROM MBMessage mbMessage WHERE ");
3880
3881                query.append("mbMessage.threadId = ?");
3882
3883                query.append(" AND parentMessageId != 0 ");
3884
3885                Query q = session.createQuery(query.toString());
3886
3887                QueryPos qPos = QueryPos.getInstance(q);
3888
3889                qPos.add(threadId);
3890
3891                count = (Long)q.uniqueResult();
3892            }
3893            catch (Exception e) {
3894                throw processException(e);
3895            }
3896            finally {
3897                if (count == null) {
3898                    count = Long.valueOf(0);
3899                }
3900
3901                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_THREADREPLIES,
3902                    finderArgs, count);
3903
3904                closeSession(session);
3905            }
3906        }
3907
3908        return count.intValue();
3909    }
3910
3911    public int countByG_U(long groupId, long userId) throws SystemException {
3912        Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
3913
3914        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
3915                finderArgs, this);
3916
3917        if (count == null) {
3918            Session session = null;
3919
3920            try {
3921                session = openSession();
3922
3923                StringBuilder query = new StringBuilder();
3924
3925                query.append("SELECT COUNT(mbMessage) ");
3926                query.append("FROM MBMessage mbMessage WHERE ");
3927
3928                query.append("mbMessage.groupId = ?");
3929
3930                query.append(" AND ");
3931
3932                query.append("mbMessage.userId = ?");
3933
3934                query.append(" ");
3935
3936                Query q = session.createQuery(query.toString());
3937
3938                QueryPos qPos = QueryPos.getInstance(q);
3939
3940                qPos.add(groupId);
3941
3942                qPos.add(userId);
3943
3944                count = (Long)q.uniqueResult();
3945            }
3946            catch (Exception e) {
3947                throw processException(e);
3948            }
3949            finally {
3950                if (count == null) {
3951                    count = Long.valueOf(0);
3952                }
3953
3954                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
3955                    count);
3956
3957                closeSession(session);
3958            }
3959        }
3960
3961        return count.intValue();
3962    }
3963
3964    public int countByC_C(long classNameId, long classPK)
3965        throws SystemException {
3966        Object[] finderArgs = new Object[] {
3967                new Long(classNameId), new Long(classPK)
3968            };
3969
3970        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C,
3971                finderArgs, this);
3972
3973        if (count == null) {
3974            Session session = null;
3975
3976            try {
3977                session = openSession();
3978
3979                StringBuilder query = new StringBuilder();
3980
3981                query.append("SELECT COUNT(mbMessage) ");
3982                query.append("FROM MBMessage mbMessage WHERE ");
3983
3984                query.append("mbMessage.classNameId = ?");
3985
3986                query.append(" AND ");
3987
3988                query.append("mbMessage.classPK = ?");
3989
3990                query.append(" ");
3991
3992                Query q = session.createQuery(query.toString());
3993
3994                QueryPos qPos = QueryPos.getInstance(q);
3995
3996                qPos.add(classNameId);
3997
3998                qPos.add(classPK);
3999
4000                count = (Long)q.uniqueResult();
4001            }
4002            catch (Exception e) {
4003                throw processException(e);
4004            }
4005            finally {
4006                if (count == null) {
4007                    count = Long.valueOf(0);
4008                }
4009
4010                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C, finderArgs,
4011                    count);
4012
4013                closeSession(session);
4014            }
4015        }
4016
4017        return count.intValue();
4018    }
4019
4020    public int countByC_T(long categoryId, long threadId)
4021        throws SystemException {
4022        Object[] finderArgs = new Object[] {
4023                new Long(categoryId), new Long(threadId)
4024            };
4025
4026        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_T,
4027                finderArgs, this);
4028
4029        if (count == null) {
4030            Session session = null;
4031
4032            try {
4033                session = openSession();
4034
4035                StringBuilder query = new StringBuilder();
4036
4037                query.append("SELECT COUNT(mbMessage) ");
4038                query.append("FROM MBMessage mbMessage WHERE ");
4039
4040                query.append("mbMessage.categoryId = ?");
4041
4042                query.append(" AND ");
4043
4044                query.append("mbMessage.threadId = ?");
4045
4046                query.append(" ");
4047
4048                Query q = session.createQuery(query.toString());
4049
4050                QueryPos qPos = QueryPos.getInstance(q);
4051
4052                qPos.add(categoryId);
4053
4054                qPos.add(threadId);
4055
4056                count = (Long)q.uniqueResult();
4057            }
4058            catch (Exception e) {
4059                throw processException(e);
4060            }
4061            finally {
4062                if (count == null) {
4063                    count = Long.valueOf(0);
4064                }
4065
4066                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_T, finderArgs,
4067                    count);
4068
4069                closeSession(session);
4070            }
4071        }
4072
4073        return count.intValue();
4074    }
4075
4076    public int countByT_P(long threadId, long parentMessageId)
4077        throws SystemException {
4078        Object[] finderArgs = new Object[] {
4079                new Long(threadId), new Long(parentMessageId)
4080            };
4081
4082        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_T_P,
4083                finderArgs, this);
4084
4085        if (count == null) {
4086            Session session = null;
4087
4088            try {
4089                session = openSession();
4090
4091                StringBuilder query = new StringBuilder();
4092
4093                query.append("SELECT COUNT(mbMessage) ");
4094                query.append("FROM MBMessage mbMessage WHERE ");
4095
4096                query.append("mbMessage.threadId = ?");
4097
4098                query.append(" AND ");
4099
4100                query.append("mbMessage.parentMessageId = ?");
4101
4102                query.append(" ");
4103
4104                Query q = session.createQuery(query.toString());
4105
4106                QueryPos qPos = QueryPos.getInstance(q);
4107
4108                qPos.add(threadId);
4109
4110                qPos.add(parentMessageId);
4111
4112                count = (Long)q.uniqueResult();
4113            }
4114            catch (Exception e) {
4115                throw processException(e);
4116            }
4117            finally {
4118                if (count == null) {
4119                    count = Long.valueOf(0);
4120                }
4121
4122                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_T_P, finderArgs,
4123                    count);
4124
4125                closeSession(session);
4126            }
4127        }
4128
4129        return count.intValue();
4130    }
4131
4132    public int countAll() throws SystemException {
4133        Object[] finderArgs = new Object[0];
4134
4135        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
4136                finderArgs, this);
4137
4138        if (count == null) {
4139            Session session = null;
4140
4141            try {
4142                session = openSession();
4143
4144                Query q = session.createQuery(
4145                        "SELECT COUNT(mbMessage) FROM MBMessage mbMessage");
4146
4147                count = (Long)q.uniqueResult();
4148            }
4149            catch (Exception e) {
4150                throw processException(e);
4151            }
4152            finally {
4153                if (count == null) {
4154                    count = Long.valueOf(0);
4155                }
4156
4157                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
4158                    count);
4159
4160                closeSession(session);
4161            }
4162        }
4163
4164        return count.intValue();
4165    }
4166
4167    public void afterPropertiesSet() {
4168        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
4169                    com.liferay.portal.util.PropsUtil.get(
4170                        "value.object.listener.com.liferay.portlet.messageboards.model.MBMessage")));
4171
4172        if (listenerClassNames.length > 0) {
4173            try {
4174                List<ModelListener<MBMessage>> listenersList = new ArrayList<ModelListener<MBMessage>>();
4175
4176                for (String listenerClassName : listenerClassNames) {
4177                    listenersList.add((ModelListener<MBMessage>)Class.forName(
4178                            listenerClassName).newInstance());
4179                }
4180
4181                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
4182            }
4183            catch (Exception e) {
4184                _log.error(e);
4185            }
4186        }
4187    }
4188
4189    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBBanPersistence.impl")
4190    protected com.liferay.portlet.messageboards.service.persistence.MBBanPersistence mbBanPersistence;
4191    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBCategoryPersistence.impl")
4192    protected com.liferay.portlet.messageboards.service.persistence.MBCategoryPersistence mbCategoryPersistence;
4193    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBDiscussionPersistence.impl")
4194    protected com.liferay.portlet.messageboards.service.persistence.MBDiscussionPersistence mbDiscussionPersistence;
4195    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBMailingListPersistence.impl")
4196    protected com.liferay.portlet.messageboards.service.persistence.MBMailingListPersistence mbMailingListPersistence;
4197    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence.impl")
4198    protected com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence mbMessagePersistence;
4199    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBMessageFlagPersistence.impl")
4200    protected com.liferay.portlet.messageboards.service.persistence.MBMessageFlagPersistence mbMessageFlagPersistence;
4201    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBStatsUserPersistence.impl")
4202    protected com.liferay.portlet.messageboards.service.persistence.MBStatsUserPersistence mbStatsUserPersistence;
4203    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBThreadPersistence.impl")
4204    protected com.liferay.portlet.messageboards.service.persistence.MBThreadPersistence mbThreadPersistence;
4205    @BeanReference(name = "com.liferay.portal.service.persistence.CompanyPersistence.impl")
4206    protected com.liferay.portal.service.persistence.CompanyPersistence companyPersistence;
4207    @BeanReference(name = "com.liferay.portal.service.persistence.GroupPersistence.impl")
4208    protected com.liferay.portal.service.persistence.GroupPersistence groupPersistence;
4209    @BeanReference(name = "com.liferay.portal.service.persistence.PortletPreferencesPersistence.impl")
4210    protected com.liferay.portal.service.persistence.PortletPreferencesPersistence portletPreferencesPersistence;
4211    @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePersistence.impl")
4212    protected com.liferay.portal.service.persistence.ResourcePersistence resourcePersistence;
4213    @BeanReference(name = "com.liferay.portal.service.persistence.SubscriptionPersistence.impl")
4214    protected com.liferay.portal.service.persistence.SubscriptionPersistence subscriptionPersistence;
4215    @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence.impl")
4216    protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
4217    @BeanReference(name = "com.liferay.portlet.blogs.service.persistence.BlogsEntryPersistence.impl")
4218    protected com.liferay.portlet.blogs.service.persistence.BlogsEntryPersistence blogsEntryPersistence;
4219    @BeanReference(name = "com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence.impl")
4220    protected com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence ratingsStatsPersistence;
4221    @BeanReference(name = "com.liferay.portlet.social.service.persistence.SocialActivityPersistence.impl")
4222    protected com.liferay.portlet.social.service.persistence.SocialActivityPersistence socialActivityPersistence;
4223    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsAssetPersistence.impl")
4224    protected com.liferay.portlet.tags.service.persistence.TagsAssetPersistence tagsAssetPersistence;
4225    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsEntryPersistence.impl")
4226    protected com.liferay.portlet.tags.service.persistence.TagsEntryPersistence tagsEntryPersistence;
4227    private static Log _log = LogFactoryUtil.getLog(MBMessagePersistenceImpl.class);
4228}