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