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