1
19
20 package com.liferay.portal.service.persistence;
21
22 import com.liferay.portal.NoSuchUserTrackerException;
23 import com.liferay.portal.SystemException;
24 import com.liferay.portal.kernel.dao.orm.DynamicQuery;
25 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
26 import com.liferay.portal.kernel.dao.orm.Query;
27 import com.liferay.portal.kernel.dao.orm.QueryPos;
28 import com.liferay.portal.kernel.dao.orm.QueryUtil;
29 import com.liferay.portal.kernel.dao.orm.Session;
30 import com.liferay.portal.kernel.log.Log;
31 import com.liferay.portal.kernel.log.LogFactoryUtil;
32 import com.liferay.portal.kernel.util.GetterUtil;
33 import com.liferay.portal.kernel.util.OrderByComparator;
34 import com.liferay.portal.kernel.util.StringPool;
35 import com.liferay.portal.kernel.util.StringUtil;
36 import com.liferay.portal.model.ModelListener;
37 import com.liferay.portal.model.UserTracker;
38 import com.liferay.portal.model.impl.UserTrackerImpl;
39 import com.liferay.portal.model.impl.UserTrackerModelImpl;
40 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
41
42 import java.util.ArrayList;
43 import java.util.Collections;
44 import java.util.Iterator;
45 import java.util.List;
46
47
53 public class UserTrackerPersistenceImpl extends BasePersistenceImpl
54 implements UserTrackerPersistence {
55 public UserTracker create(long userTrackerId) {
56 UserTracker userTracker = new UserTrackerImpl();
57
58 userTracker.setNew(true);
59 userTracker.setPrimaryKey(userTrackerId);
60
61 return userTracker;
62 }
63
64 public UserTracker remove(long userTrackerId)
65 throws NoSuchUserTrackerException, SystemException {
66 Session session = null;
67
68 try {
69 session = openSession();
70
71 UserTracker userTracker = (UserTracker)session.get(UserTrackerImpl.class,
72 new Long(userTrackerId));
73
74 if (userTracker == null) {
75 if (_log.isWarnEnabled()) {
76 _log.warn("No UserTracker exists with the primary key " +
77 userTrackerId);
78 }
79
80 throw new NoSuchUserTrackerException(
81 "No UserTracker exists with the primary key " +
82 userTrackerId);
83 }
84
85 return remove(userTracker);
86 }
87 catch (NoSuchUserTrackerException nsee) {
88 throw nsee;
89 }
90 catch (Exception e) {
91 throw processException(e);
92 }
93 finally {
94 closeSession(session);
95 }
96 }
97
98 public UserTracker remove(UserTracker userTracker)
99 throws SystemException {
100 for (ModelListener listener : listeners) {
101 listener.onBeforeRemove(userTracker);
102 }
103
104 userTracker = removeImpl(userTracker);
105
106 for (ModelListener listener : listeners) {
107 listener.onAfterRemove(userTracker);
108 }
109
110 return userTracker;
111 }
112
113 protected UserTracker removeImpl(UserTracker userTracker)
114 throws SystemException {
115 Session session = null;
116
117 try {
118 session = openSession();
119
120 if (BatchSessionUtil.isEnabled()) {
121 Object staleObject = session.get(UserTrackerImpl.class,
122 userTracker.getPrimaryKeyObj());
123
124 if (staleObject != null) {
125 session.evict(staleObject);
126 }
127 }
128
129 session.delete(userTracker);
130
131 session.flush();
132
133 return userTracker;
134 }
135 catch (Exception e) {
136 throw processException(e);
137 }
138 finally {
139 closeSession(session);
140
141 FinderCacheUtil.clearCache(UserTracker.class.getName());
142 }
143 }
144
145
148 public UserTracker update(UserTracker userTracker)
149 throws SystemException {
150 if (_log.isWarnEnabled()) {
151 _log.warn(
152 "Using the deprecated update(UserTracker userTracker) method. Use update(UserTracker userTracker, boolean merge) instead.");
153 }
154
155 return update(userTracker, false);
156 }
157
158
171 public UserTracker update(UserTracker userTracker, boolean merge)
172 throws SystemException {
173 boolean isNew = userTracker.isNew();
174
175 for (ModelListener listener : listeners) {
176 if (isNew) {
177 listener.onBeforeCreate(userTracker);
178 }
179 else {
180 listener.onBeforeUpdate(userTracker);
181 }
182 }
183
184 userTracker = updateImpl(userTracker, merge);
185
186 for (ModelListener listener : listeners) {
187 if (isNew) {
188 listener.onAfterCreate(userTracker);
189 }
190 else {
191 listener.onAfterUpdate(userTracker);
192 }
193 }
194
195 return userTracker;
196 }
197
198 public UserTracker updateImpl(
199 com.liferay.portal.model.UserTracker userTracker, boolean merge)
200 throws SystemException {
201 Session session = null;
202
203 try {
204 session = openSession();
205
206 BatchSessionUtil.update(session, userTracker, merge);
207
208 userTracker.setNew(false);
209
210 return userTracker;
211 }
212 catch (Exception e) {
213 throw processException(e);
214 }
215 finally {
216 closeSession(session);
217
218 FinderCacheUtil.clearCache(UserTracker.class.getName());
219 }
220 }
221
222 public UserTracker findByPrimaryKey(long userTrackerId)
223 throws NoSuchUserTrackerException, SystemException {
224 UserTracker userTracker = fetchByPrimaryKey(userTrackerId);
225
226 if (userTracker == null) {
227 if (_log.isWarnEnabled()) {
228 _log.warn("No UserTracker exists with the primary key " +
229 userTrackerId);
230 }
231
232 throw new NoSuchUserTrackerException(
233 "No UserTracker exists with the primary key " + userTrackerId);
234 }
235
236 return userTracker;
237 }
238
239 public UserTracker fetchByPrimaryKey(long userTrackerId)
240 throws SystemException {
241 Session session = null;
242
243 try {
244 session = openSession();
245
246 return (UserTracker)session.get(UserTrackerImpl.class,
247 new Long(userTrackerId));
248 }
249 catch (Exception e) {
250 throw processException(e);
251 }
252 finally {
253 closeSession(session);
254 }
255 }
256
257 public List<UserTracker> findByCompanyId(long companyId)
258 throws SystemException {
259 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
260 String finderClassName = UserTracker.class.getName();
261 String finderMethodName = "findByCompanyId";
262 String[] finderParams = new String[] { Long.class.getName() };
263 Object[] finderArgs = new Object[] { new Long(companyId) };
264
265 Object result = null;
266
267 if (finderClassNameCacheEnabled) {
268 result = FinderCacheUtil.getResult(finderClassName,
269 finderMethodName, finderParams, finderArgs, this);
270 }
271
272 if (result == null) {
273 Session session = null;
274
275 try {
276 session = openSession();
277
278 StringBuilder query = new StringBuilder();
279
280 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
281
282 query.append("companyId = ?");
283
284 query.append(" ");
285
286 Query q = session.createQuery(query.toString());
287
288 QueryPos qPos = QueryPos.getInstance(q);
289
290 qPos.add(companyId);
291
292 List<UserTracker> list = q.list();
293
294 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
295 finderClassName, finderMethodName, finderParams,
296 finderArgs, list);
297
298 return list;
299 }
300 catch (Exception e) {
301 throw processException(e);
302 }
303 finally {
304 closeSession(session);
305 }
306 }
307 else {
308 return (List<UserTracker>)result;
309 }
310 }
311
312 public List<UserTracker> findByCompanyId(long companyId, int start, int end)
313 throws SystemException {
314 return findByCompanyId(companyId, start, end, null);
315 }
316
317 public List<UserTracker> findByCompanyId(long companyId, int start,
318 int end, OrderByComparator obc) throws SystemException {
319 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
320 String finderClassName = UserTracker.class.getName();
321 String finderMethodName = "findByCompanyId";
322 String[] finderParams = new String[] {
323 Long.class.getName(),
324
325 "java.lang.Integer", "java.lang.Integer",
326 "com.liferay.portal.kernel.util.OrderByComparator"
327 };
328 Object[] finderArgs = new Object[] {
329 new Long(companyId),
330
331 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
332 };
333
334 Object result = null;
335
336 if (finderClassNameCacheEnabled) {
337 result = FinderCacheUtil.getResult(finderClassName,
338 finderMethodName, finderParams, finderArgs, this);
339 }
340
341 if (result == null) {
342 Session session = null;
343
344 try {
345 session = openSession();
346
347 StringBuilder query = new StringBuilder();
348
349 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
350
351 query.append("companyId = ?");
352
353 query.append(" ");
354
355 if (obc != null) {
356 query.append("ORDER BY ");
357 query.append(obc.getOrderBy());
358 }
359
360 Query q = session.createQuery(query.toString());
361
362 QueryPos qPos = QueryPos.getInstance(q);
363
364 qPos.add(companyId);
365
366 List<UserTracker> list = (List<UserTracker>)QueryUtil.list(q,
367 getDialect(), start, end);
368
369 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
370 finderClassName, finderMethodName, finderParams,
371 finderArgs, list);
372
373 return list;
374 }
375 catch (Exception e) {
376 throw processException(e);
377 }
378 finally {
379 closeSession(session);
380 }
381 }
382 else {
383 return (List<UserTracker>)result;
384 }
385 }
386
387 public UserTracker findByCompanyId_First(long companyId,
388 OrderByComparator obc)
389 throws NoSuchUserTrackerException, SystemException {
390 List<UserTracker> list = findByCompanyId(companyId, 0, 1, obc);
391
392 if (list.size() == 0) {
393 StringBuilder msg = new StringBuilder();
394
395 msg.append("No UserTracker exists with the key {");
396
397 msg.append("companyId=" + companyId);
398
399 msg.append(StringPool.CLOSE_CURLY_BRACE);
400
401 throw new NoSuchUserTrackerException(msg.toString());
402 }
403 else {
404 return list.get(0);
405 }
406 }
407
408 public UserTracker findByCompanyId_Last(long companyId,
409 OrderByComparator obc)
410 throws NoSuchUserTrackerException, SystemException {
411 int count = countByCompanyId(companyId);
412
413 List<UserTracker> list = findByCompanyId(companyId, count - 1, count,
414 obc);
415
416 if (list.size() == 0) {
417 StringBuilder msg = new StringBuilder();
418
419 msg.append("No UserTracker exists with the key {");
420
421 msg.append("companyId=" + companyId);
422
423 msg.append(StringPool.CLOSE_CURLY_BRACE);
424
425 throw new NoSuchUserTrackerException(msg.toString());
426 }
427 else {
428 return list.get(0);
429 }
430 }
431
432 public UserTracker[] findByCompanyId_PrevAndNext(long userTrackerId,
433 long companyId, OrderByComparator obc)
434 throws NoSuchUserTrackerException, SystemException {
435 UserTracker userTracker = findByPrimaryKey(userTrackerId);
436
437 int count = countByCompanyId(companyId);
438
439 Session session = null;
440
441 try {
442 session = openSession();
443
444 StringBuilder query = new StringBuilder();
445
446 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
447
448 query.append("companyId = ?");
449
450 query.append(" ");
451
452 if (obc != null) {
453 query.append("ORDER BY ");
454 query.append(obc.getOrderBy());
455 }
456
457 Query q = session.createQuery(query.toString());
458
459 QueryPos qPos = QueryPos.getInstance(q);
460
461 qPos.add(companyId);
462
463 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
464 userTracker);
465
466 UserTracker[] array = new UserTrackerImpl[3];
467
468 array[0] = (UserTracker)objArray[0];
469 array[1] = (UserTracker)objArray[1];
470 array[2] = (UserTracker)objArray[2];
471
472 return array;
473 }
474 catch (Exception e) {
475 throw processException(e);
476 }
477 finally {
478 closeSession(session);
479 }
480 }
481
482 public List<UserTracker> findByUserId(long userId)
483 throws SystemException {
484 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
485 String finderClassName = UserTracker.class.getName();
486 String finderMethodName = "findByUserId";
487 String[] finderParams = new String[] { Long.class.getName() };
488 Object[] finderArgs = new Object[] { new Long(userId) };
489
490 Object result = null;
491
492 if (finderClassNameCacheEnabled) {
493 result = FinderCacheUtil.getResult(finderClassName,
494 finderMethodName, finderParams, finderArgs, this);
495 }
496
497 if (result == null) {
498 Session session = null;
499
500 try {
501 session = openSession();
502
503 StringBuilder query = new StringBuilder();
504
505 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
506
507 query.append("userId = ?");
508
509 query.append(" ");
510
511 Query q = session.createQuery(query.toString());
512
513 QueryPos qPos = QueryPos.getInstance(q);
514
515 qPos.add(userId);
516
517 List<UserTracker> list = q.list();
518
519 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
520 finderClassName, finderMethodName, finderParams,
521 finderArgs, list);
522
523 return list;
524 }
525 catch (Exception e) {
526 throw processException(e);
527 }
528 finally {
529 closeSession(session);
530 }
531 }
532 else {
533 return (List<UserTracker>)result;
534 }
535 }
536
537 public List<UserTracker> findByUserId(long userId, int start, int end)
538 throws SystemException {
539 return findByUserId(userId, start, end, null);
540 }
541
542 public List<UserTracker> findByUserId(long userId, int start, int end,
543 OrderByComparator obc) throws SystemException {
544 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
545 String finderClassName = UserTracker.class.getName();
546 String finderMethodName = "findByUserId";
547 String[] finderParams = new String[] {
548 Long.class.getName(),
549
550 "java.lang.Integer", "java.lang.Integer",
551 "com.liferay.portal.kernel.util.OrderByComparator"
552 };
553 Object[] finderArgs = new Object[] {
554 new Long(userId),
555
556 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
557 };
558
559 Object result = null;
560
561 if (finderClassNameCacheEnabled) {
562 result = FinderCacheUtil.getResult(finderClassName,
563 finderMethodName, finderParams, finderArgs, this);
564 }
565
566 if (result == null) {
567 Session session = null;
568
569 try {
570 session = openSession();
571
572 StringBuilder query = new StringBuilder();
573
574 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
575
576 query.append("userId = ?");
577
578 query.append(" ");
579
580 if (obc != null) {
581 query.append("ORDER BY ");
582 query.append(obc.getOrderBy());
583 }
584
585 Query q = session.createQuery(query.toString());
586
587 QueryPos qPos = QueryPos.getInstance(q);
588
589 qPos.add(userId);
590
591 List<UserTracker> list = (List<UserTracker>)QueryUtil.list(q,
592 getDialect(), start, end);
593
594 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
595 finderClassName, finderMethodName, finderParams,
596 finderArgs, list);
597
598 return list;
599 }
600 catch (Exception e) {
601 throw processException(e);
602 }
603 finally {
604 closeSession(session);
605 }
606 }
607 else {
608 return (List<UserTracker>)result;
609 }
610 }
611
612 public UserTracker findByUserId_First(long userId, OrderByComparator obc)
613 throws NoSuchUserTrackerException, SystemException {
614 List<UserTracker> list = findByUserId(userId, 0, 1, obc);
615
616 if (list.size() == 0) {
617 StringBuilder msg = new StringBuilder();
618
619 msg.append("No UserTracker exists with the key {");
620
621 msg.append("userId=" + userId);
622
623 msg.append(StringPool.CLOSE_CURLY_BRACE);
624
625 throw new NoSuchUserTrackerException(msg.toString());
626 }
627 else {
628 return list.get(0);
629 }
630 }
631
632 public UserTracker findByUserId_Last(long userId, OrderByComparator obc)
633 throws NoSuchUserTrackerException, SystemException {
634 int count = countByUserId(userId);
635
636 List<UserTracker> list = findByUserId(userId, count - 1, count, obc);
637
638 if (list.size() == 0) {
639 StringBuilder msg = new StringBuilder();
640
641 msg.append("No UserTracker exists with the key {");
642
643 msg.append("userId=" + userId);
644
645 msg.append(StringPool.CLOSE_CURLY_BRACE);
646
647 throw new NoSuchUserTrackerException(msg.toString());
648 }
649 else {
650 return list.get(0);
651 }
652 }
653
654 public UserTracker[] findByUserId_PrevAndNext(long userTrackerId,
655 long userId, OrderByComparator obc)
656 throws NoSuchUserTrackerException, SystemException {
657 UserTracker userTracker = findByPrimaryKey(userTrackerId);
658
659 int count = countByUserId(userId);
660
661 Session session = null;
662
663 try {
664 session = openSession();
665
666 StringBuilder query = new StringBuilder();
667
668 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
669
670 query.append("userId = ?");
671
672 query.append(" ");
673
674 if (obc != null) {
675 query.append("ORDER BY ");
676 query.append(obc.getOrderBy());
677 }
678
679 Query q = session.createQuery(query.toString());
680
681 QueryPos qPos = QueryPos.getInstance(q);
682
683 qPos.add(userId);
684
685 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
686 userTracker);
687
688 UserTracker[] array = new UserTrackerImpl[3];
689
690 array[0] = (UserTracker)objArray[0];
691 array[1] = (UserTracker)objArray[1];
692 array[2] = (UserTracker)objArray[2];
693
694 return array;
695 }
696 catch (Exception e) {
697 throw processException(e);
698 }
699 finally {
700 closeSession(session);
701 }
702 }
703
704 public List<UserTracker> findBySessionId(String sessionId)
705 throws SystemException {
706 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
707 String finderClassName = UserTracker.class.getName();
708 String finderMethodName = "findBySessionId";
709 String[] finderParams = new String[] { String.class.getName() };
710 Object[] finderArgs = new Object[] { sessionId };
711
712 Object result = null;
713
714 if (finderClassNameCacheEnabled) {
715 result = FinderCacheUtil.getResult(finderClassName,
716 finderMethodName, finderParams, finderArgs, this);
717 }
718
719 if (result == null) {
720 Session session = null;
721
722 try {
723 session = openSession();
724
725 StringBuilder query = new StringBuilder();
726
727 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
728
729 if (sessionId == null) {
730 query.append("sessionId IS NULL");
731 }
732 else {
733 query.append("sessionId = ?");
734 }
735
736 query.append(" ");
737
738 Query q = session.createQuery(query.toString());
739
740 QueryPos qPos = QueryPos.getInstance(q);
741
742 if (sessionId != null) {
743 qPos.add(sessionId);
744 }
745
746 List<UserTracker> list = q.list();
747
748 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
749 finderClassName, finderMethodName, finderParams,
750 finderArgs, list);
751
752 return list;
753 }
754 catch (Exception e) {
755 throw processException(e);
756 }
757 finally {
758 closeSession(session);
759 }
760 }
761 else {
762 return (List<UserTracker>)result;
763 }
764 }
765
766 public List<UserTracker> findBySessionId(String sessionId, int start,
767 int end) throws SystemException {
768 return findBySessionId(sessionId, start, end, null);
769 }
770
771 public List<UserTracker> findBySessionId(String sessionId, int start,
772 int end, OrderByComparator obc) throws SystemException {
773 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
774 String finderClassName = UserTracker.class.getName();
775 String finderMethodName = "findBySessionId";
776 String[] finderParams = new String[] {
777 String.class.getName(),
778
779 "java.lang.Integer", "java.lang.Integer",
780 "com.liferay.portal.kernel.util.OrderByComparator"
781 };
782 Object[] finderArgs = new Object[] {
783 sessionId,
784
785 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
786 };
787
788 Object result = null;
789
790 if (finderClassNameCacheEnabled) {
791 result = FinderCacheUtil.getResult(finderClassName,
792 finderMethodName, finderParams, finderArgs, this);
793 }
794
795 if (result == null) {
796 Session session = null;
797
798 try {
799 session = openSession();
800
801 StringBuilder query = new StringBuilder();
802
803 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
804
805 if (sessionId == null) {
806 query.append("sessionId IS NULL");
807 }
808 else {
809 query.append("sessionId = ?");
810 }
811
812 query.append(" ");
813
814 if (obc != null) {
815 query.append("ORDER BY ");
816 query.append(obc.getOrderBy());
817 }
818
819 Query q = session.createQuery(query.toString());
820
821 QueryPos qPos = QueryPos.getInstance(q);
822
823 if (sessionId != null) {
824 qPos.add(sessionId);
825 }
826
827 List<UserTracker> list = (List<UserTracker>)QueryUtil.list(q,
828 getDialect(), start, end);
829
830 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
831 finderClassName, finderMethodName, finderParams,
832 finderArgs, list);
833
834 return list;
835 }
836 catch (Exception e) {
837 throw processException(e);
838 }
839 finally {
840 closeSession(session);
841 }
842 }
843 else {
844 return (List<UserTracker>)result;
845 }
846 }
847
848 public UserTracker findBySessionId_First(String sessionId,
849 OrderByComparator obc)
850 throws NoSuchUserTrackerException, SystemException {
851 List<UserTracker> list = findBySessionId(sessionId, 0, 1, obc);
852
853 if (list.size() == 0) {
854 StringBuilder msg = new StringBuilder();
855
856 msg.append("No UserTracker exists with the key {");
857
858 msg.append("sessionId=" + sessionId);
859
860 msg.append(StringPool.CLOSE_CURLY_BRACE);
861
862 throw new NoSuchUserTrackerException(msg.toString());
863 }
864 else {
865 return list.get(0);
866 }
867 }
868
869 public UserTracker findBySessionId_Last(String sessionId,
870 OrderByComparator obc)
871 throws NoSuchUserTrackerException, SystemException {
872 int count = countBySessionId(sessionId);
873
874 List<UserTracker> list = findBySessionId(sessionId, count - 1, count,
875 obc);
876
877 if (list.size() == 0) {
878 StringBuilder msg = new StringBuilder();
879
880 msg.append("No UserTracker exists with the key {");
881
882 msg.append("sessionId=" + sessionId);
883
884 msg.append(StringPool.CLOSE_CURLY_BRACE);
885
886 throw new NoSuchUserTrackerException(msg.toString());
887 }
888 else {
889 return list.get(0);
890 }
891 }
892
893 public UserTracker[] findBySessionId_PrevAndNext(long userTrackerId,
894 String sessionId, OrderByComparator obc)
895 throws NoSuchUserTrackerException, SystemException {
896 UserTracker userTracker = findByPrimaryKey(userTrackerId);
897
898 int count = countBySessionId(sessionId);
899
900 Session session = null;
901
902 try {
903 session = openSession();
904
905 StringBuilder query = new StringBuilder();
906
907 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
908
909 if (sessionId == null) {
910 query.append("sessionId IS NULL");
911 }
912 else {
913 query.append("sessionId = ?");
914 }
915
916 query.append(" ");
917
918 if (obc != null) {
919 query.append("ORDER BY ");
920 query.append(obc.getOrderBy());
921 }
922
923 Query q = session.createQuery(query.toString());
924
925 QueryPos qPos = QueryPos.getInstance(q);
926
927 if (sessionId != null) {
928 qPos.add(sessionId);
929 }
930
931 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
932 userTracker);
933
934 UserTracker[] array = new UserTrackerImpl[3];
935
936 array[0] = (UserTracker)objArray[0];
937 array[1] = (UserTracker)objArray[1];
938 array[2] = (UserTracker)objArray[2];
939
940 return array;
941 }
942 catch (Exception e) {
943 throw processException(e);
944 }
945 finally {
946 closeSession(session);
947 }
948 }
949
950 public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
951 throws SystemException {
952 Session session = null;
953
954 try {
955 session = openSession();
956
957 dynamicQuery.compile(session);
958
959 return dynamicQuery.list();
960 }
961 catch (Exception e) {
962 throw processException(e);
963 }
964 finally {
965 closeSession(session);
966 }
967 }
968
969 public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
970 int start, int end) throws SystemException {
971 Session session = null;
972
973 try {
974 session = openSession();
975
976 dynamicQuery.setLimit(start, end);
977
978 dynamicQuery.compile(session);
979
980 return dynamicQuery.list();
981 }
982 catch (Exception e) {
983 throw processException(e);
984 }
985 finally {
986 closeSession(session);
987 }
988 }
989
990 public List<UserTracker> findAll() throws SystemException {
991 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
992 }
993
994 public List<UserTracker> findAll(int start, int end)
995 throws SystemException {
996 return findAll(start, end, null);
997 }
998
999 public List<UserTracker> findAll(int start, int end, OrderByComparator obc)
1000 throws SystemException {
1001 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
1002 String finderClassName = UserTracker.class.getName();
1003 String finderMethodName = "findAll";
1004 String[] finderParams = new String[] {
1005 "java.lang.Integer", "java.lang.Integer",
1006 "com.liferay.portal.kernel.util.OrderByComparator"
1007 };
1008 Object[] finderArgs = new Object[] {
1009 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1010 };
1011
1012 Object result = null;
1013
1014 if (finderClassNameCacheEnabled) {
1015 result = FinderCacheUtil.getResult(finderClassName,
1016 finderMethodName, finderParams, finderArgs, this);
1017 }
1018
1019 if (result == null) {
1020 Session session = null;
1021
1022 try {
1023 session = openSession();
1024
1025 StringBuilder query = new StringBuilder();
1026
1027 query.append("FROM com.liferay.portal.model.UserTracker ");
1028
1029 if (obc != null) {
1030 query.append("ORDER BY ");
1031 query.append(obc.getOrderBy());
1032 }
1033
1034 Query q = session.createQuery(query.toString());
1035
1036 List<UserTracker> list = null;
1037
1038 if (obc == null) {
1039 list = (List<UserTracker>)QueryUtil.list(q, getDialect(),
1040 start, end, false);
1041
1042 Collections.sort(list);
1043 }
1044 else {
1045 list = (List<UserTracker>)QueryUtil.list(q, getDialect(),
1046 start, end);
1047 }
1048
1049 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1050 finderClassName, finderMethodName, finderParams,
1051 finderArgs, list);
1052
1053 return list;
1054 }
1055 catch (Exception e) {
1056 throw processException(e);
1057 }
1058 finally {
1059 closeSession(session);
1060 }
1061 }
1062 else {
1063 return (List<UserTracker>)result;
1064 }
1065 }
1066
1067 public void removeByCompanyId(long companyId) throws SystemException {
1068 for (UserTracker userTracker : findByCompanyId(companyId)) {
1069 remove(userTracker);
1070 }
1071 }
1072
1073 public void removeByUserId(long userId) throws SystemException {
1074 for (UserTracker userTracker : findByUserId(userId)) {
1075 remove(userTracker);
1076 }
1077 }
1078
1079 public void removeBySessionId(String sessionId) throws SystemException {
1080 for (UserTracker userTracker : findBySessionId(sessionId)) {
1081 remove(userTracker);
1082 }
1083 }
1084
1085 public void removeAll() throws SystemException {
1086 for (UserTracker userTracker : findAll()) {
1087 remove(userTracker);
1088 }
1089 }
1090
1091 public int countByCompanyId(long companyId) throws SystemException {
1092 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
1093 String finderClassName = UserTracker.class.getName();
1094 String finderMethodName = "countByCompanyId";
1095 String[] finderParams = new String[] { Long.class.getName() };
1096 Object[] finderArgs = new Object[] { new Long(companyId) };
1097
1098 Object result = null;
1099
1100 if (finderClassNameCacheEnabled) {
1101 result = FinderCacheUtil.getResult(finderClassName,
1102 finderMethodName, finderParams, finderArgs, this);
1103 }
1104
1105 if (result == null) {
1106 Session session = null;
1107
1108 try {
1109 session = openSession();
1110
1111 StringBuilder query = new StringBuilder();
1112
1113 query.append("SELECT COUNT(*) ");
1114 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
1115
1116 query.append("companyId = ?");
1117
1118 query.append(" ");
1119
1120 Query q = session.createQuery(query.toString());
1121
1122 QueryPos qPos = QueryPos.getInstance(q);
1123
1124 qPos.add(companyId);
1125
1126 Long count = null;
1127
1128 Iterator<Long> itr = q.list().iterator();
1129
1130 if (itr.hasNext()) {
1131 count = itr.next();
1132 }
1133
1134 if (count == null) {
1135 count = new Long(0);
1136 }
1137
1138 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1139 finderClassName, finderMethodName, finderParams,
1140 finderArgs, count);
1141
1142 return count.intValue();
1143 }
1144 catch (Exception e) {
1145 throw processException(e);
1146 }
1147 finally {
1148 closeSession(session);
1149 }
1150 }
1151 else {
1152 return ((Long)result).intValue();
1153 }
1154 }
1155
1156 public int countByUserId(long userId) throws SystemException {
1157 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
1158 String finderClassName = UserTracker.class.getName();
1159 String finderMethodName = "countByUserId";
1160 String[] finderParams = new String[] { Long.class.getName() };
1161 Object[] finderArgs = new Object[] { new Long(userId) };
1162
1163 Object result = null;
1164
1165 if (finderClassNameCacheEnabled) {
1166 result = FinderCacheUtil.getResult(finderClassName,
1167 finderMethodName, finderParams, finderArgs, this);
1168 }
1169
1170 if (result == null) {
1171 Session session = null;
1172
1173 try {
1174 session = openSession();
1175
1176 StringBuilder query = new StringBuilder();
1177
1178 query.append("SELECT COUNT(*) ");
1179 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
1180
1181 query.append("userId = ?");
1182
1183 query.append(" ");
1184
1185 Query q = session.createQuery(query.toString());
1186
1187 QueryPos qPos = QueryPos.getInstance(q);
1188
1189 qPos.add(userId);
1190
1191 Long count = null;
1192
1193 Iterator<Long> itr = q.list().iterator();
1194
1195 if (itr.hasNext()) {
1196 count = itr.next();
1197 }
1198
1199 if (count == null) {
1200 count = new Long(0);
1201 }
1202
1203 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1204 finderClassName, finderMethodName, finderParams,
1205 finderArgs, count);
1206
1207 return count.intValue();
1208 }
1209 catch (Exception e) {
1210 throw processException(e);
1211 }
1212 finally {
1213 closeSession(session);
1214 }
1215 }
1216 else {
1217 return ((Long)result).intValue();
1218 }
1219 }
1220
1221 public int countBySessionId(String sessionId) throws SystemException {
1222 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
1223 String finderClassName = UserTracker.class.getName();
1224 String finderMethodName = "countBySessionId";
1225 String[] finderParams = new String[] { String.class.getName() };
1226 Object[] finderArgs = new Object[] { sessionId };
1227
1228 Object result = null;
1229
1230 if (finderClassNameCacheEnabled) {
1231 result = FinderCacheUtil.getResult(finderClassName,
1232 finderMethodName, finderParams, finderArgs, this);
1233 }
1234
1235 if (result == null) {
1236 Session session = null;
1237
1238 try {
1239 session = openSession();
1240
1241 StringBuilder query = new StringBuilder();
1242
1243 query.append("SELECT COUNT(*) ");
1244 query.append("FROM com.liferay.portal.model.UserTracker WHERE ");
1245
1246 if (sessionId == null) {
1247 query.append("sessionId IS NULL");
1248 }
1249 else {
1250 query.append("sessionId = ?");
1251 }
1252
1253 query.append(" ");
1254
1255 Query q = session.createQuery(query.toString());
1256
1257 QueryPos qPos = QueryPos.getInstance(q);
1258
1259 if (sessionId != null) {
1260 qPos.add(sessionId);
1261 }
1262
1263 Long count = null;
1264
1265 Iterator<Long> itr = q.list().iterator();
1266
1267 if (itr.hasNext()) {
1268 count = itr.next();
1269 }
1270
1271 if (count == null) {
1272 count = new Long(0);
1273 }
1274
1275 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1276 finderClassName, finderMethodName, finderParams,
1277 finderArgs, count);
1278
1279 return count.intValue();
1280 }
1281 catch (Exception e) {
1282 throw processException(e);
1283 }
1284 finally {
1285 closeSession(session);
1286 }
1287 }
1288 else {
1289 return ((Long)result).intValue();
1290 }
1291 }
1292
1293 public int countAll() throws SystemException {
1294 boolean finderClassNameCacheEnabled = UserTrackerModelImpl.CACHE_ENABLED;
1295 String finderClassName = UserTracker.class.getName();
1296 String finderMethodName = "countAll";
1297 String[] finderParams = new String[] { };
1298 Object[] finderArgs = new Object[] { };
1299
1300 Object result = null;
1301
1302 if (finderClassNameCacheEnabled) {
1303 result = FinderCacheUtil.getResult(finderClassName,
1304 finderMethodName, finderParams, finderArgs, this);
1305 }
1306
1307 if (result == null) {
1308 Session session = null;
1309
1310 try {
1311 session = openSession();
1312
1313 Query q = session.createQuery(
1314 "SELECT COUNT(*) FROM com.liferay.portal.model.UserTracker");
1315
1316 Long count = null;
1317
1318 Iterator<Long> itr = q.list().iterator();
1319
1320 if (itr.hasNext()) {
1321 count = itr.next();
1322 }
1323
1324 if (count == null) {
1325 count = new Long(0);
1326 }
1327
1328 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1329 finderClassName, finderMethodName, finderParams,
1330 finderArgs, count);
1331
1332 return count.intValue();
1333 }
1334 catch (Exception e) {
1335 throw processException(e);
1336 }
1337 finally {
1338 closeSession(session);
1339 }
1340 }
1341 else {
1342 return ((Long)result).intValue();
1343 }
1344 }
1345
1346 public void afterPropertiesSet() {
1347 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1348 com.liferay.portal.util.PropsUtil.get(
1349 "value.object.listener.com.liferay.portal.model.UserTracker")));
1350
1351 if (listenerClassNames.length > 0) {
1352 try {
1353 List<ModelListener> listenersList = new ArrayList<ModelListener>();
1354
1355 for (String listenerClassName : listenerClassNames) {
1356 listenersList.add((ModelListener)Class.forName(
1357 listenerClassName).newInstance());
1358 }
1359
1360 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1361 }
1362 catch (Exception e) {
1363 _log.error(e);
1364 }
1365 }
1366 }
1367
1368 private static Log _log = LogFactoryUtil.getLog(UserTrackerPersistenceImpl.class);
1369}