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