1
22
23 package com.liferay.portal.service.persistence;
24
25 import com.liferay.portal.NoSuchActivityTrackerException;
26 import com.liferay.portal.SystemException;
27 import com.liferay.portal.kernel.dao.DynamicQuery;
28 import com.liferay.portal.kernel.dao.DynamicQueryInitializer;
29 import com.liferay.portal.kernel.util.GetterUtil;
30 import com.liferay.portal.kernel.util.OrderByComparator;
31 import com.liferay.portal.kernel.util.StringMaker;
32 import com.liferay.portal.kernel.util.StringPool;
33 import com.liferay.portal.kernel.util.Validator;
34 import com.liferay.portal.model.ActivityTracker;
35 import com.liferay.portal.model.ModelListener;
36 import com.liferay.portal.model.impl.ActivityTrackerImpl;
37 import com.liferay.portal.model.impl.ActivityTrackerModelImpl;
38 import com.liferay.portal.spring.hibernate.FinderCache;
39 import com.liferay.portal.spring.hibernate.HibernateUtil;
40 import com.liferay.portal.util.PropsUtil;
41
42 import com.liferay.util.dao.hibernate.QueryUtil;
43
44 import org.apache.commons.logging.Log;
45 import org.apache.commons.logging.LogFactory;
46
47 import org.hibernate.Query;
48 import org.hibernate.Session;
49
50 import java.util.Collections;
51 import java.util.Iterator;
52 import java.util.List;
53
54
60 public class ActivityTrackerPersistenceImpl extends BasePersistence
61 implements ActivityTrackerPersistence {
62 public ActivityTracker create(long activityTrackerId) {
63 ActivityTracker activityTracker = new ActivityTrackerImpl();
64
65 activityTracker.setNew(true);
66 activityTracker.setPrimaryKey(activityTrackerId);
67
68 return activityTracker;
69 }
70
71 public ActivityTracker remove(long activityTrackerId)
72 throws NoSuchActivityTrackerException, SystemException {
73 Session session = null;
74
75 try {
76 session = openSession();
77
78 ActivityTracker activityTracker = (ActivityTracker)session.get(ActivityTrackerImpl.class,
79 new Long(activityTrackerId));
80
81 if (activityTracker == null) {
82 if (_log.isWarnEnabled()) {
83 _log.warn("No ActivityTracker exists with the primary key " +
84 activityTrackerId);
85 }
86
87 throw new NoSuchActivityTrackerException(
88 "No ActivityTracker exists with the primary key " +
89 activityTrackerId);
90 }
91
92 return remove(activityTracker);
93 }
94 catch (NoSuchActivityTrackerException nsee) {
95 throw nsee;
96 }
97 catch (Exception e) {
98 throw HibernateUtil.processException(e);
99 }
100 finally {
101 closeSession(session);
102 }
103 }
104
105 public ActivityTracker remove(ActivityTracker activityTracker)
106 throws SystemException {
107 ModelListener listener = _getListener();
108
109 if (listener != null) {
110 listener.onBeforeRemove(activityTracker);
111 }
112
113 activityTracker = removeImpl(activityTracker);
114
115 if (listener != null) {
116 listener.onAfterRemove(activityTracker);
117 }
118
119 return activityTracker;
120 }
121
122 protected ActivityTracker removeImpl(ActivityTracker activityTracker)
123 throws SystemException {
124 Session session = null;
125
126 try {
127 session = openSession();
128
129 session.delete(activityTracker);
130
131 session.flush();
132
133 return activityTracker;
134 }
135 catch (Exception e) {
136 throw HibernateUtil.processException(e);
137 }
138 finally {
139 closeSession(session);
140
141 FinderCache.clearCache(ActivityTracker.class.getName());
142 }
143 }
144
145 public ActivityTracker update(ActivityTracker activityTracker)
146 throws SystemException {
147 return update(activityTracker, false);
148 }
149
150 public ActivityTracker update(ActivityTracker activityTracker, boolean merge)
151 throws SystemException {
152 ModelListener listener = _getListener();
153
154 boolean isNew = activityTracker.isNew();
155
156 if (listener != null) {
157 if (isNew) {
158 listener.onBeforeCreate(activityTracker);
159 }
160 else {
161 listener.onBeforeUpdate(activityTracker);
162 }
163 }
164
165 activityTracker = updateImpl(activityTracker, merge);
166
167 if (listener != null) {
168 if (isNew) {
169 listener.onAfterCreate(activityTracker);
170 }
171 else {
172 listener.onAfterUpdate(activityTracker);
173 }
174 }
175
176 return activityTracker;
177 }
178
179 public ActivityTracker updateImpl(
180 com.liferay.portal.model.ActivityTracker activityTracker, boolean merge)
181 throws SystemException {
182 Session session = null;
183
184 try {
185 session = openSession();
186
187 if (merge) {
188 session.merge(activityTracker);
189 }
190 else {
191 if (activityTracker.isNew()) {
192 session.save(activityTracker);
193 }
194 }
195
196 session.flush();
197
198 activityTracker.setNew(false);
199
200 return activityTracker;
201 }
202 catch (Exception e) {
203 throw HibernateUtil.processException(e);
204 }
205 finally {
206 closeSession(session);
207
208 FinderCache.clearCache(ActivityTracker.class.getName());
209 }
210 }
211
212 public ActivityTracker findByPrimaryKey(long activityTrackerId)
213 throws NoSuchActivityTrackerException, SystemException {
214 ActivityTracker activityTracker = fetchByPrimaryKey(activityTrackerId);
215
216 if (activityTracker == null) {
217 if (_log.isWarnEnabled()) {
218 _log.warn("No ActivityTracker exists with the primary key " +
219 activityTrackerId);
220 }
221
222 throw new NoSuchActivityTrackerException(
223 "No ActivityTracker exists with the primary key " +
224 activityTrackerId);
225 }
226
227 return activityTracker;
228 }
229
230 public ActivityTracker fetchByPrimaryKey(long activityTrackerId)
231 throws SystemException {
232 Session session = null;
233
234 try {
235 session = openSession();
236
237 return (ActivityTracker)session.get(ActivityTrackerImpl.class,
238 new Long(activityTrackerId));
239 }
240 catch (Exception e) {
241 throw HibernateUtil.processException(e);
242 }
243 finally {
244 closeSession(session);
245 }
246 }
247
248 public List findByGroupId(long groupId) throws SystemException {
249 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
250 String finderClassName = ActivityTracker.class.getName();
251 String finderMethodName = "findByGroupId";
252 String[] finderParams = new String[] { Long.class.getName() };
253 Object[] finderArgs = new Object[] { new Long(groupId) };
254
255 Object result = null;
256
257 if (finderClassNameCacheEnabled) {
258 result = FinderCache.getResult(finderClassName, finderMethodName,
259 finderParams, finderArgs, getSessionFactory());
260 }
261
262 if (result == null) {
263 Session session = null;
264
265 try {
266 session = openSession();
267
268 StringMaker query = new StringMaker();
269
270 query.append(
271 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
272
273 query.append("groupId = ?");
274
275 query.append(" ");
276
277 query.append("ORDER BY ");
278
279 query.append("createDate DESC");
280
281 Query q = session.createQuery(query.toString());
282
283 int queryPos = 0;
284
285 q.setLong(queryPos++, groupId);
286
287 List list = q.list();
288
289 FinderCache.putResult(finderClassNameCacheEnabled,
290 finderClassName, finderMethodName, finderParams,
291 finderArgs, list);
292
293 return list;
294 }
295 catch (Exception e) {
296 throw HibernateUtil.processException(e);
297 }
298 finally {
299 closeSession(session);
300 }
301 }
302 else {
303 return (List)result;
304 }
305 }
306
307 public List findByGroupId(long groupId, int begin, int end)
308 throws SystemException {
309 return findByGroupId(groupId, begin, end, null);
310 }
311
312 public List findByGroupId(long groupId, int begin, int end,
313 OrderByComparator obc) throws SystemException {
314 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
315 String finderClassName = ActivityTracker.class.getName();
316 String finderMethodName = "findByGroupId";
317 String[] finderParams = new String[] {
318 Long.class.getName(),
319
320 "java.lang.Integer", "java.lang.Integer",
321 "com.liferay.portal.kernel.util.OrderByComparator"
322 };
323 Object[] finderArgs = new Object[] {
324 new Long(groupId),
325
326 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
327 };
328
329 Object result = null;
330
331 if (finderClassNameCacheEnabled) {
332 result = FinderCache.getResult(finderClassName, finderMethodName,
333 finderParams, finderArgs, getSessionFactory());
334 }
335
336 if (result == null) {
337 Session session = null;
338
339 try {
340 session = openSession();
341
342 StringMaker query = new StringMaker();
343
344 query.append(
345 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
346
347 query.append("groupId = ?");
348
349 query.append(" ");
350
351 if (obc != null) {
352 query.append("ORDER BY ");
353 query.append(obc.getOrderBy());
354 }
355
356 else {
357 query.append("ORDER BY ");
358
359 query.append("createDate DESC");
360 }
361
362 Query q = session.createQuery(query.toString());
363
364 int queryPos = 0;
365
366 q.setLong(queryPos++, groupId);
367
368 List list = QueryUtil.list(q, getDialect(), begin, end);
369
370 FinderCache.putResult(finderClassNameCacheEnabled,
371 finderClassName, finderMethodName, finderParams,
372 finderArgs, list);
373
374 return list;
375 }
376 catch (Exception e) {
377 throw HibernateUtil.processException(e);
378 }
379 finally {
380 closeSession(session);
381 }
382 }
383 else {
384 return (List)result;
385 }
386 }
387
388 public ActivityTracker findByGroupId_First(long groupId,
389 OrderByComparator obc)
390 throws NoSuchActivityTrackerException, SystemException {
391 List list = findByGroupId(groupId, 0, 1, obc);
392
393 if (list.size() == 0) {
394 StringMaker msg = new StringMaker();
395
396 msg.append("No ActivityTracker exists with the key {");
397
398 msg.append("groupId=" + groupId);
399
400 msg.append(StringPool.CLOSE_CURLY_BRACE);
401
402 throw new NoSuchActivityTrackerException(msg.toString());
403 }
404 else {
405 return (ActivityTracker)list.get(0);
406 }
407 }
408
409 public ActivityTracker findByGroupId_Last(long groupId,
410 OrderByComparator obc)
411 throws NoSuchActivityTrackerException, SystemException {
412 int count = countByGroupId(groupId);
413
414 List list = findByGroupId(groupId, count - 1, count, obc);
415
416 if (list.size() == 0) {
417 StringMaker msg = new StringMaker();
418
419 msg.append("No ActivityTracker exists with the key {");
420
421 msg.append("groupId=" + groupId);
422
423 msg.append(StringPool.CLOSE_CURLY_BRACE);
424
425 throw new NoSuchActivityTrackerException(msg.toString());
426 }
427 else {
428 return (ActivityTracker)list.get(0);
429 }
430 }
431
432 public ActivityTracker[] findByGroupId_PrevAndNext(long activityTrackerId,
433 long groupId, OrderByComparator obc)
434 throws NoSuchActivityTrackerException, SystemException {
435 ActivityTracker activityTracker = findByPrimaryKey(activityTrackerId);
436
437 int count = countByGroupId(groupId);
438
439 Session session = null;
440
441 try {
442 session = openSession();
443
444 StringMaker query = new StringMaker();
445
446 query.append("FROM com.liferay.portal.model.ActivityTracker WHERE ");
447
448 query.append("groupId = ?");
449
450 query.append(" ");
451
452 if (obc != null) {
453 query.append("ORDER BY ");
454 query.append(obc.getOrderBy());
455 }
456
457 else {
458 query.append("ORDER BY ");
459
460 query.append("createDate DESC");
461 }
462
463 Query q = session.createQuery(query.toString());
464
465 int queryPos = 0;
466
467 q.setLong(queryPos++, groupId);
468
469 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
470 activityTracker);
471
472 ActivityTracker[] array = new ActivityTrackerImpl[3];
473
474 array[0] = (ActivityTracker)objArray[0];
475 array[1] = (ActivityTracker)objArray[1];
476 array[2] = (ActivityTracker)objArray[2];
477
478 return array;
479 }
480 catch (Exception e) {
481 throw HibernateUtil.processException(e);
482 }
483 finally {
484 closeSession(session);
485 }
486 }
487
488 public List findByCompanyId(long companyId) throws SystemException {
489 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
490 String finderClassName = ActivityTracker.class.getName();
491 String finderMethodName = "findByCompanyId";
492 String[] finderParams = new String[] { Long.class.getName() };
493 Object[] finderArgs = new Object[] { new Long(companyId) };
494
495 Object result = null;
496
497 if (finderClassNameCacheEnabled) {
498 result = FinderCache.getResult(finderClassName, finderMethodName,
499 finderParams, finderArgs, getSessionFactory());
500 }
501
502 if (result == null) {
503 Session session = null;
504
505 try {
506 session = openSession();
507
508 StringMaker query = new StringMaker();
509
510 query.append(
511 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
512
513 query.append("companyId = ?");
514
515 query.append(" ");
516
517 query.append("ORDER BY ");
518
519 query.append("createDate DESC");
520
521 Query q = session.createQuery(query.toString());
522
523 int queryPos = 0;
524
525 q.setLong(queryPos++, companyId);
526
527 List list = q.list();
528
529 FinderCache.putResult(finderClassNameCacheEnabled,
530 finderClassName, finderMethodName, finderParams,
531 finderArgs, list);
532
533 return list;
534 }
535 catch (Exception e) {
536 throw HibernateUtil.processException(e);
537 }
538 finally {
539 closeSession(session);
540 }
541 }
542 else {
543 return (List)result;
544 }
545 }
546
547 public List findByCompanyId(long companyId, int begin, int end)
548 throws SystemException {
549 return findByCompanyId(companyId, begin, end, null);
550 }
551
552 public List findByCompanyId(long companyId, int begin, int end,
553 OrderByComparator obc) throws SystemException {
554 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
555 String finderClassName = ActivityTracker.class.getName();
556 String finderMethodName = "findByCompanyId";
557 String[] finderParams = new String[] {
558 Long.class.getName(),
559
560 "java.lang.Integer", "java.lang.Integer",
561 "com.liferay.portal.kernel.util.OrderByComparator"
562 };
563 Object[] finderArgs = new Object[] {
564 new Long(companyId),
565
566 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
567 };
568
569 Object result = null;
570
571 if (finderClassNameCacheEnabled) {
572 result = FinderCache.getResult(finderClassName, finderMethodName,
573 finderParams, finderArgs, getSessionFactory());
574 }
575
576 if (result == null) {
577 Session session = null;
578
579 try {
580 session = openSession();
581
582 StringMaker query = new StringMaker();
583
584 query.append(
585 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
586
587 query.append("companyId = ?");
588
589 query.append(" ");
590
591 if (obc != null) {
592 query.append("ORDER BY ");
593 query.append(obc.getOrderBy());
594 }
595
596 else {
597 query.append("ORDER BY ");
598
599 query.append("createDate DESC");
600 }
601
602 Query q = session.createQuery(query.toString());
603
604 int queryPos = 0;
605
606 q.setLong(queryPos++, companyId);
607
608 List list = QueryUtil.list(q, getDialect(), begin, end);
609
610 FinderCache.putResult(finderClassNameCacheEnabled,
611 finderClassName, finderMethodName, finderParams,
612 finderArgs, list);
613
614 return list;
615 }
616 catch (Exception e) {
617 throw HibernateUtil.processException(e);
618 }
619 finally {
620 closeSession(session);
621 }
622 }
623 else {
624 return (List)result;
625 }
626 }
627
628 public ActivityTracker findByCompanyId_First(long companyId,
629 OrderByComparator obc)
630 throws NoSuchActivityTrackerException, SystemException {
631 List list = findByCompanyId(companyId, 0, 1, obc);
632
633 if (list.size() == 0) {
634 StringMaker msg = new StringMaker();
635
636 msg.append("No ActivityTracker exists with the key {");
637
638 msg.append("companyId=" + companyId);
639
640 msg.append(StringPool.CLOSE_CURLY_BRACE);
641
642 throw new NoSuchActivityTrackerException(msg.toString());
643 }
644 else {
645 return (ActivityTracker)list.get(0);
646 }
647 }
648
649 public ActivityTracker findByCompanyId_Last(long companyId,
650 OrderByComparator obc)
651 throws NoSuchActivityTrackerException, SystemException {
652 int count = countByCompanyId(companyId);
653
654 List list = findByCompanyId(companyId, count - 1, count, obc);
655
656 if (list.size() == 0) {
657 StringMaker msg = new StringMaker();
658
659 msg.append("No ActivityTracker exists with the key {");
660
661 msg.append("companyId=" + companyId);
662
663 msg.append(StringPool.CLOSE_CURLY_BRACE);
664
665 throw new NoSuchActivityTrackerException(msg.toString());
666 }
667 else {
668 return (ActivityTracker)list.get(0);
669 }
670 }
671
672 public ActivityTracker[] findByCompanyId_PrevAndNext(
673 long activityTrackerId, long companyId, OrderByComparator obc)
674 throws NoSuchActivityTrackerException, SystemException {
675 ActivityTracker activityTracker = findByPrimaryKey(activityTrackerId);
676
677 int count = countByCompanyId(companyId);
678
679 Session session = null;
680
681 try {
682 session = openSession();
683
684 StringMaker query = new StringMaker();
685
686 query.append("FROM com.liferay.portal.model.ActivityTracker WHERE ");
687
688 query.append("companyId = ?");
689
690 query.append(" ");
691
692 if (obc != null) {
693 query.append("ORDER BY ");
694 query.append(obc.getOrderBy());
695 }
696
697 else {
698 query.append("ORDER BY ");
699
700 query.append("createDate DESC");
701 }
702
703 Query q = session.createQuery(query.toString());
704
705 int queryPos = 0;
706
707 q.setLong(queryPos++, companyId);
708
709 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
710 activityTracker);
711
712 ActivityTracker[] array = new ActivityTrackerImpl[3];
713
714 array[0] = (ActivityTracker)objArray[0];
715 array[1] = (ActivityTracker)objArray[1];
716 array[2] = (ActivityTracker)objArray[2];
717
718 return array;
719 }
720 catch (Exception e) {
721 throw HibernateUtil.processException(e);
722 }
723 finally {
724 closeSession(session);
725 }
726 }
727
728 public List findByUserId(long userId) throws SystemException {
729 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
730 String finderClassName = ActivityTracker.class.getName();
731 String finderMethodName = "findByUserId";
732 String[] finderParams = new String[] { Long.class.getName() };
733 Object[] finderArgs = new Object[] { new Long(userId) };
734
735 Object result = null;
736
737 if (finderClassNameCacheEnabled) {
738 result = FinderCache.getResult(finderClassName, finderMethodName,
739 finderParams, finderArgs, getSessionFactory());
740 }
741
742 if (result == null) {
743 Session session = null;
744
745 try {
746 session = openSession();
747
748 StringMaker query = new StringMaker();
749
750 query.append(
751 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
752
753 query.append("userId = ?");
754
755 query.append(" ");
756
757 query.append("ORDER BY ");
758
759 query.append("createDate DESC");
760
761 Query q = session.createQuery(query.toString());
762
763 int queryPos = 0;
764
765 q.setLong(queryPos++, userId);
766
767 List list = q.list();
768
769 FinderCache.putResult(finderClassNameCacheEnabled,
770 finderClassName, finderMethodName, finderParams,
771 finderArgs, list);
772
773 return list;
774 }
775 catch (Exception e) {
776 throw HibernateUtil.processException(e);
777 }
778 finally {
779 closeSession(session);
780 }
781 }
782 else {
783 return (List)result;
784 }
785 }
786
787 public List findByUserId(long userId, int begin, int end)
788 throws SystemException {
789 return findByUserId(userId, begin, end, null);
790 }
791
792 public List findByUserId(long userId, int begin, int end,
793 OrderByComparator obc) throws SystemException {
794 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
795 String finderClassName = ActivityTracker.class.getName();
796 String finderMethodName = "findByUserId";
797 String[] finderParams = new String[] {
798 Long.class.getName(),
799
800 "java.lang.Integer", "java.lang.Integer",
801 "com.liferay.portal.kernel.util.OrderByComparator"
802 };
803 Object[] finderArgs = new Object[] {
804 new Long(userId),
805
806 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
807 };
808
809 Object result = null;
810
811 if (finderClassNameCacheEnabled) {
812 result = FinderCache.getResult(finderClassName, finderMethodName,
813 finderParams, finderArgs, getSessionFactory());
814 }
815
816 if (result == null) {
817 Session session = null;
818
819 try {
820 session = openSession();
821
822 StringMaker query = new StringMaker();
823
824 query.append(
825 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
826
827 query.append("userId = ?");
828
829 query.append(" ");
830
831 if (obc != null) {
832 query.append("ORDER BY ");
833 query.append(obc.getOrderBy());
834 }
835
836 else {
837 query.append("ORDER BY ");
838
839 query.append("createDate DESC");
840 }
841
842 Query q = session.createQuery(query.toString());
843
844 int queryPos = 0;
845
846 q.setLong(queryPos++, userId);
847
848 List list = QueryUtil.list(q, getDialect(), begin, end);
849
850 FinderCache.putResult(finderClassNameCacheEnabled,
851 finderClassName, finderMethodName, finderParams,
852 finderArgs, list);
853
854 return list;
855 }
856 catch (Exception e) {
857 throw HibernateUtil.processException(e);
858 }
859 finally {
860 closeSession(session);
861 }
862 }
863 else {
864 return (List)result;
865 }
866 }
867
868 public ActivityTracker findByUserId_First(long userId, OrderByComparator obc)
869 throws NoSuchActivityTrackerException, SystemException {
870 List list = findByUserId(userId, 0, 1, obc);
871
872 if (list.size() == 0) {
873 StringMaker msg = new StringMaker();
874
875 msg.append("No ActivityTracker exists with the key {");
876
877 msg.append("userId=" + userId);
878
879 msg.append(StringPool.CLOSE_CURLY_BRACE);
880
881 throw new NoSuchActivityTrackerException(msg.toString());
882 }
883 else {
884 return (ActivityTracker)list.get(0);
885 }
886 }
887
888 public ActivityTracker findByUserId_Last(long userId, OrderByComparator obc)
889 throws NoSuchActivityTrackerException, SystemException {
890 int count = countByUserId(userId);
891
892 List list = findByUserId(userId, count - 1, count, obc);
893
894 if (list.size() == 0) {
895 StringMaker msg = new StringMaker();
896
897 msg.append("No ActivityTracker exists with the key {");
898
899 msg.append("userId=" + userId);
900
901 msg.append(StringPool.CLOSE_CURLY_BRACE);
902
903 throw new NoSuchActivityTrackerException(msg.toString());
904 }
905 else {
906 return (ActivityTracker)list.get(0);
907 }
908 }
909
910 public ActivityTracker[] findByUserId_PrevAndNext(long activityTrackerId,
911 long userId, OrderByComparator obc)
912 throws NoSuchActivityTrackerException, SystemException {
913 ActivityTracker activityTracker = findByPrimaryKey(activityTrackerId);
914
915 int count = countByUserId(userId);
916
917 Session session = null;
918
919 try {
920 session = openSession();
921
922 StringMaker query = new StringMaker();
923
924 query.append("FROM com.liferay.portal.model.ActivityTracker WHERE ");
925
926 query.append("userId = ?");
927
928 query.append(" ");
929
930 if (obc != null) {
931 query.append("ORDER BY ");
932 query.append(obc.getOrderBy());
933 }
934
935 else {
936 query.append("ORDER BY ");
937
938 query.append("createDate DESC");
939 }
940
941 Query q = session.createQuery(query.toString());
942
943 int queryPos = 0;
944
945 q.setLong(queryPos++, userId);
946
947 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
948 activityTracker);
949
950 ActivityTracker[] array = new ActivityTrackerImpl[3];
951
952 array[0] = (ActivityTracker)objArray[0];
953 array[1] = (ActivityTracker)objArray[1];
954 array[2] = (ActivityTracker)objArray[2];
955
956 return array;
957 }
958 catch (Exception e) {
959 throw HibernateUtil.processException(e);
960 }
961 finally {
962 closeSession(session);
963 }
964 }
965
966 public List findByReceiverUserId(long receiverUserId)
967 throws SystemException {
968 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
969 String finderClassName = ActivityTracker.class.getName();
970 String finderMethodName = "findByReceiverUserId";
971 String[] finderParams = new String[] { Long.class.getName() };
972 Object[] finderArgs = new Object[] { new Long(receiverUserId) };
973
974 Object result = null;
975
976 if (finderClassNameCacheEnabled) {
977 result = FinderCache.getResult(finderClassName, finderMethodName,
978 finderParams, finderArgs, getSessionFactory());
979 }
980
981 if (result == null) {
982 Session session = null;
983
984 try {
985 session = openSession();
986
987 StringMaker query = new StringMaker();
988
989 query.append(
990 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
991
992 query.append("receiverUserId = ?");
993
994 query.append(" ");
995
996 query.append("ORDER BY ");
997
998 query.append("createDate DESC");
999
1000 Query q = session.createQuery(query.toString());
1001
1002 int queryPos = 0;
1003
1004 q.setLong(queryPos++, receiverUserId);
1005
1006 List list = q.list();
1007
1008 FinderCache.putResult(finderClassNameCacheEnabled,
1009 finderClassName, finderMethodName, finderParams,
1010 finderArgs, list);
1011
1012 return list;
1013 }
1014 catch (Exception e) {
1015 throw HibernateUtil.processException(e);
1016 }
1017 finally {
1018 closeSession(session);
1019 }
1020 }
1021 else {
1022 return (List)result;
1023 }
1024 }
1025
1026 public List findByReceiverUserId(long receiverUserId, int begin, int end)
1027 throws SystemException {
1028 return findByReceiverUserId(receiverUserId, begin, end, null);
1029 }
1030
1031 public List findByReceiverUserId(long receiverUserId, int begin, int end,
1032 OrderByComparator obc) throws SystemException {
1033 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
1034 String finderClassName = ActivityTracker.class.getName();
1035 String finderMethodName = "findByReceiverUserId";
1036 String[] finderParams = new String[] {
1037 Long.class.getName(),
1038
1039 "java.lang.Integer", "java.lang.Integer",
1040 "com.liferay.portal.kernel.util.OrderByComparator"
1041 };
1042 Object[] finderArgs = new Object[] {
1043 new Long(receiverUserId),
1044
1045 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1046 };
1047
1048 Object result = null;
1049
1050 if (finderClassNameCacheEnabled) {
1051 result = FinderCache.getResult(finderClassName, finderMethodName,
1052 finderParams, finderArgs, getSessionFactory());
1053 }
1054
1055 if (result == null) {
1056 Session session = null;
1057
1058 try {
1059 session = openSession();
1060
1061 StringMaker query = new StringMaker();
1062
1063 query.append(
1064 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
1065
1066 query.append("receiverUserId = ?");
1067
1068 query.append(" ");
1069
1070 if (obc != null) {
1071 query.append("ORDER BY ");
1072 query.append(obc.getOrderBy());
1073 }
1074
1075 else {
1076 query.append("ORDER BY ");
1077
1078 query.append("createDate DESC");
1079 }
1080
1081 Query q = session.createQuery(query.toString());
1082
1083 int queryPos = 0;
1084
1085 q.setLong(queryPos++, receiverUserId);
1086
1087 List list = QueryUtil.list(q, getDialect(), begin, end);
1088
1089 FinderCache.putResult(finderClassNameCacheEnabled,
1090 finderClassName, finderMethodName, finderParams,
1091 finderArgs, list);
1092
1093 return list;
1094 }
1095 catch (Exception e) {
1096 throw HibernateUtil.processException(e);
1097 }
1098 finally {
1099 closeSession(session);
1100 }
1101 }
1102 else {
1103 return (List)result;
1104 }
1105 }
1106
1107 public ActivityTracker findByReceiverUserId_First(long receiverUserId,
1108 OrderByComparator obc)
1109 throws NoSuchActivityTrackerException, SystemException {
1110 List list = findByReceiverUserId(receiverUserId, 0, 1, obc);
1111
1112 if (list.size() == 0) {
1113 StringMaker msg = new StringMaker();
1114
1115 msg.append("No ActivityTracker exists with the key {");
1116
1117 msg.append("receiverUserId=" + receiverUserId);
1118
1119 msg.append(StringPool.CLOSE_CURLY_BRACE);
1120
1121 throw new NoSuchActivityTrackerException(msg.toString());
1122 }
1123 else {
1124 return (ActivityTracker)list.get(0);
1125 }
1126 }
1127
1128 public ActivityTracker findByReceiverUserId_Last(long receiverUserId,
1129 OrderByComparator obc)
1130 throws NoSuchActivityTrackerException, SystemException {
1131 int count = countByReceiverUserId(receiverUserId);
1132
1133 List list = findByReceiverUserId(receiverUserId, count - 1, count, obc);
1134
1135 if (list.size() == 0) {
1136 StringMaker msg = new StringMaker();
1137
1138 msg.append("No ActivityTracker exists with the key {");
1139
1140 msg.append("receiverUserId=" + receiverUserId);
1141
1142 msg.append(StringPool.CLOSE_CURLY_BRACE);
1143
1144 throw new NoSuchActivityTrackerException(msg.toString());
1145 }
1146 else {
1147 return (ActivityTracker)list.get(0);
1148 }
1149 }
1150
1151 public ActivityTracker[] findByReceiverUserId_PrevAndNext(
1152 long activityTrackerId, long receiverUserId, OrderByComparator obc)
1153 throws NoSuchActivityTrackerException, SystemException {
1154 ActivityTracker activityTracker = findByPrimaryKey(activityTrackerId);
1155
1156 int count = countByReceiverUserId(receiverUserId);
1157
1158 Session session = null;
1159
1160 try {
1161 session = openSession();
1162
1163 StringMaker query = new StringMaker();
1164
1165 query.append("FROM com.liferay.portal.model.ActivityTracker WHERE ");
1166
1167 query.append("receiverUserId = ?");
1168
1169 query.append(" ");
1170
1171 if (obc != null) {
1172 query.append("ORDER BY ");
1173 query.append(obc.getOrderBy());
1174 }
1175
1176 else {
1177 query.append("ORDER BY ");
1178
1179 query.append("createDate DESC");
1180 }
1181
1182 Query q = session.createQuery(query.toString());
1183
1184 int queryPos = 0;
1185
1186 q.setLong(queryPos++, receiverUserId);
1187
1188 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1189 activityTracker);
1190
1191 ActivityTracker[] array = new ActivityTrackerImpl[3];
1192
1193 array[0] = (ActivityTracker)objArray[0];
1194 array[1] = (ActivityTracker)objArray[1];
1195 array[2] = (ActivityTracker)objArray[2];
1196
1197 return array;
1198 }
1199 catch (Exception e) {
1200 throw HibernateUtil.processException(e);
1201 }
1202 finally {
1203 closeSession(session);
1204 }
1205 }
1206
1207 public List findByC_C(long classNameId, long classPK)
1208 throws SystemException {
1209 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
1210 String finderClassName = ActivityTracker.class.getName();
1211 String finderMethodName = "findByC_C";
1212 String[] finderParams = new String[] {
1213 Long.class.getName(), Long.class.getName()
1214 };
1215 Object[] finderArgs = new Object[] {
1216 new Long(classNameId), new Long(classPK)
1217 };
1218
1219 Object result = null;
1220
1221 if (finderClassNameCacheEnabled) {
1222 result = FinderCache.getResult(finderClassName, finderMethodName,
1223 finderParams, finderArgs, getSessionFactory());
1224 }
1225
1226 if (result == null) {
1227 Session session = null;
1228
1229 try {
1230 session = openSession();
1231
1232 StringMaker query = new StringMaker();
1233
1234 query.append(
1235 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
1236
1237 query.append("classNameId = ?");
1238
1239 query.append(" AND ");
1240
1241 query.append("classPK = ?");
1242
1243 query.append(" ");
1244
1245 query.append("ORDER BY ");
1246
1247 query.append("createDate DESC");
1248
1249 Query q = session.createQuery(query.toString());
1250
1251 int queryPos = 0;
1252
1253 q.setLong(queryPos++, classNameId);
1254
1255 q.setLong(queryPos++, classPK);
1256
1257 List list = q.list();
1258
1259 FinderCache.putResult(finderClassNameCacheEnabled,
1260 finderClassName, finderMethodName, finderParams,
1261 finderArgs, list);
1262
1263 return list;
1264 }
1265 catch (Exception e) {
1266 throw HibernateUtil.processException(e);
1267 }
1268 finally {
1269 closeSession(session);
1270 }
1271 }
1272 else {
1273 return (List)result;
1274 }
1275 }
1276
1277 public List findByC_C(long classNameId, long classPK, int begin, int end)
1278 throws SystemException {
1279 return findByC_C(classNameId, classPK, begin, end, null);
1280 }
1281
1282 public List findByC_C(long classNameId, long classPK, int begin, int end,
1283 OrderByComparator obc) throws SystemException {
1284 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
1285 String finderClassName = ActivityTracker.class.getName();
1286 String finderMethodName = "findByC_C";
1287 String[] finderParams = new String[] {
1288 Long.class.getName(), Long.class.getName(),
1289
1290 "java.lang.Integer", "java.lang.Integer",
1291 "com.liferay.portal.kernel.util.OrderByComparator"
1292 };
1293 Object[] finderArgs = new Object[] {
1294 new Long(classNameId), new Long(classPK),
1295
1296 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1297 };
1298
1299 Object result = null;
1300
1301 if (finderClassNameCacheEnabled) {
1302 result = FinderCache.getResult(finderClassName, finderMethodName,
1303 finderParams, finderArgs, getSessionFactory());
1304 }
1305
1306 if (result == null) {
1307 Session session = null;
1308
1309 try {
1310 session = openSession();
1311
1312 StringMaker query = new StringMaker();
1313
1314 query.append(
1315 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
1316
1317 query.append("classNameId = ?");
1318
1319 query.append(" AND ");
1320
1321 query.append("classPK = ?");
1322
1323 query.append(" ");
1324
1325 if (obc != null) {
1326 query.append("ORDER BY ");
1327 query.append(obc.getOrderBy());
1328 }
1329
1330 else {
1331 query.append("ORDER BY ");
1332
1333 query.append("createDate DESC");
1334 }
1335
1336 Query q = session.createQuery(query.toString());
1337
1338 int queryPos = 0;
1339
1340 q.setLong(queryPos++, classNameId);
1341
1342 q.setLong(queryPos++, classPK);
1343
1344 List list = QueryUtil.list(q, getDialect(), begin, end);
1345
1346 FinderCache.putResult(finderClassNameCacheEnabled,
1347 finderClassName, finderMethodName, finderParams,
1348 finderArgs, list);
1349
1350 return list;
1351 }
1352 catch (Exception e) {
1353 throw HibernateUtil.processException(e);
1354 }
1355 finally {
1356 closeSession(session);
1357 }
1358 }
1359 else {
1360 return (List)result;
1361 }
1362 }
1363
1364 public ActivityTracker findByC_C_First(long classNameId, long classPK,
1365 OrderByComparator obc)
1366 throws NoSuchActivityTrackerException, SystemException {
1367 List list = findByC_C(classNameId, classPK, 0, 1, obc);
1368
1369 if (list.size() == 0) {
1370 StringMaker msg = new StringMaker();
1371
1372 msg.append("No ActivityTracker exists with the key {");
1373
1374 msg.append("classNameId=" + classNameId);
1375
1376 msg.append(", ");
1377 msg.append("classPK=" + classPK);
1378
1379 msg.append(StringPool.CLOSE_CURLY_BRACE);
1380
1381 throw new NoSuchActivityTrackerException(msg.toString());
1382 }
1383 else {
1384 return (ActivityTracker)list.get(0);
1385 }
1386 }
1387
1388 public ActivityTracker findByC_C_Last(long classNameId, long classPK,
1389 OrderByComparator obc)
1390 throws NoSuchActivityTrackerException, SystemException {
1391 int count = countByC_C(classNameId, classPK);
1392
1393 List list = findByC_C(classNameId, classPK, count - 1, count, obc);
1394
1395 if (list.size() == 0) {
1396 StringMaker msg = new StringMaker();
1397
1398 msg.append("No ActivityTracker exists with the key {");
1399
1400 msg.append("classNameId=" + classNameId);
1401
1402 msg.append(", ");
1403 msg.append("classPK=" + classPK);
1404
1405 msg.append(StringPool.CLOSE_CURLY_BRACE);
1406
1407 throw new NoSuchActivityTrackerException(msg.toString());
1408 }
1409 else {
1410 return (ActivityTracker)list.get(0);
1411 }
1412 }
1413
1414 public ActivityTracker[] findByC_C_PrevAndNext(long activityTrackerId,
1415 long classNameId, long classPK, OrderByComparator obc)
1416 throws NoSuchActivityTrackerException, SystemException {
1417 ActivityTracker activityTracker = findByPrimaryKey(activityTrackerId);
1418
1419 int count = countByC_C(classNameId, classPK);
1420
1421 Session session = null;
1422
1423 try {
1424 session = openSession();
1425
1426 StringMaker query = new StringMaker();
1427
1428 query.append("FROM com.liferay.portal.model.ActivityTracker WHERE ");
1429
1430 query.append("classNameId = ?");
1431
1432 query.append(" AND ");
1433
1434 query.append("classPK = ?");
1435
1436 query.append(" ");
1437
1438 if (obc != null) {
1439 query.append("ORDER BY ");
1440 query.append(obc.getOrderBy());
1441 }
1442
1443 else {
1444 query.append("ORDER BY ");
1445
1446 query.append("createDate DESC");
1447 }
1448
1449 Query q = session.createQuery(query.toString());
1450
1451 int queryPos = 0;
1452
1453 q.setLong(queryPos++, classNameId);
1454
1455 q.setLong(queryPos++, classPK);
1456
1457 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1458 activityTracker);
1459
1460 ActivityTracker[] array = new ActivityTrackerImpl[3];
1461
1462 array[0] = (ActivityTracker)objArray[0];
1463 array[1] = (ActivityTracker)objArray[1];
1464 array[2] = (ActivityTracker)objArray[2];
1465
1466 return array;
1467 }
1468 catch (Exception e) {
1469 throw HibernateUtil.processException(e);
1470 }
1471 finally {
1472 closeSession(session);
1473 }
1474 }
1475
1476 public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer)
1477 throws SystemException {
1478 Session session = null;
1479
1480 try {
1481 session = openSession();
1482
1483 DynamicQuery query = queryInitializer.initialize(session);
1484
1485 return query.list();
1486 }
1487 catch (Exception e) {
1488 throw HibernateUtil.processException(e);
1489 }
1490 finally {
1491 closeSession(session);
1492 }
1493 }
1494
1495 public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer,
1496 int begin, int end) throws SystemException {
1497 Session session = null;
1498
1499 try {
1500 session = openSession();
1501
1502 DynamicQuery query = queryInitializer.initialize(session);
1503
1504 query.setLimit(begin, end);
1505
1506 return query.list();
1507 }
1508 catch (Exception e) {
1509 throw HibernateUtil.processException(e);
1510 }
1511 finally {
1512 closeSession(session);
1513 }
1514 }
1515
1516 public List findAll() throws SystemException {
1517 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1518 }
1519
1520 public List findAll(int begin, int end) throws SystemException {
1521 return findAll(begin, end, null);
1522 }
1523
1524 public List findAll(int begin, int end, OrderByComparator obc)
1525 throws SystemException {
1526 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
1527 String finderClassName = ActivityTracker.class.getName();
1528 String finderMethodName = "findAll";
1529 String[] finderParams = new String[] {
1530 "java.lang.Integer", "java.lang.Integer",
1531 "com.liferay.portal.kernel.util.OrderByComparator"
1532 };
1533 Object[] finderArgs = new Object[] {
1534 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1535 };
1536
1537 Object result = null;
1538
1539 if (finderClassNameCacheEnabled) {
1540 result = FinderCache.getResult(finderClassName, finderMethodName,
1541 finderParams, finderArgs, getSessionFactory());
1542 }
1543
1544 if (result == null) {
1545 Session session = null;
1546
1547 try {
1548 session = openSession();
1549
1550 StringMaker query = new StringMaker();
1551
1552 query.append("FROM com.liferay.portal.model.ActivityTracker ");
1553
1554 if (obc != null) {
1555 query.append("ORDER BY ");
1556 query.append(obc.getOrderBy());
1557 }
1558
1559 else {
1560 query.append("ORDER BY ");
1561
1562 query.append("createDate DESC");
1563 }
1564
1565 Query q = session.createQuery(query.toString());
1566
1567 List list = QueryUtil.list(q, getDialect(), begin, end);
1568
1569 if (obc == null) {
1570 Collections.sort(list);
1571 }
1572
1573 FinderCache.putResult(finderClassNameCacheEnabled,
1574 finderClassName, finderMethodName, finderParams,
1575 finderArgs, list);
1576
1577 return list;
1578 }
1579 catch (Exception e) {
1580 throw HibernateUtil.processException(e);
1581 }
1582 finally {
1583 closeSession(session);
1584 }
1585 }
1586 else {
1587 return (List)result;
1588 }
1589 }
1590
1591 public void removeByGroupId(long groupId) throws SystemException {
1592 Iterator itr = findByGroupId(groupId).iterator();
1593
1594 while (itr.hasNext()) {
1595 ActivityTracker activityTracker = (ActivityTracker)itr.next();
1596
1597 remove(activityTracker);
1598 }
1599 }
1600
1601 public void removeByCompanyId(long companyId) throws SystemException {
1602 Iterator itr = findByCompanyId(companyId).iterator();
1603
1604 while (itr.hasNext()) {
1605 ActivityTracker activityTracker = (ActivityTracker)itr.next();
1606
1607 remove(activityTracker);
1608 }
1609 }
1610
1611 public void removeByUserId(long userId) throws SystemException {
1612 Iterator itr = findByUserId(userId).iterator();
1613
1614 while (itr.hasNext()) {
1615 ActivityTracker activityTracker = (ActivityTracker)itr.next();
1616
1617 remove(activityTracker);
1618 }
1619 }
1620
1621 public void removeByReceiverUserId(long receiverUserId)
1622 throws SystemException {
1623 Iterator itr = findByReceiverUserId(receiverUserId).iterator();
1624
1625 while (itr.hasNext()) {
1626 ActivityTracker activityTracker = (ActivityTracker)itr.next();
1627
1628 remove(activityTracker);
1629 }
1630 }
1631
1632 public void removeByC_C(long classNameId, long classPK)
1633 throws SystemException {
1634 Iterator itr = findByC_C(classNameId, classPK).iterator();
1635
1636 while (itr.hasNext()) {
1637 ActivityTracker activityTracker = (ActivityTracker)itr.next();
1638
1639 remove(activityTracker);
1640 }
1641 }
1642
1643 public void removeAll() throws SystemException {
1644 Iterator itr = findAll().iterator();
1645
1646 while (itr.hasNext()) {
1647 remove((ActivityTracker)itr.next());
1648 }
1649 }
1650
1651 public int countByGroupId(long groupId) throws SystemException {
1652 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
1653 String finderClassName = ActivityTracker.class.getName();
1654 String finderMethodName = "countByGroupId";
1655 String[] finderParams = new String[] { Long.class.getName() };
1656 Object[] finderArgs = new Object[] { new Long(groupId) };
1657
1658 Object result = null;
1659
1660 if (finderClassNameCacheEnabled) {
1661 result = FinderCache.getResult(finderClassName, finderMethodName,
1662 finderParams, finderArgs, getSessionFactory());
1663 }
1664
1665 if (result == null) {
1666 Session session = null;
1667
1668 try {
1669 session = openSession();
1670
1671 StringMaker query = new StringMaker();
1672
1673 query.append("SELECT COUNT(*) ");
1674 query.append(
1675 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
1676
1677 query.append("groupId = ?");
1678
1679 query.append(" ");
1680
1681 Query q = session.createQuery(query.toString());
1682
1683 int queryPos = 0;
1684
1685 q.setLong(queryPos++, groupId);
1686
1687 Long count = null;
1688
1689 Iterator itr = q.list().iterator();
1690
1691 if (itr.hasNext()) {
1692 count = (Long)itr.next();
1693 }
1694
1695 if (count == null) {
1696 count = new Long(0);
1697 }
1698
1699 FinderCache.putResult(finderClassNameCacheEnabled,
1700 finderClassName, finderMethodName, finderParams,
1701 finderArgs, count);
1702
1703 return count.intValue();
1704 }
1705 catch (Exception e) {
1706 throw HibernateUtil.processException(e);
1707 }
1708 finally {
1709 closeSession(session);
1710 }
1711 }
1712 else {
1713 return ((Long)result).intValue();
1714 }
1715 }
1716
1717 public int countByCompanyId(long companyId) throws SystemException {
1718 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
1719 String finderClassName = ActivityTracker.class.getName();
1720 String finderMethodName = "countByCompanyId";
1721 String[] finderParams = new String[] { Long.class.getName() };
1722 Object[] finderArgs = new Object[] { new Long(companyId) };
1723
1724 Object result = null;
1725
1726 if (finderClassNameCacheEnabled) {
1727 result = FinderCache.getResult(finderClassName, finderMethodName,
1728 finderParams, finderArgs, getSessionFactory());
1729 }
1730
1731 if (result == null) {
1732 Session session = null;
1733
1734 try {
1735 session = openSession();
1736
1737 StringMaker query = new StringMaker();
1738
1739 query.append("SELECT COUNT(*) ");
1740 query.append(
1741 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
1742
1743 query.append("companyId = ?");
1744
1745 query.append(" ");
1746
1747 Query q = session.createQuery(query.toString());
1748
1749 int queryPos = 0;
1750
1751 q.setLong(queryPos++, companyId);
1752
1753 Long count = null;
1754
1755 Iterator itr = q.list().iterator();
1756
1757 if (itr.hasNext()) {
1758 count = (Long)itr.next();
1759 }
1760
1761 if (count == null) {
1762 count = new Long(0);
1763 }
1764
1765 FinderCache.putResult(finderClassNameCacheEnabled,
1766 finderClassName, finderMethodName, finderParams,
1767 finderArgs, count);
1768
1769 return count.intValue();
1770 }
1771 catch (Exception e) {
1772 throw HibernateUtil.processException(e);
1773 }
1774 finally {
1775 closeSession(session);
1776 }
1777 }
1778 else {
1779 return ((Long)result).intValue();
1780 }
1781 }
1782
1783 public int countByUserId(long userId) throws SystemException {
1784 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
1785 String finderClassName = ActivityTracker.class.getName();
1786 String finderMethodName = "countByUserId";
1787 String[] finderParams = new String[] { Long.class.getName() };
1788 Object[] finderArgs = new Object[] { new Long(userId) };
1789
1790 Object result = null;
1791
1792 if (finderClassNameCacheEnabled) {
1793 result = FinderCache.getResult(finderClassName, finderMethodName,
1794 finderParams, finderArgs, getSessionFactory());
1795 }
1796
1797 if (result == null) {
1798 Session session = null;
1799
1800 try {
1801 session = openSession();
1802
1803 StringMaker query = new StringMaker();
1804
1805 query.append("SELECT COUNT(*) ");
1806 query.append(
1807 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
1808
1809 query.append("userId = ?");
1810
1811 query.append(" ");
1812
1813 Query q = session.createQuery(query.toString());
1814
1815 int queryPos = 0;
1816
1817 q.setLong(queryPos++, userId);
1818
1819 Long count = null;
1820
1821 Iterator itr = q.list().iterator();
1822
1823 if (itr.hasNext()) {
1824 count = (Long)itr.next();
1825 }
1826
1827 if (count == null) {
1828 count = new Long(0);
1829 }
1830
1831 FinderCache.putResult(finderClassNameCacheEnabled,
1832 finderClassName, finderMethodName, finderParams,
1833 finderArgs, count);
1834
1835 return count.intValue();
1836 }
1837 catch (Exception e) {
1838 throw HibernateUtil.processException(e);
1839 }
1840 finally {
1841 closeSession(session);
1842 }
1843 }
1844 else {
1845 return ((Long)result).intValue();
1846 }
1847 }
1848
1849 public int countByReceiverUserId(long receiverUserId)
1850 throws SystemException {
1851 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
1852 String finderClassName = ActivityTracker.class.getName();
1853 String finderMethodName = "countByReceiverUserId";
1854 String[] finderParams = new String[] { Long.class.getName() };
1855 Object[] finderArgs = new Object[] { new Long(receiverUserId) };
1856
1857 Object result = null;
1858
1859 if (finderClassNameCacheEnabled) {
1860 result = FinderCache.getResult(finderClassName, finderMethodName,
1861 finderParams, finderArgs, getSessionFactory());
1862 }
1863
1864 if (result == null) {
1865 Session session = null;
1866
1867 try {
1868 session = openSession();
1869
1870 StringMaker query = new StringMaker();
1871
1872 query.append("SELECT COUNT(*) ");
1873 query.append(
1874 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
1875
1876 query.append("receiverUserId = ?");
1877
1878 query.append(" ");
1879
1880 Query q = session.createQuery(query.toString());
1881
1882 int queryPos = 0;
1883
1884 q.setLong(queryPos++, receiverUserId);
1885
1886 Long count = null;
1887
1888 Iterator itr = q.list().iterator();
1889
1890 if (itr.hasNext()) {
1891 count = (Long)itr.next();
1892 }
1893
1894 if (count == null) {
1895 count = new Long(0);
1896 }
1897
1898 FinderCache.putResult(finderClassNameCacheEnabled,
1899 finderClassName, finderMethodName, finderParams,
1900 finderArgs, count);
1901
1902 return count.intValue();
1903 }
1904 catch (Exception e) {
1905 throw HibernateUtil.processException(e);
1906 }
1907 finally {
1908 closeSession(session);
1909 }
1910 }
1911 else {
1912 return ((Long)result).intValue();
1913 }
1914 }
1915
1916 public int countByC_C(long classNameId, long classPK)
1917 throws SystemException {
1918 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
1919 String finderClassName = ActivityTracker.class.getName();
1920 String finderMethodName = "countByC_C";
1921 String[] finderParams = new String[] {
1922 Long.class.getName(), Long.class.getName()
1923 };
1924 Object[] finderArgs = new Object[] {
1925 new Long(classNameId), new Long(classPK)
1926 };
1927
1928 Object result = null;
1929
1930 if (finderClassNameCacheEnabled) {
1931 result = FinderCache.getResult(finderClassName, finderMethodName,
1932 finderParams, finderArgs, getSessionFactory());
1933 }
1934
1935 if (result == null) {
1936 Session session = null;
1937
1938 try {
1939 session = openSession();
1940
1941 StringMaker query = new StringMaker();
1942
1943 query.append("SELECT COUNT(*) ");
1944 query.append(
1945 "FROM com.liferay.portal.model.ActivityTracker WHERE ");
1946
1947 query.append("classNameId = ?");
1948
1949 query.append(" AND ");
1950
1951 query.append("classPK = ?");
1952
1953 query.append(" ");
1954
1955 Query q = session.createQuery(query.toString());
1956
1957 int queryPos = 0;
1958
1959 q.setLong(queryPos++, classNameId);
1960
1961 q.setLong(queryPos++, classPK);
1962
1963 Long count = null;
1964
1965 Iterator itr = q.list().iterator();
1966
1967 if (itr.hasNext()) {
1968 count = (Long)itr.next();
1969 }
1970
1971 if (count == null) {
1972 count = new Long(0);
1973 }
1974
1975 FinderCache.putResult(finderClassNameCacheEnabled,
1976 finderClassName, finderMethodName, finderParams,
1977 finderArgs, count);
1978
1979 return count.intValue();
1980 }
1981 catch (Exception e) {
1982 throw HibernateUtil.processException(e);
1983 }
1984 finally {
1985 closeSession(session);
1986 }
1987 }
1988 else {
1989 return ((Long)result).intValue();
1990 }
1991 }
1992
1993 public int countAll() throws SystemException {
1994 boolean finderClassNameCacheEnabled = ActivityTrackerModelImpl.CACHE_ENABLED;
1995 String finderClassName = ActivityTracker.class.getName();
1996 String finderMethodName = "countAll";
1997 String[] finderParams = new String[] { };
1998 Object[] finderArgs = new Object[] { };
1999
2000 Object result = null;
2001
2002 if (finderClassNameCacheEnabled) {
2003 result = FinderCache.getResult(finderClassName, finderMethodName,
2004 finderParams, finderArgs, getSessionFactory());
2005 }
2006
2007 if (result == null) {
2008 Session session = null;
2009
2010 try {
2011 session = openSession();
2012
2013 Query q = session.createQuery(
2014 "SELECT COUNT(*) FROM com.liferay.portal.model.ActivityTracker");
2015
2016 Long count = null;
2017
2018 Iterator itr = q.list().iterator();
2019
2020 if (itr.hasNext()) {
2021 count = (Long)itr.next();
2022 }
2023
2024 if (count == null) {
2025 count = new Long(0);
2026 }
2027
2028 FinderCache.putResult(finderClassNameCacheEnabled,
2029 finderClassName, finderMethodName, finderParams,
2030 finderArgs, count);
2031
2032 return count.intValue();
2033 }
2034 catch (Exception e) {
2035 throw HibernateUtil.processException(e);
2036 }
2037 finally {
2038 closeSession(session);
2039 }
2040 }
2041 else {
2042 return ((Long)result).intValue();
2043 }
2044 }
2045
2046 protected void initDao() {
2047 }
2048
2049 private static ModelListener _getListener() {
2050 if (Validator.isNotNull(_LISTENER)) {
2051 try {
2052 return (ModelListener)Class.forName(_LISTENER).newInstance();
2053 }
2054 catch (Exception e) {
2055 _log.error(e);
2056 }
2057 }
2058
2059 return null;
2060 }
2061
2062 private static final String _LISTENER = GetterUtil.getString(PropsUtil.get(
2063 "value.object.listener.com.liferay.portal.model.ActivityTracker"));
2064 private static Log _log = LogFactory.getLog(ActivityTrackerPersistenceImpl.class);
2065}