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