1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
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  /**
55   * <a href="ActivityTrackerPersistenceImpl.java.html"><b><i>View Source</i></b></a>
56   *
57   * @author Brian Wing Shun Chan
58   *
59   */
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}