1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
12   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
14   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
15   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
16   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17   * SOFTWARE.
18   */
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  /**
48   * <a href="UserTrackerPersistenceImpl.java.html"><b><i>View Source</i></b></a>
49   *
50   * @author Brian Wing Shun Chan
51   *
52   */
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     /**
146      * @deprecated Use <code>update(UserTracker userTracker, boolean merge)</code>.
147      */
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     /**
159      * Add, update, or merge, the entity. This method also calls the model
160      * listeners to trigger the proper events associated with adding, deleting,
161      * or updating an entity.
162      *
163      * @param        userTracker the entity to add, update, or merge
164      * @param        merge boolean value for whether to merge the entity. The
165      *                default value is false. Setting merge to true is more
166      *                expensive and should only be true when userTracker is
167      *                transient. See LEP-5473 for a detailed discussion of this
168      *                method.
169      * @return        true if the portlet can be displayed via Ajax
170      */
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}