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