1
22
23 package com.liferay.portlet.messageboards.service.persistence;
24
25 import com.liferay.portal.SystemException;
26 import com.liferay.portal.kernel.dao.DynamicQuery;
27 import com.liferay.portal.kernel.dao.DynamicQueryInitializer;
28 import com.liferay.portal.kernel.util.GetterUtil;
29 import com.liferay.portal.kernel.util.OrderByComparator;
30 import com.liferay.portal.kernel.util.StringMaker;
31 import com.liferay.portal.kernel.util.StringPool;
32 import com.liferay.portal.kernel.util.StringUtil;
33 import com.liferay.portal.kernel.util.Validator;
34 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
35 import com.liferay.portal.model.ModelListener;
36 import com.liferay.portal.service.persistence.BasePersistence;
37 import com.liferay.portal.spring.hibernate.FinderCache;
38 import com.liferay.portal.spring.hibernate.HibernateUtil;
39 import com.liferay.portal.util.PropsUtil;
40
41 import com.liferay.portlet.messageboards.NoSuchMessageException;
42 import com.liferay.portlet.messageboards.model.MBMessage;
43 import com.liferay.portlet.messageboards.model.impl.MBMessageImpl;
44 import com.liferay.portlet.messageboards.model.impl.MBMessageModelImpl;
45
46 import com.liferay.util.dao.hibernate.QueryUtil;
47
48 import org.apache.commons.logging.Log;
49 import org.apache.commons.logging.LogFactory;
50
51 import org.hibernate.Query;
52 import org.hibernate.Session;
53
54 import java.util.ArrayList;
55 import java.util.Collections;
56 import java.util.Iterator;
57 import java.util.List;
58
59
65 public class MBMessagePersistenceImpl extends BasePersistence
66 implements MBMessagePersistence {
67 public MBMessage create(long messageId) {
68 MBMessage mbMessage = new MBMessageImpl();
69
70 mbMessage.setNew(true);
71 mbMessage.setPrimaryKey(messageId);
72
73 String uuid = PortalUUIDUtil.generate();
74
75 mbMessage.setUuid(uuid);
76
77 return mbMessage;
78 }
79
80 public MBMessage remove(long messageId)
81 throws NoSuchMessageException, SystemException {
82 Session session = null;
83
84 try {
85 session = openSession();
86
87 MBMessage mbMessage = (MBMessage)session.get(MBMessageImpl.class,
88 new Long(messageId));
89
90 if (mbMessage == null) {
91 if (_log.isWarnEnabled()) {
92 _log.warn("No MBMessage exists with the primary key " +
93 messageId);
94 }
95
96 throw new NoSuchMessageException(
97 "No MBMessage exists with the primary key " + messageId);
98 }
99
100 return remove(mbMessage);
101 }
102 catch (NoSuchMessageException nsee) {
103 throw nsee;
104 }
105 catch (Exception e) {
106 throw HibernateUtil.processException(e);
107 }
108 finally {
109 closeSession(session);
110 }
111 }
112
113 public MBMessage remove(MBMessage mbMessage) throws SystemException {
114 if (_listeners != null) {
115 for (ModelListener listener : _listeners) {
116 listener.onBeforeRemove(mbMessage);
117 }
118 }
119
120 mbMessage = removeImpl(mbMessage);
121
122 if (_listeners != null) {
123 for (ModelListener listener : _listeners) {
124 listener.onAfterRemove(mbMessage);
125 }
126 }
127
128 return mbMessage;
129 }
130
131 protected MBMessage removeImpl(MBMessage mbMessage)
132 throws SystemException {
133 Session session = null;
134
135 try {
136 session = openSession();
137
138 session.delete(mbMessage);
139
140 session.flush();
141
142 return mbMessage;
143 }
144 catch (Exception e) {
145 throw HibernateUtil.processException(e);
146 }
147 finally {
148 closeSession(session);
149
150 FinderCache.clearCache(MBMessage.class.getName());
151 }
152 }
153
154
157 public MBMessage update(MBMessage mbMessage) throws SystemException {
158 if (_log.isWarnEnabled()) {
159 _log.warn(
160 "Using the deprecated update(MBMessage mbMessage) method. Use update(MBMessage mbMessage, boolean merge) instead.");
161 }
162
163 return update(mbMessage, false);
164 }
165
166
179 public MBMessage update(MBMessage mbMessage, boolean merge)
180 throws SystemException {
181 boolean isNew = mbMessage.isNew();
182
183 if (_listeners != null) {
184 for (ModelListener listener : _listeners) {
185 if (isNew) {
186 listener.onBeforeCreate(mbMessage);
187 }
188 else {
189 listener.onBeforeUpdate(mbMessage);
190 }
191 }
192 }
193
194 mbMessage = updateImpl(mbMessage, merge);
195
196 if (_listeners != null) {
197 for (ModelListener listener : _listeners) {
198 if (isNew) {
199 listener.onAfterCreate(mbMessage);
200 }
201 else {
202 listener.onAfterUpdate(mbMessage);
203 }
204 }
205 }
206
207 return mbMessage;
208 }
209
210 public MBMessage updateImpl(
211 com.liferay.portlet.messageboards.model.MBMessage mbMessage,
212 boolean merge) throws SystemException {
213 if (Validator.isNull(mbMessage.getUuid())) {
214 String uuid = PortalUUIDUtil.generate();
215
216 mbMessage.setUuid(uuid);
217 }
218
219 Session session = null;
220
221 try {
222 session = openSession();
223
224 if (merge) {
225 session.merge(mbMessage);
226 }
227 else {
228 if (mbMessage.isNew()) {
229 session.save(mbMessage);
230 }
231 }
232
233 session.flush();
234
235 mbMessage.setNew(false);
236
237 return mbMessage;
238 }
239 catch (Exception e) {
240 throw HibernateUtil.processException(e);
241 }
242 finally {
243 closeSession(session);
244
245 FinderCache.clearCache(MBMessage.class.getName());
246 }
247 }
248
249 public MBMessage findByPrimaryKey(long messageId)
250 throws NoSuchMessageException, SystemException {
251 MBMessage mbMessage = fetchByPrimaryKey(messageId);
252
253 if (mbMessage == null) {
254 if (_log.isWarnEnabled()) {
255 _log.warn("No MBMessage exists with the primary key " +
256 messageId);
257 }
258
259 throw new NoSuchMessageException(
260 "No MBMessage exists with the primary key " + messageId);
261 }
262
263 return mbMessage;
264 }
265
266 public MBMessage fetchByPrimaryKey(long messageId)
267 throws SystemException {
268 Session session = null;
269
270 try {
271 session = openSession();
272
273 return (MBMessage)session.get(MBMessageImpl.class,
274 new Long(messageId));
275 }
276 catch (Exception e) {
277 throw HibernateUtil.processException(e);
278 }
279 finally {
280 closeSession(session);
281 }
282 }
283
284 public List<MBMessage> findByUuid(String uuid) throws SystemException {
285 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
286 String finderClassName = MBMessage.class.getName();
287 String finderMethodName = "findByUuid";
288 String[] finderParams = new String[] { String.class.getName() };
289 Object[] finderArgs = new Object[] { uuid };
290
291 Object result = null;
292
293 if (finderClassNameCacheEnabled) {
294 result = FinderCache.getResult(finderClassName, finderMethodName,
295 finderParams, finderArgs, getSessionFactory());
296 }
297
298 if (result == null) {
299 Session session = null;
300
301 try {
302 session = openSession();
303
304 StringMaker query = new StringMaker();
305
306 query.append(
307 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
308
309 if (uuid == null) {
310 query.append("uuid_ IS NULL");
311 }
312 else {
313 query.append("uuid_ = ?");
314 }
315
316 query.append(" ");
317
318 query.append("ORDER BY ");
319
320 query.append("createDate ASC, ");
321 query.append("messageId ASC");
322
323 Query q = session.createQuery(query.toString());
324
325 int queryPos = 0;
326
327 if (uuid != null) {
328 q.setString(queryPos++, uuid);
329 }
330
331 List<MBMessage> list = q.list();
332
333 FinderCache.putResult(finderClassNameCacheEnabled,
334 finderClassName, finderMethodName, finderParams,
335 finderArgs, list);
336
337 return list;
338 }
339 catch (Exception e) {
340 throw HibernateUtil.processException(e);
341 }
342 finally {
343 closeSession(session);
344 }
345 }
346 else {
347 return (List<MBMessage>)result;
348 }
349 }
350
351 public List<MBMessage> findByUuid(String uuid, int begin, int end)
352 throws SystemException {
353 return findByUuid(uuid, begin, end, null);
354 }
355
356 public List<MBMessage> findByUuid(String uuid, int begin, int end,
357 OrderByComparator obc) throws SystemException {
358 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
359 String finderClassName = MBMessage.class.getName();
360 String finderMethodName = "findByUuid";
361 String[] finderParams = new String[] {
362 String.class.getName(),
363
364 "java.lang.Integer", "java.lang.Integer",
365 "com.liferay.portal.kernel.util.OrderByComparator"
366 };
367 Object[] finderArgs = new Object[] {
368 uuid,
369
370 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
371 };
372
373 Object result = null;
374
375 if (finderClassNameCacheEnabled) {
376 result = FinderCache.getResult(finderClassName, finderMethodName,
377 finderParams, finderArgs, getSessionFactory());
378 }
379
380 if (result == null) {
381 Session session = null;
382
383 try {
384 session = openSession();
385
386 StringMaker query = new StringMaker();
387
388 query.append(
389 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
390
391 if (uuid == null) {
392 query.append("uuid_ IS NULL");
393 }
394 else {
395 query.append("uuid_ = ?");
396 }
397
398 query.append(" ");
399
400 if (obc != null) {
401 query.append("ORDER BY ");
402 query.append(obc.getOrderBy());
403 }
404
405 else {
406 query.append("ORDER BY ");
407
408 query.append("createDate ASC, ");
409 query.append("messageId ASC");
410 }
411
412 Query q = session.createQuery(query.toString());
413
414 int queryPos = 0;
415
416 if (uuid != null) {
417 q.setString(queryPos++, uuid);
418 }
419
420 List<MBMessage> list = (List<MBMessage>)QueryUtil.list(q,
421 getDialect(), begin, end);
422
423 FinderCache.putResult(finderClassNameCacheEnabled,
424 finderClassName, finderMethodName, finderParams,
425 finderArgs, list);
426
427 return list;
428 }
429 catch (Exception e) {
430 throw HibernateUtil.processException(e);
431 }
432 finally {
433 closeSession(session);
434 }
435 }
436 else {
437 return (List<MBMessage>)result;
438 }
439 }
440
441 public MBMessage findByUuid_First(String uuid, OrderByComparator obc)
442 throws NoSuchMessageException, SystemException {
443 List<MBMessage> list = findByUuid(uuid, 0, 1, obc);
444
445 if (list.size() == 0) {
446 StringMaker msg = new StringMaker();
447
448 msg.append("No MBMessage exists with the key {");
449
450 msg.append("uuid=" + uuid);
451
452 msg.append(StringPool.CLOSE_CURLY_BRACE);
453
454 throw new NoSuchMessageException(msg.toString());
455 }
456 else {
457 return list.get(0);
458 }
459 }
460
461 public MBMessage findByUuid_Last(String uuid, OrderByComparator obc)
462 throws NoSuchMessageException, SystemException {
463 int count = countByUuid(uuid);
464
465 List<MBMessage> list = findByUuid(uuid, count - 1, count, obc);
466
467 if (list.size() == 0) {
468 StringMaker msg = new StringMaker();
469
470 msg.append("No MBMessage exists with the key {");
471
472 msg.append("uuid=" + uuid);
473
474 msg.append(StringPool.CLOSE_CURLY_BRACE);
475
476 throw new NoSuchMessageException(msg.toString());
477 }
478 else {
479 return list.get(0);
480 }
481 }
482
483 public MBMessage[] findByUuid_PrevAndNext(long messageId, String uuid,
484 OrderByComparator obc) throws NoSuchMessageException, SystemException {
485 MBMessage mbMessage = findByPrimaryKey(messageId);
486
487 int count = countByUuid(uuid);
488
489 Session session = null;
490
491 try {
492 session = openSession();
493
494 StringMaker query = new StringMaker();
495
496 query.append(
497 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
498
499 if (uuid == null) {
500 query.append("uuid_ IS NULL");
501 }
502 else {
503 query.append("uuid_ = ?");
504 }
505
506 query.append(" ");
507
508 if (obc != null) {
509 query.append("ORDER BY ");
510 query.append(obc.getOrderBy());
511 }
512
513 else {
514 query.append("ORDER BY ");
515
516 query.append("createDate ASC, ");
517 query.append("messageId ASC");
518 }
519
520 Query q = session.createQuery(query.toString());
521
522 int queryPos = 0;
523
524 if (uuid != null) {
525 q.setString(queryPos++, uuid);
526 }
527
528 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
529 mbMessage);
530
531 MBMessage[] array = new MBMessageImpl[3];
532
533 array[0] = (MBMessage)objArray[0];
534 array[1] = (MBMessage)objArray[1];
535 array[2] = (MBMessage)objArray[2];
536
537 return array;
538 }
539 catch (Exception e) {
540 throw HibernateUtil.processException(e);
541 }
542 finally {
543 closeSession(session);
544 }
545 }
546
547 public List<MBMessage> findByCompanyId(long companyId)
548 throws SystemException {
549 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
550 String finderClassName = MBMessage.class.getName();
551 String finderMethodName = "findByCompanyId";
552 String[] finderParams = new String[] { Long.class.getName() };
553 Object[] finderArgs = new Object[] { new Long(companyId) };
554
555 Object result = null;
556
557 if (finderClassNameCacheEnabled) {
558 result = FinderCache.getResult(finderClassName, finderMethodName,
559 finderParams, finderArgs, getSessionFactory());
560 }
561
562 if (result == null) {
563 Session session = null;
564
565 try {
566 session = openSession();
567
568 StringMaker query = new StringMaker();
569
570 query.append(
571 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
572
573 query.append("companyId = ?");
574
575 query.append(" ");
576
577 query.append("ORDER BY ");
578
579 query.append("createDate ASC, ");
580 query.append("messageId ASC");
581
582 Query q = session.createQuery(query.toString());
583
584 int queryPos = 0;
585
586 q.setLong(queryPos++, companyId);
587
588 List<MBMessage> list = q.list();
589
590 FinderCache.putResult(finderClassNameCacheEnabled,
591 finderClassName, finderMethodName, finderParams,
592 finderArgs, list);
593
594 return list;
595 }
596 catch (Exception e) {
597 throw HibernateUtil.processException(e);
598 }
599 finally {
600 closeSession(session);
601 }
602 }
603 else {
604 return (List<MBMessage>)result;
605 }
606 }
607
608 public List<MBMessage> findByCompanyId(long companyId, int begin, int end)
609 throws SystemException {
610 return findByCompanyId(companyId, begin, end, null);
611 }
612
613 public List<MBMessage> findByCompanyId(long companyId, int begin, int end,
614 OrderByComparator obc) throws SystemException {
615 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
616 String finderClassName = MBMessage.class.getName();
617 String finderMethodName = "findByCompanyId";
618 String[] finderParams = new String[] {
619 Long.class.getName(),
620
621 "java.lang.Integer", "java.lang.Integer",
622 "com.liferay.portal.kernel.util.OrderByComparator"
623 };
624 Object[] finderArgs = new Object[] {
625 new Long(companyId),
626
627 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
628 };
629
630 Object result = null;
631
632 if (finderClassNameCacheEnabled) {
633 result = FinderCache.getResult(finderClassName, finderMethodName,
634 finderParams, finderArgs, getSessionFactory());
635 }
636
637 if (result == null) {
638 Session session = null;
639
640 try {
641 session = openSession();
642
643 StringMaker query = new StringMaker();
644
645 query.append(
646 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
647
648 query.append("companyId = ?");
649
650 query.append(" ");
651
652 if (obc != null) {
653 query.append("ORDER BY ");
654 query.append(obc.getOrderBy());
655 }
656
657 else {
658 query.append("ORDER BY ");
659
660 query.append("createDate ASC, ");
661 query.append("messageId ASC");
662 }
663
664 Query q = session.createQuery(query.toString());
665
666 int queryPos = 0;
667
668 q.setLong(queryPos++, companyId);
669
670 List<MBMessage> list = (List<MBMessage>)QueryUtil.list(q,
671 getDialect(), begin, end);
672
673 FinderCache.putResult(finderClassNameCacheEnabled,
674 finderClassName, finderMethodName, finderParams,
675 finderArgs, list);
676
677 return list;
678 }
679 catch (Exception e) {
680 throw HibernateUtil.processException(e);
681 }
682 finally {
683 closeSession(session);
684 }
685 }
686 else {
687 return (List<MBMessage>)result;
688 }
689 }
690
691 public MBMessage findByCompanyId_First(long companyId, OrderByComparator obc)
692 throws NoSuchMessageException, SystemException {
693 List<MBMessage> list = findByCompanyId(companyId, 0, 1, obc);
694
695 if (list.size() == 0) {
696 StringMaker msg = new StringMaker();
697
698 msg.append("No MBMessage exists with the key {");
699
700 msg.append("companyId=" + companyId);
701
702 msg.append(StringPool.CLOSE_CURLY_BRACE);
703
704 throw new NoSuchMessageException(msg.toString());
705 }
706 else {
707 return list.get(0);
708 }
709 }
710
711 public MBMessage findByCompanyId_Last(long companyId, OrderByComparator obc)
712 throws NoSuchMessageException, SystemException {
713 int count = countByCompanyId(companyId);
714
715 List<MBMessage> list = findByCompanyId(companyId, count - 1, count, obc);
716
717 if (list.size() == 0) {
718 StringMaker msg = new StringMaker();
719
720 msg.append("No MBMessage exists with the key {");
721
722 msg.append("companyId=" + companyId);
723
724 msg.append(StringPool.CLOSE_CURLY_BRACE);
725
726 throw new NoSuchMessageException(msg.toString());
727 }
728 else {
729 return list.get(0);
730 }
731 }
732
733 public MBMessage[] findByCompanyId_PrevAndNext(long messageId,
734 long companyId, OrderByComparator obc)
735 throws NoSuchMessageException, SystemException {
736 MBMessage mbMessage = findByPrimaryKey(messageId);
737
738 int count = countByCompanyId(companyId);
739
740 Session session = null;
741
742 try {
743 session = openSession();
744
745 StringMaker query = new StringMaker();
746
747 query.append(
748 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
749
750 query.append("companyId = ?");
751
752 query.append(" ");
753
754 if (obc != null) {
755 query.append("ORDER BY ");
756 query.append(obc.getOrderBy());
757 }
758
759 else {
760 query.append("ORDER BY ");
761
762 query.append("createDate ASC, ");
763 query.append("messageId ASC");
764 }
765
766 Query q = session.createQuery(query.toString());
767
768 int queryPos = 0;
769
770 q.setLong(queryPos++, companyId);
771
772 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
773 mbMessage);
774
775 MBMessage[] array = new MBMessageImpl[3];
776
777 array[0] = (MBMessage)objArray[0];
778 array[1] = (MBMessage)objArray[1];
779 array[2] = (MBMessage)objArray[2];
780
781 return array;
782 }
783 catch (Exception e) {
784 throw HibernateUtil.processException(e);
785 }
786 finally {
787 closeSession(session);
788 }
789 }
790
791 public List<MBMessage> findByCategoryId(long categoryId)
792 throws SystemException {
793 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
794 String finderClassName = MBMessage.class.getName();
795 String finderMethodName = "findByCategoryId";
796 String[] finderParams = new String[] { Long.class.getName() };
797 Object[] finderArgs = new Object[] { new Long(categoryId) };
798
799 Object result = null;
800
801 if (finderClassNameCacheEnabled) {
802 result = FinderCache.getResult(finderClassName, finderMethodName,
803 finderParams, finderArgs, getSessionFactory());
804 }
805
806 if (result == null) {
807 Session session = null;
808
809 try {
810 session = openSession();
811
812 StringMaker query = new StringMaker();
813
814 query.append(
815 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
816
817 query.append("categoryId = ?");
818
819 query.append(" ");
820
821 query.append("ORDER BY ");
822
823 query.append("createDate ASC, ");
824 query.append("messageId ASC");
825
826 Query q = session.createQuery(query.toString());
827
828 int queryPos = 0;
829
830 q.setLong(queryPos++, categoryId);
831
832 List<MBMessage> list = q.list();
833
834 FinderCache.putResult(finderClassNameCacheEnabled,
835 finderClassName, finderMethodName, finderParams,
836 finderArgs, list);
837
838 return list;
839 }
840 catch (Exception e) {
841 throw HibernateUtil.processException(e);
842 }
843 finally {
844 closeSession(session);
845 }
846 }
847 else {
848 return (List<MBMessage>)result;
849 }
850 }
851
852 public List<MBMessage> findByCategoryId(long categoryId, int begin, int end)
853 throws SystemException {
854 return findByCategoryId(categoryId, begin, end, null);
855 }
856
857 public List<MBMessage> findByCategoryId(long categoryId, int begin,
858 int end, OrderByComparator obc) throws SystemException {
859 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
860 String finderClassName = MBMessage.class.getName();
861 String finderMethodName = "findByCategoryId";
862 String[] finderParams = new String[] {
863 Long.class.getName(),
864
865 "java.lang.Integer", "java.lang.Integer",
866 "com.liferay.portal.kernel.util.OrderByComparator"
867 };
868 Object[] finderArgs = new Object[] {
869 new Long(categoryId),
870
871 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
872 };
873
874 Object result = null;
875
876 if (finderClassNameCacheEnabled) {
877 result = FinderCache.getResult(finderClassName, finderMethodName,
878 finderParams, finderArgs, getSessionFactory());
879 }
880
881 if (result == null) {
882 Session session = null;
883
884 try {
885 session = openSession();
886
887 StringMaker query = new StringMaker();
888
889 query.append(
890 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
891
892 query.append("categoryId = ?");
893
894 query.append(" ");
895
896 if (obc != null) {
897 query.append("ORDER BY ");
898 query.append(obc.getOrderBy());
899 }
900
901 else {
902 query.append("ORDER BY ");
903
904 query.append("createDate ASC, ");
905 query.append("messageId ASC");
906 }
907
908 Query q = session.createQuery(query.toString());
909
910 int queryPos = 0;
911
912 q.setLong(queryPos++, categoryId);
913
914 List<MBMessage> list = (List<MBMessage>)QueryUtil.list(q,
915 getDialect(), begin, end);
916
917 FinderCache.putResult(finderClassNameCacheEnabled,
918 finderClassName, finderMethodName, finderParams,
919 finderArgs, list);
920
921 return list;
922 }
923 catch (Exception e) {
924 throw HibernateUtil.processException(e);
925 }
926 finally {
927 closeSession(session);
928 }
929 }
930 else {
931 return (List<MBMessage>)result;
932 }
933 }
934
935 public MBMessage findByCategoryId_First(long categoryId,
936 OrderByComparator obc) throws NoSuchMessageException, SystemException {
937 List<MBMessage> list = findByCategoryId(categoryId, 0, 1, obc);
938
939 if (list.size() == 0) {
940 StringMaker msg = new StringMaker();
941
942 msg.append("No MBMessage exists with the key {");
943
944 msg.append("categoryId=" + categoryId);
945
946 msg.append(StringPool.CLOSE_CURLY_BRACE);
947
948 throw new NoSuchMessageException(msg.toString());
949 }
950 else {
951 return list.get(0);
952 }
953 }
954
955 public MBMessage findByCategoryId_Last(long categoryId,
956 OrderByComparator obc) throws NoSuchMessageException, SystemException {
957 int count = countByCategoryId(categoryId);
958
959 List<MBMessage> list = findByCategoryId(categoryId, count - 1, count,
960 obc);
961
962 if (list.size() == 0) {
963 StringMaker msg = new StringMaker();
964
965 msg.append("No MBMessage exists with the key {");
966
967 msg.append("categoryId=" + categoryId);
968
969 msg.append(StringPool.CLOSE_CURLY_BRACE);
970
971 throw new NoSuchMessageException(msg.toString());
972 }
973 else {
974 return list.get(0);
975 }
976 }
977
978 public MBMessage[] findByCategoryId_PrevAndNext(long messageId,
979 long categoryId, OrderByComparator obc)
980 throws NoSuchMessageException, SystemException {
981 MBMessage mbMessage = findByPrimaryKey(messageId);
982
983 int count = countByCategoryId(categoryId);
984
985 Session session = null;
986
987 try {
988 session = openSession();
989
990 StringMaker query = new StringMaker();
991
992 query.append(
993 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
994
995 query.append("categoryId = ?");
996
997 query.append(" ");
998
999 if (obc != null) {
1000 query.append("ORDER BY ");
1001 query.append(obc.getOrderBy());
1002 }
1003
1004 else {
1005 query.append("ORDER BY ");
1006
1007 query.append("createDate ASC, ");
1008 query.append("messageId ASC");
1009 }
1010
1011 Query q = session.createQuery(query.toString());
1012
1013 int queryPos = 0;
1014
1015 q.setLong(queryPos++, categoryId);
1016
1017 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1018 mbMessage);
1019
1020 MBMessage[] array = new MBMessageImpl[3];
1021
1022 array[0] = (MBMessage)objArray[0];
1023 array[1] = (MBMessage)objArray[1];
1024 array[2] = (MBMessage)objArray[2];
1025
1026 return array;
1027 }
1028 catch (Exception e) {
1029 throw HibernateUtil.processException(e);
1030 }
1031 finally {
1032 closeSession(session);
1033 }
1034 }
1035
1036 public List<MBMessage> findByThreadId(long threadId)
1037 throws SystemException {
1038 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
1039 String finderClassName = MBMessage.class.getName();
1040 String finderMethodName = "findByThreadId";
1041 String[] finderParams = new String[] { Long.class.getName() };
1042 Object[] finderArgs = new Object[] { new Long(threadId) };
1043
1044 Object result = null;
1045
1046 if (finderClassNameCacheEnabled) {
1047 result = FinderCache.getResult(finderClassName, finderMethodName,
1048 finderParams, finderArgs, getSessionFactory());
1049 }
1050
1051 if (result == null) {
1052 Session session = null;
1053
1054 try {
1055 session = openSession();
1056
1057 StringMaker query = new StringMaker();
1058
1059 query.append(
1060 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1061
1062 query.append("threadId = ?");
1063
1064 query.append(" ");
1065
1066 query.append("ORDER BY ");
1067
1068 query.append("createDate ASC, ");
1069 query.append("messageId ASC");
1070
1071 Query q = session.createQuery(query.toString());
1072
1073 int queryPos = 0;
1074
1075 q.setLong(queryPos++, threadId);
1076
1077 List<MBMessage> list = q.list();
1078
1079 FinderCache.putResult(finderClassNameCacheEnabled,
1080 finderClassName, finderMethodName, finderParams,
1081 finderArgs, list);
1082
1083 return list;
1084 }
1085 catch (Exception e) {
1086 throw HibernateUtil.processException(e);
1087 }
1088 finally {
1089 closeSession(session);
1090 }
1091 }
1092 else {
1093 return (List<MBMessage>)result;
1094 }
1095 }
1096
1097 public List<MBMessage> findByThreadId(long threadId, int begin, int end)
1098 throws SystemException {
1099 return findByThreadId(threadId, begin, end, null);
1100 }
1101
1102 public List<MBMessage> findByThreadId(long threadId, int begin, int end,
1103 OrderByComparator obc) throws SystemException {
1104 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
1105 String finderClassName = MBMessage.class.getName();
1106 String finderMethodName = "findByThreadId";
1107 String[] finderParams = new String[] {
1108 Long.class.getName(),
1109
1110 "java.lang.Integer", "java.lang.Integer",
1111 "com.liferay.portal.kernel.util.OrderByComparator"
1112 };
1113 Object[] finderArgs = new Object[] {
1114 new Long(threadId),
1115
1116 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1117 };
1118
1119 Object result = null;
1120
1121 if (finderClassNameCacheEnabled) {
1122 result = FinderCache.getResult(finderClassName, finderMethodName,
1123 finderParams, finderArgs, getSessionFactory());
1124 }
1125
1126 if (result == null) {
1127 Session session = null;
1128
1129 try {
1130 session = openSession();
1131
1132 StringMaker query = new StringMaker();
1133
1134 query.append(
1135 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1136
1137 query.append("threadId = ?");
1138
1139 query.append(" ");
1140
1141 if (obc != null) {
1142 query.append("ORDER BY ");
1143 query.append(obc.getOrderBy());
1144 }
1145
1146 else {
1147 query.append("ORDER BY ");
1148
1149 query.append("createDate ASC, ");
1150 query.append("messageId ASC");
1151 }
1152
1153 Query q = session.createQuery(query.toString());
1154
1155 int queryPos = 0;
1156
1157 q.setLong(queryPos++, threadId);
1158
1159 List<MBMessage> list = (List<MBMessage>)QueryUtil.list(q,
1160 getDialect(), begin, end);
1161
1162 FinderCache.putResult(finderClassNameCacheEnabled,
1163 finderClassName, finderMethodName, finderParams,
1164 finderArgs, list);
1165
1166 return list;
1167 }
1168 catch (Exception e) {
1169 throw HibernateUtil.processException(e);
1170 }
1171 finally {
1172 closeSession(session);
1173 }
1174 }
1175 else {
1176 return (List<MBMessage>)result;
1177 }
1178 }
1179
1180 public MBMessage findByThreadId_First(long threadId, OrderByComparator obc)
1181 throws NoSuchMessageException, SystemException {
1182 List<MBMessage> list = findByThreadId(threadId, 0, 1, obc);
1183
1184 if (list.size() == 0) {
1185 StringMaker msg = new StringMaker();
1186
1187 msg.append("No MBMessage exists with the key {");
1188
1189 msg.append("threadId=" + threadId);
1190
1191 msg.append(StringPool.CLOSE_CURLY_BRACE);
1192
1193 throw new NoSuchMessageException(msg.toString());
1194 }
1195 else {
1196 return list.get(0);
1197 }
1198 }
1199
1200 public MBMessage findByThreadId_Last(long threadId, OrderByComparator obc)
1201 throws NoSuchMessageException, SystemException {
1202 int count = countByThreadId(threadId);
1203
1204 List<MBMessage> list = findByThreadId(threadId, count - 1, count, obc);
1205
1206 if (list.size() == 0) {
1207 StringMaker msg = new StringMaker();
1208
1209 msg.append("No MBMessage exists with the key {");
1210
1211 msg.append("threadId=" + threadId);
1212
1213 msg.append(StringPool.CLOSE_CURLY_BRACE);
1214
1215 throw new NoSuchMessageException(msg.toString());
1216 }
1217 else {
1218 return list.get(0);
1219 }
1220 }
1221
1222 public MBMessage[] findByThreadId_PrevAndNext(long messageId,
1223 long threadId, OrderByComparator obc)
1224 throws NoSuchMessageException, SystemException {
1225 MBMessage mbMessage = findByPrimaryKey(messageId);
1226
1227 int count = countByThreadId(threadId);
1228
1229 Session session = null;
1230
1231 try {
1232 session = openSession();
1233
1234 StringMaker query = new StringMaker();
1235
1236 query.append(
1237 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1238
1239 query.append("threadId = ?");
1240
1241 query.append(" ");
1242
1243 if (obc != null) {
1244 query.append("ORDER BY ");
1245 query.append(obc.getOrderBy());
1246 }
1247
1248 else {
1249 query.append("ORDER BY ");
1250
1251 query.append("createDate ASC, ");
1252 query.append("messageId ASC");
1253 }
1254
1255 Query q = session.createQuery(query.toString());
1256
1257 int queryPos = 0;
1258
1259 q.setLong(queryPos++, threadId);
1260
1261 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1262 mbMessage);
1263
1264 MBMessage[] array = new MBMessageImpl[3];
1265
1266 array[0] = (MBMessage)objArray[0];
1267 array[1] = (MBMessage)objArray[1];
1268 array[2] = (MBMessage)objArray[2];
1269
1270 return array;
1271 }
1272 catch (Exception e) {
1273 throw HibernateUtil.processException(e);
1274 }
1275 finally {
1276 closeSession(session);
1277 }
1278 }
1279
1280 public List<MBMessage> findByC_T(long categoryId, long threadId)
1281 throws SystemException {
1282 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
1283 String finderClassName = MBMessage.class.getName();
1284 String finderMethodName = "findByC_T";
1285 String[] finderParams = new String[] {
1286 Long.class.getName(), Long.class.getName()
1287 };
1288 Object[] finderArgs = new Object[] {
1289 new Long(categoryId), new Long(threadId)
1290 };
1291
1292 Object result = null;
1293
1294 if (finderClassNameCacheEnabled) {
1295 result = FinderCache.getResult(finderClassName, finderMethodName,
1296 finderParams, finderArgs, getSessionFactory());
1297 }
1298
1299 if (result == null) {
1300 Session session = null;
1301
1302 try {
1303 session = openSession();
1304
1305 StringMaker query = new StringMaker();
1306
1307 query.append(
1308 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1309
1310 query.append("categoryId = ?");
1311
1312 query.append(" AND ");
1313
1314 query.append("threadId = ?");
1315
1316 query.append(" ");
1317
1318 query.append("ORDER BY ");
1319
1320 query.append("createDate ASC, ");
1321 query.append("messageId ASC");
1322
1323 Query q = session.createQuery(query.toString());
1324
1325 int queryPos = 0;
1326
1327 q.setLong(queryPos++, categoryId);
1328
1329 q.setLong(queryPos++, threadId);
1330
1331 List<MBMessage> list = q.list();
1332
1333 FinderCache.putResult(finderClassNameCacheEnabled,
1334 finderClassName, finderMethodName, finderParams,
1335 finderArgs, list);
1336
1337 return list;
1338 }
1339 catch (Exception e) {
1340 throw HibernateUtil.processException(e);
1341 }
1342 finally {
1343 closeSession(session);
1344 }
1345 }
1346 else {
1347 return (List<MBMessage>)result;
1348 }
1349 }
1350
1351 public List<MBMessage> findByC_T(long categoryId, long threadId, int begin,
1352 int end) throws SystemException {
1353 return findByC_T(categoryId, threadId, begin, end, null);
1354 }
1355
1356 public List<MBMessage> findByC_T(long categoryId, long threadId, int begin,
1357 int end, OrderByComparator obc) throws SystemException {
1358 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
1359 String finderClassName = MBMessage.class.getName();
1360 String finderMethodName = "findByC_T";
1361 String[] finderParams = new String[] {
1362 Long.class.getName(), Long.class.getName(),
1363
1364 "java.lang.Integer", "java.lang.Integer",
1365 "com.liferay.portal.kernel.util.OrderByComparator"
1366 };
1367 Object[] finderArgs = new Object[] {
1368 new Long(categoryId), new Long(threadId),
1369
1370 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1371 };
1372
1373 Object result = null;
1374
1375 if (finderClassNameCacheEnabled) {
1376 result = FinderCache.getResult(finderClassName, finderMethodName,
1377 finderParams, finderArgs, getSessionFactory());
1378 }
1379
1380 if (result == null) {
1381 Session session = null;
1382
1383 try {
1384 session = openSession();
1385
1386 StringMaker query = new StringMaker();
1387
1388 query.append(
1389 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1390
1391 query.append("categoryId = ?");
1392
1393 query.append(" AND ");
1394
1395 query.append("threadId = ?");
1396
1397 query.append(" ");
1398
1399 if (obc != null) {
1400 query.append("ORDER BY ");
1401 query.append(obc.getOrderBy());
1402 }
1403
1404 else {
1405 query.append("ORDER BY ");
1406
1407 query.append("createDate ASC, ");
1408 query.append("messageId ASC");
1409 }
1410
1411 Query q = session.createQuery(query.toString());
1412
1413 int queryPos = 0;
1414
1415 q.setLong(queryPos++, categoryId);
1416
1417 q.setLong(queryPos++, threadId);
1418
1419 List<MBMessage> list = (List<MBMessage>)QueryUtil.list(q,
1420 getDialect(), begin, end);
1421
1422 FinderCache.putResult(finderClassNameCacheEnabled,
1423 finderClassName, finderMethodName, finderParams,
1424 finderArgs, list);
1425
1426 return list;
1427 }
1428 catch (Exception e) {
1429 throw HibernateUtil.processException(e);
1430 }
1431 finally {
1432 closeSession(session);
1433 }
1434 }
1435 else {
1436 return (List<MBMessage>)result;
1437 }
1438 }
1439
1440 public MBMessage findByC_T_First(long categoryId, long threadId,
1441 OrderByComparator obc) throws NoSuchMessageException, SystemException {
1442 List<MBMessage> list = findByC_T(categoryId, threadId, 0, 1, obc);
1443
1444 if (list.size() == 0) {
1445 StringMaker msg = new StringMaker();
1446
1447 msg.append("No MBMessage exists with the key {");
1448
1449 msg.append("categoryId=" + categoryId);
1450
1451 msg.append(", ");
1452 msg.append("threadId=" + threadId);
1453
1454 msg.append(StringPool.CLOSE_CURLY_BRACE);
1455
1456 throw new NoSuchMessageException(msg.toString());
1457 }
1458 else {
1459 return list.get(0);
1460 }
1461 }
1462
1463 public MBMessage findByC_T_Last(long categoryId, long threadId,
1464 OrderByComparator obc) throws NoSuchMessageException, SystemException {
1465 int count = countByC_T(categoryId, threadId);
1466
1467 List<MBMessage> list = findByC_T(categoryId, threadId, count - 1,
1468 count, obc);
1469
1470 if (list.size() == 0) {
1471 StringMaker msg = new StringMaker();
1472
1473 msg.append("No MBMessage exists with the key {");
1474
1475 msg.append("categoryId=" + categoryId);
1476
1477 msg.append(", ");
1478 msg.append("threadId=" + threadId);
1479
1480 msg.append(StringPool.CLOSE_CURLY_BRACE);
1481
1482 throw new NoSuchMessageException(msg.toString());
1483 }
1484 else {
1485 return list.get(0);
1486 }
1487 }
1488
1489 public MBMessage[] findByC_T_PrevAndNext(long messageId, long categoryId,
1490 long threadId, OrderByComparator obc)
1491 throws NoSuchMessageException, SystemException {
1492 MBMessage mbMessage = findByPrimaryKey(messageId);
1493
1494 int count = countByC_T(categoryId, threadId);
1495
1496 Session session = null;
1497
1498 try {
1499 session = openSession();
1500
1501 StringMaker query = new StringMaker();
1502
1503 query.append(
1504 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1505
1506 query.append("categoryId = ?");
1507
1508 query.append(" AND ");
1509
1510 query.append("threadId = ?");
1511
1512 query.append(" ");
1513
1514 if (obc != null) {
1515 query.append("ORDER BY ");
1516 query.append(obc.getOrderBy());
1517 }
1518
1519 else {
1520 query.append("ORDER BY ");
1521
1522 query.append("createDate ASC, ");
1523 query.append("messageId ASC");
1524 }
1525
1526 Query q = session.createQuery(query.toString());
1527
1528 int queryPos = 0;
1529
1530 q.setLong(queryPos++, categoryId);
1531
1532 q.setLong(queryPos++, threadId);
1533
1534 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1535 mbMessage);
1536
1537 MBMessage[] array = new MBMessageImpl[3];
1538
1539 array[0] = (MBMessage)objArray[0];
1540 array[1] = (MBMessage)objArray[1];
1541 array[2] = (MBMessage)objArray[2];
1542
1543 return array;
1544 }
1545 catch (Exception e) {
1546 throw HibernateUtil.processException(e);
1547 }
1548 finally {
1549 closeSession(session);
1550 }
1551 }
1552
1553 public List<MBMessage> findByT_P(long threadId, long parentMessageId)
1554 throws SystemException {
1555 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
1556 String finderClassName = MBMessage.class.getName();
1557 String finderMethodName = "findByT_P";
1558 String[] finderParams = new String[] {
1559 Long.class.getName(), Long.class.getName()
1560 };
1561 Object[] finderArgs = new Object[] {
1562 new Long(threadId), new Long(parentMessageId)
1563 };
1564
1565 Object result = null;
1566
1567 if (finderClassNameCacheEnabled) {
1568 result = FinderCache.getResult(finderClassName, finderMethodName,
1569 finderParams, finderArgs, getSessionFactory());
1570 }
1571
1572 if (result == null) {
1573 Session session = null;
1574
1575 try {
1576 session = openSession();
1577
1578 StringMaker query = new StringMaker();
1579
1580 query.append(
1581 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1582
1583 query.append("threadId = ?");
1584
1585 query.append(" AND ");
1586
1587 query.append("parentMessageId = ?");
1588
1589 query.append(" ");
1590
1591 query.append("ORDER BY ");
1592
1593 query.append("createDate ASC, ");
1594 query.append("messageId ASC");
1595
1596 Query q = session.createQuery(query.toString());
1597
1598 int queryPos = 0;
1599
1600 q.setLong(queryPos++, threadId);
1601
1602 q.setLong(queryPos++, parentMessageId);
1603
1604 List<MBMessage> list = q.list();
1605
1606 FinderCache.putResult(finderClassNameCacheEnabled,
1607 finderClassName, finderMethodName, finderParams,
1608 finderArgs, list);
1609
1610 return list;
1611 }
1612 catch (Exception e) {
1613 throw HibernateUtil.processException(e);
1614 }
1615 finally {
1616 closeSession(session);
1617 }
1618 }
1619 else {
1620 return (List<MBMessage>)result;
1621 }
1622 }
1623
1624 public List<MBMessage> findByT_P(long threadId, long parentMessageId,
1625 int begin, int end) throws SystemException {
1626 return findByT_P(threadId, parentMessageId, begin, end, null);
1627 }
1628
1629 public List<MBMessage> findByT_P(long threadId, long parentMessageId,
1630 int begin, int end, OrderByComparator obc) throws SystemException {
1631 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
1632 String finderClassName = MBMessage.class.getName();
1633 String finderMethodName = "findByT_P";
1634 String[] finderParams = new String[] {
1635 Long.class.getName(), Long.class.getName(),
1636
1637 "java.lang.Integer", "java.lang.Integer",
1638 "com.liferay.portal.kernel.util.OrderByComparator"
1639 };
1640 Object[] finderArgs = new Object[] {
1641 new Long(threadId), new Long(parentMessageId),
1642
1643 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1644 };
1645
1646 Object result = null;
1647
1648 if (finderClassNameCacheEnabled) {
1649 result = FinderCache.getResult(finderClassName, finderMethodName,
1650 finderParams, finderArgs, getSessionFactory());
1651 }
1652
1653 if (result == null) {
1654 Session session = null;
1655
1656 try {
1657 session = openSession();
1658
1659 StringMaker query = new StringMaker();
1660
1661 query.append(
1662 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1663
1664 query.append("threadId = ?");
1665
1666 query.append(" AND ");
1667
1668 query.append("parentMessageId = ?");
1669
1670 query.append(" ");
1671
1672 if (obc != null) {
1673 query.append("ORDER BY ");
1674 query.append(obc.getOrderBy());
1675 }
1676
1677 else {
1678 query.append("ORDER BY ");
1679
1680 query.append("createDate ASC, ");
1681 query.append("messageId ASC");
1682 }
1683
1684 Query q = session.createQuery(query.toString());
1685
1686 int queryPos = 0;
1687
1688 q.setLong(queryPos++, threadId);
1689
1690 q.setLong(queryPos++, parentMessageId);
1691
1692 List<MBMessage> list = (List<MBMessage>)QueryUtil.list(q,
1693 getDialect(), begin, end);
1694
1695 FinderCache.putResult(finderClassNameCacheEnabled,
1696 finderClassName, finderMethodName, finderParams,
1697 finderArgs, list);
1698
1699 return list;
1700 }
1701 catch (Exception e) {
1702 throw HibernateUtil.processException(e);
1703 }
1704 finally {
1705 closeSession(session);
1706 }
1707 }
1708 else {
1709 return (List<MBMessage>)result;
1710 }
1711 }
1712
1713 public MBMessage findByT_P_First(long threadId, long parentMessageId,
1714 OrderByComparator obc) throws NoSuchMessageException, SystemException {
1715 List<MBMessage> list = findByT_P(threadId, parentMessageId, 0, 1, obc);
1716
1717 if (list.size() == 0) {
1718 StringMaker msg = new StringMaker();
1719
1720 msg.append("No MBMessage exists with the key {");
1721
1722 msg.append("threadId=" + threadId);
1723
1724 msg.append(", ");
1725 msg.append("parentMessageId=" + parentMessageId);
1726
1727 msg.append(StringPool.CLOSE_CURLY_BRACE);
1728
1729 throw new NoSuchMessageException(msg.toString());
1730 }
1731 else {
1732 return list.get(0);
1733 }
1734 }
1735
1736 public MBMessage findByT_P_Last(long threadId, long parentMessageId,
1737 OrderByComparator obc) throws NoSuchMessageException, SystemException {
1738 int count = countByT_P(threadId, parentMessageId);
1739
1740 List<MBMessage> list = findByT_P(threadId, parentMessageId, count - 1,
1741 count, obc);
1742
1743 if (list.size() == 0) {
1744 StringMaker msg = new StringMaker();
1745
1746 msg.append("No MBMessage exists with the key {");
1747
1748 msg.append("threadId=" + threadId);
1749
1750 msg.append(", ");
1751 msg.append("parentMessageId=" + parentMessageId);
1752
1753 msg.append(StringPool.CLOSE_CURLY_BRACE);
1754
1755 throw new NoSuchMessageException(msg.toString());
1756 }
1757 else {
1758 return list.get(0);
1759 }
1760 }
1761
1762 public MBMessage[] findByT_P_PrevAndNext(long messageId, long threadId,
1763 long parentMessageId, OrderByComparator obc)
1764 throws NoSuchMessageException, SystemException {
1765 MBMessage mbMessage = findByPrimaryKey(messageId);
1766
1767 int count = countByT_P(threadId, parentMessageId);
1768
1769 Session session = null;
1770
1771 try {
1772 session = openSession();
1773
1774 StringMaker query = new StringMaker();
1775
1776 query.append(
1777 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1778
1779 query.append("threadId = ?");
1780
1781 query.append(" AND ");
1782
1783 query.append("parentMessageId = ?");
1784
1785 query.append(" ");
1786
1787 if (obc != null) {
1788 query.append("ORDER BY ");
1789 query.append(obc.getOrderBy());
1790 }
1791
1792 else {
1793 query.append("ORDER BY ");
1794
1795 query.append("createDate ASC, ");
1796 query.append("messageId ASC");
1797 }
1798
1799 Query q = session.createQuery(query.toString());
1800
1801 int queryPos = 0;
1802
1803 q.setLong(queryPos++, threadId);
1804
1805 q.setLong(queryPos++, parentMessageId);
1806
1807 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1808 mbMessage);
1809
1810 MBMessage[] array = new MBMessageImpl[3];
1811
1812 array[0] = (MBMessage)objArray[0];
1813 array[1] = (MBMessage)objArray[1];
1814 array[2] = (MBMessage)objArray[2];
1815
1816 return array;
1817 }
1818 catch (Exception e) {
1819 throw HibernateUtil.processException(e);
1820 }
1821 finally {
1822 closeSession(session);
1823 }
1824 }
1825
1826 public List<MBMessage> findWithDynamicQuery(
1827 DynamicQueryInitializer queryInitializer) throws SystemException {
1828 Session session = null;
1829
1830 try {
1831 session = openSession();
1832
1833 DynamicQuery query = queryInitializer.initialize(session);
1834
1835 return query.list();
1836 }
1837 catch (Exception e) {
1838 throw HibernateUtil.processException(e);
1839 }
1840 finally {
1841 closeSession(session);
1842 }
1843 }
1844
1845 public List<MBMessage> findWithDynamicQuery(
1846 DynamicQueryInitializer queryInitializer, int begin, int end)
1847 throws SystemException {
1848 Session session = null;
1849
1850 try {
1851 session = openSession();
1852
1853 DynamicQuery query = queryInitializer.initialize(session);
1854
1855 query.setLimit(begin, end);
1856
1857 return query.list();
1858 }
1859 catch (Exception e) {
1860 throw HibernateUtil.processException(e);
1861 }
1862 finally {
1863 closeSession(session);
1864 }
1865 }
1866
1867 public List<MBMessage> findAll() throws SystemException {
1868 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1869 }
1870
1871 public List<MBMessage> findAll(int begin, int end)
1872 throws SystemException {
1873 return findAll(begin, end, null);
1874 }
1875
1876 public List<MBMessage> findAll(int begin, int end, OrderByComparator obc)
1877 throws SystemException {
1878 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
1879 String finderClassName = MBMessage.class.getName();
1880 String finderMethodName = "findAll";
1881 String[] finderParams = new String[] {
1882 "java.lang.Integer", "java.lang.Integer",
1883 "com.liferay.portal.kernel.util.OrderByComparator"
1884 };
1885 Object[] finderArgs = new Object[] {
1886 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1887 };
1888
1889 Object result = null;
1890
1891 if (finderClassNameCacheEnabled) {
1892 result = FinderCache.getResult(finderClassName, finderMethodName,
1893 finderParams, finderArgs, getSessionFactory());
1894 }
1895
1896 if (result == null) {
1897 Session session = null;
1898
1899 try {
1900 session = openSession();
1901
1902 StringMaker query = new StringMaker();
1903
1904 query.append(
1905 "FROM com.liferay.portlet.messageboards.model.MBMessage ");
1906
1907 if (obc != null) {
1908 query.append("ORDER BY ");
1909 query.append(obc.getOrderBy());
1910 }
1911
1912 else {
1913 query.append("ORDER BY ");
1914
1915 query.append("createDate ASC, ");
1916 query.append("messageId ASC");
1917 }
1918
1919 Query q = session.createQuery(query.toString());
1920
1921 List<MBMessage> list = (List<MBMessage>)QueryUtil.list(q,
1922 getDialect(), begin, end);
1923
1924 if (obc == null) {
1925 Collections.sort(list);
1926 }
1927
1928 FinderCache.putResult(finderClassNameCacheEnabled,
1929 finderClassName, finderMethodName, finderParams,
1930 finderArgs, list);
1931
1932 return list;
1933 }
1934 catch (Exception e) {
1935 throw HibernateUtil.processException(e);
1936 }
1937 finally {
1938 closeSession(session);
1939 }
1940 }
1941 else {
1942 return (List<MBMessage>)result;
1943 }
1944 }
1945
1946 public void removeByUuid(String uuid) throws SystemException {
1947 for (MBMessage mbMessage : findByUuid(uuid)) {
1948 remove(mbMessage);
1949 }
1950 }
1951
1952 public void removeByCompanyId(long companyId) throws SystemException {
1953 for (MBMessage mbMessage : findByCompanyId(companyId)) {
1954 remove(mbMessage);
1955 }
1956 }
1957
1958 public void removeByCategoryId(long categoryId) throws SystemException {
1959 for (MBMessage mbMessage : findByCategoryId(categoryId)) {
1960 remove(mbMessage);
1961 }
1962 }
1963
1964 public void removeByThreadId(long threadId) throws SystemException {
1965 for (MBMessage mbMessage : findByThreadId(threadId)) {
1966 remove(mbMessage);
1967 }
1968 }
1969
1970 public void removeByC_T(long categoryId, long threadId)
1971 throws SystemException {
1972 for (MBMessage mbMessage : findByC_T(categoryId, threadId)) {
1973 remove(mbMessage);
1974 }
1975 }
1976
1977 public void removeByT_P(long threadId, long parentMessageId)
1978 throws SystemException {
1979 for (MBMessage mbMessage : findByT_P(threadId, parentMessageId)) {
1980 remove(mbMessage);
1981 }
1982 }
1983
1984 public void removeAll() throws SystemException {
1985 for (MBMessage mbMessage : findAll()) {
1986 remove(mbMessage);
1987 }
1988 }
1989
1990 public int countByUuid(String uuid) throws SystemException {
1991 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
1992 String finderClassName = MBMessage.class.getName();
1993 String finderMethodName = "countByUuid";
1994 String[] finderParams = new String[] { String.class.getName() };
1995 Object[] finderArgs = new Object[] { uuid };
1996
1997 Object result = null;
1998
1999 if (finderClassNameCacheEnabled) {
2000 result = FinderCache.getResult(finderClassName, finderMethodName,
2001 finderParams, finderArgs, getSessionFactory());
2002 }
2003
2004 if (result == null) {
2005 Session session = null;
2006
2007 try {
2008 session = openSession();
2009
2010 StringMaker query = new StringMaker();
2011
2012 query.append("SELECT COUNT(*) ");
2013 query.append(
2014 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
2015
2016 if (uuid == null) {
2017 query.append("uuid_ IS NULL");
2018 }
2019 else {
2020 query.append("uuid_ = ?");
2021 }
2022
2023 query.append(" ");
2024
2025 Query q = session.createQuery(query.toString());
2026
2027 int queryPos = 0;
2028
2029 if (uuid != null) {
2030 q.setString(queryPos++, uuid);
2031 }
2032
2033 Long count = null;
2034
2035 Iterator<Long> itr = q.list().iterator();
2036
2037 if (itr.hasNext()) {
2038 count = itr.next();
2039 }
2040
2041 if (count == null) {
2042 count = new Long(0);
2043 }
2044
2045 FinderCache.putResult(finderClassNameCacheEnabled,
2046 finderClassName, finderMethodName, finderParams,
2047 finderArgs, count);
2048
2049 return count.intValue();
2050 }
2051 catch (Exception e) {
2052 throw HibernateUtil.processException(e);
2053 }
2054 finally {
2055 closeSession(session);
2056 }
2057 }
2058 else {
2059 return ((Long)result).intValue();
2060 }
2061 }
2062
2063 public int countByCompanyId(long companyId) throws SystemException {
2064 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
2065 String finderClassName = MBMessage.class.getName();
2066 String finderMethodName = "countByCompanyId";
2067 String[] finderParams = new String[] { Long.class.getName() };
2068 Object[] finderArgs = new Object[] { new Long(companyId) };
2069
2070 Object result = null;
2071
2072 if (finderClassNameCacheEnabled) {
2073 result = FinderCache.getResult(finderClassName, finderMethodName,
2074 finderParams, finderArgs, getSessionFactory());
2075 }
2076
2077 if (result == null) {
2078 Session session = null;
2079
2080 try {
2081 session = openSession();
2082
2083 StringMaker query = new StringMaker();
2084
2085 query.append("SELECT COUNT(*) ");
2086 query.append(
2087 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
2088
2089 query.append("companyId = ?");
2090
2091 query.append(" ");
2092
2093 Query q = session.createQuery(query.toString());
2094
2095 int queryPos = 0;
2096
2097 q.setLong(queryPos++, companyId);
2098
2099 Long count = null;
2100
2101 Iterator<Long> itr = q.list().iterator();
2102
2103 if (itr.hasNext()) {
2104 count = itr.next();
2105 }
2106
2107 if (count == null) {
2108 count = new Long(0);
2109 }
2110
2111 FinderCache.putResult(finderClassNameCacheEnabled,
2112 finderClassName, finderMethodName, finderParams,
2113 finderArgs, count);
2114
2115 return count.intValue();
2116 }
2117 catch (Exception e) {
2118 throw HibernateUtil.processException(e);
2119 }
2120 finally {
2121 closeSession(session);
2122 }
2123 }
2124 else {
2125 return ((Long)result).intValue();
2126 }
2127 }
2128
2129 public int countByCategoryId(long categoryId) throws SystemException {
2130 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
2131 String finderClassName = MBMessage.class.getName();
2132 String finderMethodName = "countByCategoryId";
2133 String[] finderParams = new String[] { Long.class.getName() };
2134 Object[] finderArgs = new Object[] { new Long(categoryId) };
2135
2136 Object result = null;
2137
2138 if (finderClassNameCacheEnabled) {
2139 result = FinderCache.getResult(finderClassName, finderMethodName,
2140 finderParams, finderArgs, getSessionFactory());
2141 }
2142
2143 if (result == null) {
2144 Session session = null;
2145
2146 try {
2147 session = openSession();
2148
2149 StringMaker query = new StringMaker();
2150
2151 query.append("SELECT COUNT(*) ");
2152 query.append(
2153 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
2154
2155 query.append("categoryId = ?");
2156
2157 query.append(" ");
2158
2159 Query q = session.createQuery(query.toString());
2160
2161 int queryPos = 0;
2162
2163 q.setLong(queryPos++, categoryId);
2164
2165 Long count = null;
2166
2167 Iterator<Long> itr = q.list().iterator();
2168
2169 if (itr.hasNext()) {
2170 count = itr.next();
2171 }
2172
2173 if (count == null) {
2174 count = new Long(0);
2175 }
2176
2177 FinderCache.putResult(finderClassNameCacheEnabled,
2178 finderClassName, finderMethodName, finderParams,
2179 finderArgs, count);
2180
2181 return count.intValue();
2182 }
2183 catch (Exception e) {
2184 throw HibernateUtil.processException(e);
2185 }
2186 finally {
2187 closeSession(session);
2188 }
2189 }
2190 else {
2191 return ((Long)result).intValue();
2192 }
2193 }
2194
2195 public int countByThreadId(long threadId) throws SystemException {
2196 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
2197 String finderClassName = MBMessage.class.getName();
2198 String finderMethodName = "countByThreadId";
2199 String[] finderParams = new String[] { Long.class.getName() };
2200 Object[] finderArgs = new Object[] { new Long(threadId) };
2201
2202 Object result = null;
2203
2204 if (finderClassNameCacheEnabled) {
2205 result = FinderCache.getResult(finderClassName, finderMethodName,
2206 finderParams, finderArgs, getSessionFactory());
2207 }
2208
2209 if (result == null) {
2210 Session session = null;
2211
2212 try {
2213 session = openSession();
2214
2215 StringMaker query = new StringMaker();
2216
2217 query.append("SELECT COUNT(*) ");
2218 query.append(
2219 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
2220
2221 query.append("threadId = ?");
2222
2223 query.append(" ");
2224
2225 Query q = session.createQuery(query.toString());
2226
2227 int queryPos = 0;
2228
2229 q.setLong(queryPos++, threadId);
2230
2231 Long count = null;
2232
2233 Iterator<Long> itr = q.list().iterator();
2234
2235 if (itr.hasNext()) {
2236 count = itr.next();
2237 }
2238
2239 if (count == null) {
2240 count = new Long(0);
2241 }
2242
2243 FinderCache.putResult(finderClassNameCacheEnabled,
2244 finderClassName, finderMethodName, finderParams,
2245 finderArgs, count);
2246
2247 return count.intValue();
2248 }
2249 catch (Exception e) {
2250 throw HibernateUtil.processException(e);
2251 }
2252 finally {
2253 closeSession(session);
2254 }
2255 }
2256 else {
2257 return ((Long)result).intValue();
2258 }
2259 }
2260
2261 public int countByC_T(long categoryId, long threadId)
2262 throws SystemException {
2263 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
2264 String finderClassName = MBMessage.class.getName();
2265 String finderMethodName = "countByC_T";
2266 String[] finderParams = new String[] {
2267 Long.class.getName(), Long.class.getName()
2268 };
2269 Object[] finderArgs = new Object[] {
2270 new Long(categoryId), new Long(threadId)
2271 };
2272
2273 Object result = null;
2274
2275 if (finderClassNameCacheEnabled) {
2276 result = FinderCache.getResult(finderClassName, finderMethodName,
2277 finderParams, finderArgs, getSessionFactory());
2278 }
2279
2280 if (result == null) {
2281 Session session = null;
2282
2283 try {
2284 session = openSession();
2285
2286 StringMaker query = new StringMaker();
2287
2288 query.append("SELECT COUNT(*) ");
2289 query.append(
2290 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
2291
2292 query.append("categoryId = ?");
2293
2294 query.append(" AND ");
2295
2296 query.append("threadId = ?");
2297
2298 query.append(" ");
2299
2300 Query q = session.createQuery(query.toString());
2301
2302 int queryPos = 0;
2303
2304 q.setLong(queryPos++, categoryId);
2305
2306 q.setLong(queryPos++, threadId);
2307
2308 Long count = null;
2309
2310 Iterator<Long> itr = q.list().iterator();
2311
2312 if (itr.hasNext()) {
2313 count = itr.next();
2314 }
2315
2316 if (count == null) {
2317 count = new Long(0);
2318 }
2319
2320 FinderCache.putResult(finderClassNameCacheEnabled,
2321 finderClassName, finderMethodName, finderParams,
2322 finderArgs, count);
2323
2324 return count.intValue();
2325 }
2326 catch (Exception e) {
2327 throw HibernateUtil.processException(e);
2328 }
2329 finally {
2330 closeSession(session);
2331 }
2332 }
2333 else {
2334 return ((Long)result).intValue();
2335 }
2336 }
2337
2338 public int countByT_P(long threadId, long parentMessageId)
2339 throws SystemException {
2340 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
2341 String finderClassName = MBMessage.class.getName();
2342 String finderMethodName = "countByT_P";
2343 String[] finderParams = new String[] {
2344 Long.class.getName(), Long.class.getName()
2345 };
2346 Object[] finderArgs = new Object[] {
2347 new Long(threadId), new Long(parentMessageId)
2348 };
2349
2350 Object result = null;
2351
2352 if (finderClassNameCacheEnabled) {
2353 result = FinderCache.getResult(finderClassName, finderMethodName,
2354 finderParams, finderArgs, getSessionFactory());
2355 }
2356
2357 if (result == null) {
2358 Session session = null;
2359
2360 try {
2361 session = openSession();
2362
2363 StringMaker query = new StringMaker();
2364
2365 query.append("SELECT COUNT(*) ");
2366 query.append(
2367 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
2368
2369 query.append("threadId = ?");
2370
2371 query.append(" AND ");
2372
2373 query.append("parentMessageId = ?");
2374
2375 query.append(" ");
2376
2377 Query q = session.createQuery(query.toString());
2378
2379 int queryPos = 0;
2380
2381 q.setLong(queryPos++, threadId);
2382
2383 q.setLong(queryPos++, parentMessageId);
2384
2385 Long count = null;
2386
2387 Iterator<Long> itr = q.list().iterator();
2388
2389 if (itr.hasNext()) {
2390 count = itr.next();
2391 }
2392
2393 if (count == null) {
2394 count = new Long(0);
2395 }
2396
2397 FinderCache.putResult(finderClassNameCacheEnabled,
2398 finderClassName, finderMethodName, finderParams,
2399 finderArgs, count);
2400
2401 return count.intValue();
2402 }
2403 catch (Exception e) {
2404 throw HibernateUtil.processException(e);
2405 }
2406 finally {
2407 closeSession(session);
2408 }
2409 }
2410 else {
2411 return ((Long)result).intValue();
2412 }
2413 }
2414
2415 public int countAll() throws SystemException {
2416 boolean finderClassNameCacheEnabled = MBMessageModelImpl.CACHE_ENABLED;
2417 String finderClassName = MBMessage.class.getName();
2418 String finderMethodName = "countAll";
2419 String[] finderParams = new String[] { };
2420 Object[] finderArgs = new Object[] { };
2421
2422 Object result = null;
2423
2424 if (finderClassNameCacheEnabled) {
2425 result = FinderCache.getResult(finderClassName, finderMethodName,
2426 finderParams, finderArgs, getSessionFactory());
2427 }
2428
2429 if (result == null) {
2430 Session session = null;
2431
2432 try {
2433 session = openSession();
2434
2435 Query q = session.createQuery(
2436 "SELECT COUNT(*) FROM com.liferay.portlet.messageboards.model.MBMessage");
2437
2438 Long count = null;
2439
2440 Iterator<Long> itr = q.list().iterator();
2441
2442 if (itr.hasNext()) {
2443 count = itr.next();
2444 }
2445
2446 if (count == null) {
2447 count = new Long(0);
2448 }
2449
2450 FinderCache.putResult(finderClassNameCacheEnabled,
2451 finderClassName, finderMethodName, finderParams,
2452 finderArgs, count);
2453
2454 return count.intValue();
2455 }
2456 catch (Exception e) {
2457 throw HibernateUtil.processException(e);
2458 }
2459 finally {
2460 closeSession(session);
2461 }
2462 }
2463 else {
2464 return ((Long)result).intValue();
2465 }
2466 }
2467
2468 protected void initDao() {
2469 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2470 PropsUtil.get(
2471 "value.object.listener.com.liferay.portlet.messageboards.model.MBMessage")));
2472
2473 if (listenerClassNames.length > 0) {
2474 try {
2475 List<ModelListener> listeners = new ArrayList<ModelListener>();
2476
2477 for (String listenerClassName : listenerClassNames) {
2478 listeners.add((ModelListener)Class.forName(
2479 listenerClassName).newInstance());
2480 }
2481
2482 _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2483 }
2484 catch (Exception e) {
2485 _log.error(e);
2486 }
2487 }
2488 }
2489
2490 private static Log _log = LogFactory.getLog(MBMessagePersistenceImpl.class);
2491 private ModelListener[] _listeners;
2492}