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