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