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