1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    *
5    *
6    *
7    * The contents of this file are subject to the terms of the Liferay Enterprise
8    * Subscription License ("License"). You may not use this file except in
9    * compliance with the License. You can obtain a copy of the License by
10   * contacting Liferay, Inc. See the License for the specific language governing
11   * permissions and limitations under the License, including but not limited to
12   * distribution rights 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.NoSuchUserTrackerException;
26  import com.liferay.portal.SystemException;
27  import com.liferay.portal.kernel.annotation.BeanReference;
28  import com.liferay.portal.kernel.cache.CacheRegistry;
29  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
30  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
31  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
32  import com.liferay.portal.kernel.dao.orm.FinderPath;
33  import com.liferay.portal.kernel.dao.orm.Query;
34  import com.liferay.portal.kernel.dao.orm.QueryPos;
35  import com.liferay.portal.kernel.dao.orm.QueryUtil;
36  import com.liferay.portal.kernel.dao.orm.Session;
37  import com.liferay.portal.kernel.log.Log;
38  import com.liferay.portal.kernel.log.LogFactoryUtil;
39  import com.liferay.portal.kernel.util.GetterUtil;
40  import com.liferay.portal.kernel.util.OrderByComparator;
41  import com.liferay.portal.kernel.util.StringPool;
42  import com.liferay.portal.kernel.util.StringUtil;
43  import com.liferay.portal.model.ModelListener;
44  import com.liferay.portal.model.UserTracker;
45  import com.liferay.portal.model.impl.UserTrackerImpl;
46  import com.liferay.portal.model.impl.UserTrackerModelImpl;
47  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
48  
49  import java.util.ArrayList;
50  import java.util.Collections;
51  import java.util.List;
52  
53  /**
54   * <a href="UserTrackerPersistenceImpl.java.html"><b><i>View Source</i></b></a>
55   *
56   * <p>
57   * ServiceBuilder generated this class. Modifications in this class will be
58   * overwritten the next time is generated.
59   * </p>
60   *
61   * @author    Brian Wing Shun Chan
62   * @see       UserTrackerPersistence
63   * @see       UserTrackerUtil
64   * @generated
65   */
66  public class UserTrackerPersistenceImpl extends BasePersistenceImpl
67      implements UserTrackerPersistence {
68      public static final String FINDER_CLASS_NAME_ENTITY = UserTrackerImpl.class.getName();
69      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
70          ".List";
71      public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
72              UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
73              "findByCompanyId", new String[] { Long.class.getName() });
74      public static final FinderPath FINDER_PATH_FIND_BY_OBC_COMPANYID = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
75              UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
76              "findByCompanyId",
77              new String[] {
78                  Long.class.getName(),
79                  
80              "java.lang.Integer", "java.lang.Integer",
81                  "com.liferay.portal.kernel.util.OrderByComparator"
82              });
83      public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
84              UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
85              "countByCompanyId", new String[] { Long.class.getName() });
86      public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
87              UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
88              "findByUserId", new String[] { Long.class.getName() });
89      public static final FinderPath FINDER_PATH_FIND_BY_OBC_USERID = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
90              UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
91              "findByUserId",
92              new String[] {
93                  Long.class.getName(),
94                  
95              "java.lang.Integer", "java.lang.Integer",
96                  "com.liferay.portal.kernel.util.OrderByComparator"
97              });
98      public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
99              UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
100             "countByUserId", new String[] { Long.class.getName() });
101     public static final FinderPath FINDER_PATH_FIND_BY_SESSIONID = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
102             UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
103             "findBySessionId", new String[] { String.class.getName() });
104     public static final FinderPath FINDER_PATH_FIND_BY_OBC_SESSIONID = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
105             UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
106             "findBySessionId",
107             new String[] {
108                 String.class.getName(),
109                 
110             "java.lang.Integer", "java.lang.Integer",
111                 "com.liferay.portal.kernel.util.OrderByComparator"
112             });
113     public static final FinderPath FINDER_PATH_COUNT_BY_SESSIONID = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
114             UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
115             "countBySessionId", new String[] { String.class.getName() });
116     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
117             UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
118             "findAll", new String[0]);
119     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
120             UserTrackerModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
121             "countAll", new String[0]);
122 
123     public void cacheResult(UserTracker userTracker) {
124         EntityCacheUtil.putResult(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
125             UserTrackerImpl.class, userTracker.getPrimaryKey(), userTracker);
126     }
127 
128     public void cacheResult(List<UserTracker> userTrackers) {
129         for (UserTracker userTracker : userTrackers) {
130             if (EntityCacheUtil.getResult(
131                         UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
132                         UserTrackerImpl.class, userTracker.getPrimaryKey(), this) == null) {
133                 cacheResult(userTracker);
134             }
135         }
136     }
137 
138     public void clearCache() {
139         CacheRegistry.clear(UserTrackerImpl.class.getName());
140         EntityCacheUtil.clearCache(UserTrackerImpl.class.getName());
141         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
142         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
143     }
144 
145     public UserTracker create(long userTrackerId) {
146         UserTracker userTracker = new UserTrackerImpl();
147 
148         userTracker.setNew(true);
149         userTracker.setPrimaryKey(userTrackerId);
150 
151         return userTracker;
152     }
153 
154     public UserTracker remove(long userTrackerId)
155         throws NoSuchUserTrackerException, SystemException {
156         Session session = null;
157 
158         try {
159             session = openSession();
160 
161             UserTracker userTracker = (UserTracker)session.get(UserTrackerImpl.class,
162                     new Long(userTrackerId));
163 
164             if (userTracker == null) {
165                 if (_log.isWarnEnabled()) {
166                     _log.warn("No UserTracker exists with the primary key " +
167                         userTrackerId);
168                 }
169 
170                 throw new NoSuchUserTrackerException(
171                     "No UserTracker exists with the primary key " +
172                     userTrackerId);
173             }
174 
175             return remove(userTracker);
176         }
177         catch (NoSuchUserTrackerException nsee) {
178             throw nsee;
179         }
180         catch (Exception e) {
181             throw processException(e);
182         }
183         finally {
184             closeSession(session);
185         }
186     }
187 
188     public UserTracker remove(UserTracker userTracker)
189         throws SystemException {
190         for (ModelListener<UserTracker> listener : listeners) {
191             listener.onBeforeRemove(userTracker);
192         }
193 
194         userTracker = removeImpl(userTracker);
195 
196         for (ModelListener<UserTracker> listener : listeners) {
197             listener.onAfterRemove(userTracker);
198         }
199 
200         return userTracker;
201     }
202 
203     protected UserTracker removeImpl(UserTracker userTracker)
204         throws SystemException {
205         Session session = null;
206 
207         try {
208             session = openSession();
209 
210             if (userTracker.isCachedModel() || BatchSessionUtil.isEnabled()) {
211                 Object staleObject = session.get(UserTrackerImpl.class,
212                         userTracker.getPrimaryKeyObj());
213 
214                 if (staleObject != null) {
215                     session.evict(staleObject);
216                 }
217             }
218 
219             session.delete(userTracker);
220 
221             session.flush();
222         }
223         catch (Exception e) {
224             throw processException(e);
225         }
226         finally {
227             closeSession(session);
228         }
229 
230         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
231 
232         EntityCacheUtil.removeResult(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
233             UserTrackerImpl.class, userTracker.getPrimaryKey());
234 
235         return userTracker;
236     }
237 
238     /**
239      * @deprecated Use {@link #update(UserTracker, boolean merge)}.
240      */
241     public UserTracker update(UserTracker userTracker)
242         throws SystemException {
243         if (_log.isWarnEnabled()) {
244             _log.warn(
245                 "Using the deprecated update(UserTracker userTracker) method. Use update(UserTracker userTracker, boolean merge) instead.");
246         }
247 
248         return update(userTracker, false);
249     }
250 
251     /**
252      * Add, update, or merge, the entity. This method also calls the model
253      * listeners to trigger the proper events associated with adding, deleting,
254      * or updating an entity.
255      *
256      * @param  userTracker the entity to add, update, or merge
257      * @param  merge boolean value for whether to merge the entity. The default
258      *         value is false. Setting merge to true is more expensive and
259      *         should only be true when userTracker is transient. See
260      *         LEP-5473 for a detailed discussion of this method.
261      * @return the entity that was added, updated, or merged
262      */
263     public UserTracker update(UserTracker userTracker, boolean merge)
264         throws SystemException {
265         boolean isNew = userTracker.isNew();
266 
267         for (ModelListener<UserTracker> listener : listeners) {
268             if (isNew) {
269                 listener.onBeforeCreate(userTracker);
270             }
271             else {
272                 listener.onBeforeUpdate(userTracker);
273             }
274         }
275 
276         userTracker = updateImpl(userTracker, merge);
277 
278         for (ModelListener<UserTracker> listener : listeners) {
279             if (isNew) {
280                 listener.onAfterCreate(userTracker);
281             }
282             else {
283                 listener.onAfterUpdate(userTracker);
284             }
285         }
286 
287         return userTracker;
288     }
289 
290     public UserTracker updateImpl(
291         com.liferay.portal.model.UserTracker userTracker, boolean merge)
292         throws SystemException {
293         Session session = null;
294 
295         try {
296             session = openSession();
297 
298             BatchSessionUtil.update(session, userTracker, merge);
299 
300             userTracker.setNew(false);
301         }
302         catch (Exception e) {
303             throw processException(e);
304         }
305         finally {
306             closeSession(session);
307         }
308 
309         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
310 
311         EntityCacheUtil.putResult(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
312             UserTrackerImpl.class, userTracker.getPrimaryKey(), userTracker);
313 
314         return userTracker;
315     }
316 
317     public UserTracker findByPrimaryKey(long userTrackerId)
318         throws NoSuchUserTrackerException, SystemException {
319         UserTracker userTracker = fetchByPrimaryKey(userTrackerId);
320 
321         if (userTracker == null) {
322             if (_log.isWarnEnabled()) {
323                 _log.warn("No UserTracker exists with the primary key " +
324                     userTrackerId);
325             }
326 
327             throw new NoSuchUserTrackerException(
328                 "No UserTracker exists with the primary key " + userTrackerId);
329         }
330 
331         return userTracker;
332     }
333 
334     public UserTracker fetchByPrimaryKey(long userTrackerId)
335         throws SystemException {
336         UserTracker userTracker = (UserTracker)EntityCacheUtil.getResult(UserTrackerModelImpl.ENTITY_CACHE_ENABLED,
337                 UserTrackerImpl.class, userTrackerId, this);
338 
339         if (userTracker == null) {
340             Session session = null;
341 
342             try {
343                 session = openSession();
344 
345                 userTracker = (UserTracker)session.get(UserTrackerImpl.class,
346                         new Long(userTrackerId));
347             }
348             catch (Exception e) {
349                 throw processException(e);
350             }
351             finally {
352                 if (userTracker != null) {
353                     cacheResult(userTracker);
354                 }
355 
356                 closeSession(session);
357             }
358         }
359 
360         return userTracker;
361     }
362 
363     public List<UserTracker> findByCompanyId(long companyId)
364         throws SystemException {
365         Object[] finderArgs = new Object[] { new Long(companyId) };
366 
367         List<UserTracker> list = (List<UserTracker>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
368                 finderArgs, this);
369 
370         if (list == null) {
371             Session session = null;
372 
373             try {
374                 session = openSession();
375 
376                 StringBuilder query = new StringBuilder();
377 
378                 query.append(
379                     "SELECT userTracker FROM UserTracker userTracker WHERE ");
380 
381                 query.append("userTracker.companyId = ?");
382 
383                 query.append(" ");
384 
385                 Query q = session.createQuery(query.toString());
386 
387                 QueryPos qPos = QueryPos.getInstance(q);
388 
389                 qPos.add(companyId);
390 
391                 list = q.list();
392             }
393             catch (Exception e) {
394                 throw processException(e);
395             }
396             finally {
397                 if (list == null) {
398                     list = new ArrayList<UserTracker>();
399                 }
400 
401                 cacheResult(list);
402 
403                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
404                     finderArgs, list);
405 
406                 closeSession(session);
407             }
408         }
409 
410         return list;
411     }
412 
413     public List<UserTracker> findByCompanyId(long companyId, int start, int end)
414         throws SystemException {
415         return findByCompanyId(companyId, start, end, null);
416     }
417 
418     public List<UserTracker> findByCompanyId(long companyId, int start,
419         int end, OrderByComparator obc) throws SystemException {
420         Object[] finderArgs = new Object[] {
421                 new Long(companyId),
422                 
423                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
424             };
425 
426         List<UserTracker> list = (List<UserTracker>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
427                 finderArgs, this);
428 
429         if (list == null) {
430             Session session = null;
431 
432             try {
433                 session = openSession();
434 
435                 StringBuilder query = new StringBuilder();
436 
437                 query.append(
438                     "SELECT userTracker FROM UserTracker userTracker WHERE ");
439 
440                 query.append("userTracker.companyId = ?");
441 
442                 query.append(" ");
443 
444                 if (obc != null) {
445                     query.append("ORDER BY ");
446 
447                     String[] orderByFields = obc.getOrderByFields();
448 
449                     for (int i = 0; i < orderByFields.length; i++) {
450                         query.append("userTracker.");
451                         query.append(orderByFields[i]);
452 
453                         if (obc.isAscending()) {
454                             query.append(" ASC");
455                         }
456                         else {
457                             query.append(" DESC");
458                         }
459 
460                         if ((i + 1) < orderByFields.length) {
461                             query.append(", ");
462                         }
463                     }
464                 }
465 
466                 Query q = session.createQuery(query.toString());
467 
468                 QueryPos qPos = QueryPos.getInstance(q);
469 
470                 qPos.add(companyId);
471 
472                 list = (List<UserTracker>)QueryUtil.list(q, getDialect(),
473                         start, end);
474             }
475             catch (Exception e) {
476                 throw processException(e);
477             }
478             finally {
479                 if (list == null) {
480                     list = new ArrayList<UserTracker>();
481                 }
482 
483                 cacheResult(list);
484 
485                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
486                     finderArgs, list);
487 
488                 closeSession(session);
489             }
490         }
491 
492         return list;
493     }
494 
495     public UserTracker findByCompanyId_First(long companyId,
496         OrderByComparator obc)
497         throws NoSuchUserTrackerException, SystemException {
498         List<UserTracker> list = findByCompanyId(companyId, 0, 1, obc);
499 
500         if (list.isEmpty()) {
501             StringBuilder msg = new StringBuilder();
502 
503             msg.append("No UserTracker exists with the key {");
504 
505             msg.append("companyId=" + companyId);
506 
507             msg.append(StringPool.CLOSE_CURLY_BRACE);
508 
509             throw new NoSuchUserTrackerException(msg.toString());
510         }
511         else {
512             return list.get(0);
513         }
514     }
515 
516     public UserTracker findByCompanyId_Last(long companyId,
517         OrderByComparator obc)
518         throws NoSuchUserTrackerException, SystemException {
519         int count = countByCompanyId(companyId);
520 
521         List<UserTracker> list = findByCompanyId(companyId, count - 1, count,
522                 obc);
523 
524         if (list.isEmpty()) {
525             StringBuilder msg = new StringBuilder();
526 
527             msg.append("No UserTracker exists with the key {");
528 
529             msg.append("companyId=" + companyId);
530 
531             msg.append(StringPool.CLOSE_CURLY_BRACE);
532 
533             throw new NoSuchUserTrackerException(msg.toString());
534         }
535         else {
536             return list.get(0);
537         }
538     }
539 
540     public UserTracker[] findByCompanyId_PrevAndNext(long userTrackerId,
541         long companyId, OrderByComparator obc)
542         throws NoSuchUserTrackerException, SystemException {
543         UserTracker userTracker = findByPrimaryKey(userTrackerId);
544 
545         int count = countByCompanyId(companyId);
546 
547         Session session = null;
548 
549         try {
550             session = openSession();
551 
552             StringBuilder query = new StringBuilder();
553 
554             query.append(
555                 "SELECT userTracker FROM UserTracker userTracker WHERE ");
556 
557             query.append("userTracker.companyId = ?");
558 
559             query.append(" ");
560 
561             if (obc != null) {
562                 query.append("ORDER BY ");
563 
564                 String[] orderByFields = obc.getOrderByFields();
565 
566                 for (int i = 0; i < orderByFields.length; i++) {
567                     query.append("userTracker.");
568                     query.append(orderByFields[i]);
569 
570                     if (obc.isAscending()) {
571                         query.append(" ASC");
572                     }
573                     else {
574                         query.append(" DESC");
575                     }
576 
577                     if ((i + 1) < orderByFields.length) {
578                         query.append(", ");
579                     }
580                 }
581             }
582 
583             Query q = session.createQuery(query.toString());
584 
585             QueryPos qPos = QueryPos.getInstance(q);
586 
587             qPos.add(companyId);
588 
589             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
590                     userTracker);
591 
592             UserTracker[] array = new UserTrackerImpl[3];
593 
594             array[0] = (UserTracker)objArray[0];
595             array[1] = (UserTracker)objArray[1];
596             array[2] = (UserTracker)objArray[2];
597 
598             return array;
599         }
600         catch (Exception e) {
601             throw processException(e);
602         }
603         finally {
604             closeSession(session);
605         }
606     }
607 
608     public List<UserTracker> findByUserId(long userId)
609         throws SystemException {
610         Object[] finderArgs = new Object[] { new Long(userId) };
611 
612         List<UserTracker> list = (List<UserTracker>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
613                 finderArgs, this);
614 
615         if (list == null) {
616             Session session = null;
617 
618             try {
619                 session = openSession();
620 
621                 StringBuilder query = new StringBuilder();
622 
623                 query.append(
624                     "SELECT userTracker FROM UserTracker userTracker WHERE ");
625 
626                 query.append("userTracker.userId = ?");
627 
628                 query.append(" ");
629 
630                 Query q = session.createQuery(query.toString());
631 
632                 QueryPos qPos = QueryPos.getInstance(q);
633 
634                 qPos.add(userId);
635 
636                 list = q.list();
637             }
638             catch (Exception e) {
639                 throw processException(e);
640             }
641             finally {
642                 if (list == null) {
643                     list = new ArrayList<UserTracker>();
644                 }
645 
646                 cacheResult(list);
647 
648                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
649                     finderArgs, list);
650 
651                 closeSession(session);
652             }
653         }
654 
655         return list;
656     }
657 
658     public List<UserTracker> findByUserId(long userId, int start, int end)
659         throws SystemException {
660         return findByUserId(userId, start, end, null);
661     }
662 
663     public List<UserTracker> findByUserId(long userId, int start, int end,
664         OrderByComparator obc) throws SystemException {
665         Object[] finderArgs = new Object[] {
666                 new Long(userId),
667                 
668                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
669             };
670 
671         List<UserTracker> list = (List<UserTracker>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_USERID,
672                 finderArgs, this);
673 
674         if (list == null) {
675             Session session = null;
676 
677             try {
678                 session = openSession();
679 
680                 StringBuilder query = new StringBuilder();
681 
682                 query.append(
683                     "SELECT userTracker FROM UserTracker userTracker WHERE ");
684 
685                 query.append("userTracker.userId = ?");
686 
687                 query.append(" ");
688 
689                 if (obc != null) {
690                     query.append("ORDER BY ");
691 
692                     String[] orderByFields = obc.getOrderByFields();
693 
694                     for (int i = 0; i < orderByFields.length; i++) {
695                         query.append("userTracker.");
696                         query.append(orderByFields[i]);
697 
698                         if (obc.isAscending()) {
699                             query.append(" ASC");
700                         }
701                         else {
702                             query.append(" DESC");
703                         }
704 
705                         if ((i + 1) < orderByFields.length) {
706                             query.append(", ");
707                         }
708                     }
709                 }
710 
711                 Query q = session.createQuery(query.toString());
712 
713                 QueryPos qPos = QueryPos.getInstance(q);
714 
715                 qPos.add(userId);
716 
717                 list = (List<UserTracker>)QueryUtil.list(q, getDialect(),
718                         start, end);
719             }
720             catch (Exception e) {
721                 throw processException(e);
722             }
723             finally {
724                 if (list == null) {
725                     list = new ArrayList<UserTracker>();
726                 }
727 
728                 cacheResult(list);
729 
730                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_USERID,
731                     finderArgs, list);
732 
733                 closeSession(session);
734             }
735         }
736 
737         return list;
738     }
739 
740     public UserTracker findByUserId_First(long userId, OrderByComparator obc)
741         throws NoSuchUserTrackerException, SystemException {
742         List<UserTracker> list = findByUserId(userId, 0, 1, obc);
743 
744         if (list.isEmpty()) {
745             StringBuilder msg = new StringBuilder();
746 
747             msg.append("No UserTracker exists with the key {");
748 
749             msg.append("userId=" + userId);
750 
751             msg.append(StringPool.CLOSE_CURLY_BRACE);
752 
753             throw new NoSuchUserTrackerException(msg.toString());
754         }
755         else {
756             return list.get(0);
757         }
758     }
759 
760     public UserTracker findByUserId_Last(long userId, OrderByComparator obc)
761         throws NoSuchUserTrackerException, SystemException {
762         int count = countByUserId(userId);
763 
764         List<UserTracker> list = findByUserId(userId, count - 1, count, obc);
765 
766         if (list.isEmpty()) {
767             StringBuilder msg = new StringBuilder();
768 
769             msg.append("No UserTracker exists with the key {");
770 
771             msg.append("userId=" + userId);
772 
773             msg.append(StringPool.CLOSE_CURLY_BRACE);
774 
775             throw new NoSuchUserTrackerException(msg.toString());
776         }
777         else {
778             return list.get(0);
779         }
780     }
781 
782     public UserTracker[] findByUserId_PrevAndNext(long userTrackerId,
783         long userId, OrderByComparator obc)
784         throws NoSuchUserTrackerException, SystemException {
785         UserTracker userTracker = findByPrimaryKey(userTrackerId);
786 
787         int count = countByUserId(userId);
788 
789         Session session = null;
790 
791         try {
792             session = openSession();
793 
794             StringBuilder query = new StringBuilder();
795 
796             query.append(
797                 "SELECT userTracker FROM UserTracker userTracker WHERE ");
798 
799             query.append("userTracker.userId = ?");
800 
801             query.append(" ");
802 
803             if (obc != null) {
804                 query.append("ORDER BY ");
805 
806                 String[] orderByFields = obc.getOrderByFields();
807 
808                 for (int i = 0; i < orderByFields.length; i++) {
809                     query.append("userTracker.");
810                     query.append(orderByFields[i]);
811 
812                     if (obc.isAscending()) {
813                         query.append(" ASC");
814                     }
815                     else {
816                         query.append(" DESC");
817                     }
818 
819                     if ((i + 1) < orderByFields.length) {
820                         query.append(", ");
821                     }
822                 }
823             }
824 
825             Query q = session.createQuery(query.toString());
826 
827             QueryPos qPos = QueryPos.getInstance(q);
828 
829             qPos.add(userId);
830 
831             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
832                     userTracker);
833 
834             UserTracker[] array = new UserTrackerImpl[3];
835 
836             array[0] = (UserTracker)objArray[0];
837             array[1] = (UserTracker)objArray[1];
838             array[2] = (UserTracker)objArray[2];
839 
840             return array;
841         }
842         catch (Exception e) {
843             throw processException(e);
844         }
845         finally {
846             closeSession(session);
847         }
848     }
849 
850     public List<UserTracker> findBySessionId(String sessionId)
851         throws SystemException {
852         Object[] finderArgs = new Object[] { sessionId };
853 
854         List<UserTracker> list = (List<UserTracker>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_SESSIONID,
855                 finderArgs, this);
856 
857         if (list == null) {
858             Session session = null;
859 
860             try {
861                 session = openSession();
862 
863                 StringBuilder query = new StringBuilder();
864 
865                 query.append(
866                     "SELECT userTracker FROM UserTracker userTracker WHERE ");
867 
868                 if (sessionId == null) {
869                     query.append("userTracker.sessionId IS NULL");
870                 }
871                 else {
872                     query.append("userTracker.sessionId = ?");
873                 }
874 
875                 query.append(" ");
876 
877                 Query q = session.createQuery(query.toString());
878 
879                 QueryPos qPos = QueryPos.getInstance(q);
880 
881                 if (sessionId != null) {
882                     qPos.add(sessionId);
883                 }
884 
885                 list = q.list();
886             }
887             catch (Exception e) {
888                 throw processException(e);
889             }
890             finally {
891                 if (list == null) {
892                     list = new ArrayList<UserTracker>();
893                 }
894 
895                 cacheResult(list);
896 
897                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_SESSIONID,
898                     finderArgs, list);
899 
900                 closeSession(session);
901             }
902         }
903 
904         return list;
905     }
906 
907     public List<UserTracker> findBySessionId(String sessionId, int start,
908         int end) throws SystemException {
909         return findBySessionId(sessionId, start, end, null);
910     }
911 
912     public List<UserTracker> findBySessionId(String sessionId, int start,
913         int end, OrderByComparator obc) throws SystemException {
914         Object[] finderArgs = new Object[] {
915                 sessionId,
916                 
917                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
918             };
919 
920         List<UserTracker> list = (List<UserTracker>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_SESSIONID,
921                 finderArgs, this);
922 
923         if (list == null) {
924             Session session = null;
925 
926             try {
927                 session = openSession();
928 
929                 StringBuilder query = new StringBuilder();
930 
931                 query.append(
932                     "SELECT userTracker FROM UserTracker userTracker WHERE ");
933 
934                 if (sessionId == null) {
935                     query.append("userTracker.sessionId IS NULL");
936                 }
937                 else {
938                     query.append("userTracker.sessionId = ?");
939                 }
940 
941                 query.append(" ");
942 
943                 if (obc != null) {
944                     query.append("ORDER BY ");
945 
946                     String[] orderByFields = obc.getOrderByFields();
947 
948                     for (int i = 0; i < orderByFields.length; i++) {
949                         query.append("userTracker.");
950                         query.append(orderByFields[i]);
951 
952                         if (obc.isAscending()) {
953                             query.append(" ASC");
954                         }
955                         else {
956                             query.append(" DESC");
957                         }
958 
959                         if ((i + 1) < orderByFields.length) {
960                             query.append(", ");
961                         }
962                     }
963                 }
964 
965                 Query q = session.createQuery(query.toString());
966 
967                 QueryPos qPos = QueryPos.getInstance(q);
968 
969                 if (sessionId != null) {
970                     qPos.add(sessionId);
971                 }
972 
973                 list = (List<UserTracker>)QueryUtil.list(q, getDialect(),
974                         start, end);
975             }
976             catch (Exception e) {
977                 throw processException(e);
978             }
979             finally {
980                 if (list == null) {
981                     list = new ArrayList<UserTracker>();
982                 }
983 
984                 cacheResult(list);
985 
986                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_SESSIONID,
987                     finderArgs, list);
988 
989                 closeSession(session);
990             }
991         }
992 
993         return list;
994     }
995 
996     public UserTracker findBySessionId_First(String sessionId,
997         OrderByComparator obc)
998         throws NoSuchUserTrackerException, SystemException {
999         List<UserTracker> list = findBySessionId(sessionId, 0, 1, obc);
1000
1001        if (list.isEmpty()) {
1002            StringBuilder msg = new StringBuilder();
1003
1004            msg.append("No UserTracker exists with the key {");
1005
1006            msg.append("sessionId=" + sessionId);
1007
1008            msg.append(StringPool.CLOSE_CURLY_BRACE);
1009
1010            throw new NoSuchUserTrackerException(msg.toString());
1011        }
1012        else {
1013            return list.get(0);
1014        }
1015    }
1016
1017    public UserTracker findBySessionId_Last(String sessionId,
1018        OrderByComparator obc)
1019        throws NoSuchUserTrackerException, SystemException {
1020        int count = countBySessionId(sessionId);
1021
1022        List<UserTracker> list = findBySessionId(sessionId, count - 1, count,
1023                obc);
1024
1025        if (list.isEmpty()) {
1026            StringBuilder msg = new StringBuilder();
1027
1028            msg.append("No UserTracker exists with the key {");
1029
1030            msg.append("sessionId=" + sessionId);
1031
1032            msg.append(StringPool.CLOSE_CURLY_BRACE);
1033
1034            throw new NoSuchUserTrackerException(msg.toString());
1035        }
1036        else {
1037            return list.get(0);
1038        }
1039    }
1040
1041    public UserTracker[] findBySessionId_PrevAndNext(long userTrackerId,
1042        String sessionId, OrderByComparator obc)
1043        throws NoSuchUserTrackerException, SystemException {
1044        UserTracker userTracker = findByPrimaryKey(userTrackerId);
1045
1046        int count = countBySessionId(sessionId);
1047
1048        Session session = null;
1049
1050        try {
1051            session = openSession();
1052
1053            StringBuilder query = new StringBuilder();
1054
1055            query.append(
1056                "SELECT userTracker FROM UserTracker userTracker WHERE ");
1057
1058            if (sessionId == null) {
1059                query.append("userTracker.sessionId IS NULL");
1060            }
1061            else {
1062                query.append("userTracker.sessionId = ?");
1063            }
1064
1065            query.append(" ");
1066
1067            if (obc != null) {
1068                query.append("ORDER BY ");
1069
1070                String[] orderByFields = obc.getOrderByFields();
1071
1072                for (int i = 0; i < orderByFields.length; i++) {
1073                    query.append("userTracker.");
1074                    query.append(orderByFields[i]);
1075
1076                    if (obc.isAscending()) {
1077                        query.append(" ASC");
1078                    }
1079                    else {
1080                        query.append(" DESC");
1081                    }
1082
1083                    if ((i + 1) < orderByFields.length) {
1084                        query.append(", ");
1085                    }
1086                }
1087            }
1088
1089            Query q = session.createQuery(query.toString());
1090
1091            QueryPos qPos = QueryPos.getInstance(q);
1092
1093            if (sessionId != null) {
1094                qPos.add(sessionId);
1095            }
1096
1097            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1098                    userTracker);
1099
1100            UserTracker[] array = new UserTrackerImpl[3];
1101
1102            array[0] = (UserTracker)objArray[0];
1103            array[1] = (UserTracker)objArray[1];
1104            array[2] = (UserTracker)objArray[2];
1105
1106            return array;
1107        }
1108        catch (Exception e) {
1109            throw processException(e);
1110        }
1111        finally {
1112            closeSession(session);
1113        }
1114    }
1115
1116    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1117        throws SystemException {
1118        Session session = null;
1119
1120        try {
1121            session = openSession();
1122
1123            dynamicQuery.compile(session);
1124
1125            return dynamicQuery.list();
1126        }
1127        catch (Exception e) {
1128            throw processException(e);
1129        }
1130        finally {
1131            closeSession(session);
1132        }
1133    }
1134
1135    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1136        int start, int end) throws SystemException {
1137        Session session = null;
1138
1139        try {
1140            session = openSession();
1141
1142            dynamicQuery.setLimit(start, end);
1143
1144            dynamicQuery.compile(session);
1145
1146            return dynamicQuery.list();
1147        }
1148        catch (Exception e) {
1149            throw processException(e);
1150        }
1151        finally {
1152            closeSession(session);
1153        }
1154    }
1155
1156    public List<UserTracker> findAll() throws SystemException {
1157        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1158    }
1159
1160    public List<UserTracker> findAll(int start, int end)
1161        throws SystemException {
1162        return findAll(start, end, null);
1163    }
1164
1165    public List<UserTracker> findAll(int start, int end, OrderByComparator obc)
1166        throws SystemException {
1167        Object[] finderArgs = new Object[] {
1168                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1169            };
1170
1171        List<UserTracker> list = (List<UserTracker>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1172                finderArgs, this);
1173
1174        if (list == null) {
1175            Session session = null;
1176
1177            try {
1178                session = openSession();
1179
1180                StringBuilder query = new StringBuilder();
1181
1182                query.append("SELECT userTracker FROM UserTracker userTracker ");
1183
1184                if (obc != null) {
1185                    query.append("ORDER BY ");
1186
1187                    String[] orderByFields = obc.getOrderByFields();
1188
1189                    for (int i = 0; i < orderByFields.length; i++) {
1190                        query.append("userTracker.");
1191                        query.append(orderByFields[i]);
1192
1193                        if (obc.isAscending()) {
1194                            query.append(" ASC");
1195                        }
1196                        else {
1197                            query.append(" DESC");
1198                        }
1199
1200                        if ((i + 1) < orderByFields.length) {
1201                            query.append(", ");
1202                        }
1203                    }
1204                }
1205
1206                Query q = session.createQuery(query.toString());
1207
1208                if (obc == null) {
1209                    list = (List<UserTracker>)QueryUtil.list(q, getDialect(),
1210                            start, end, false);
1211
1212                    Collections.sort(list);
1213                }
1214                else {
1215                    list = (List<UserTracker>)QueryUtil.list(q, getDialect(),
1216                            start, end);
1217                }
1218            }
1219            catch (Exception e) {
1220                throw processException(e);
1221            }
1222            finally {
1223                if (list == null) {
1224                    list = new ArrayList<UserTracker>();
1225                }
1226
1227                cacheResult(list);
1228
1229                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1230
1231                closeSession(session);
1232            }
1233        }
1234
1235        return list;
1236    }
1237
1238    public void removeByCompanyId(long companyId) throws SystemException {
1239        for (UserTracker userTracker : findByCompanyId(companyId)) {
1240            remove(userTracker);
1241        }
1242    }
1243
1244    public void removeByUserId(long userId) throws SystemException {
1245        for (UserTracker userTracker : findByUserId(userId)) {
1246            remove(userTracker);
1247        }
1248    }
1249
1250    public void removeBySessionId(String sessionId) throws SystemException {
1251        for (UserTracker userTracker : findBySessionId(sessionId)) {
1252            remove(userTracker);
1253        }
1254    }
1255
1256    public void removeAll() throws SystemException {
1257        for (UserTracker userTracker : findAll()) {
1258            remove(userTracker);
1259        }
1260    }
1261
1262    public int countByCompanyId(long companyId) throws SystemException {
1263        Object[] finderArgs = new Object[] { new Long(companyId) };
1264
1265        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
1266                finderArgs, this);
1267
1268        if (count == null) {
1269            Session session = null;
1270
1271            try {
1272                session = openSession();
1273
1274                StringBuilder query = new StringBuilder();
1275
1276                query.append("SELECT COUNT(userTracker) ");
1277                query.append("FROM UserTracker userTracker WHERE ");
1278
1279                query.append("userTracker.companyId = ?");
1280
1281                query.append(" ");
1282
1283                Query q = session.createQuery(query.toString());
1284
1285                QueryPos qPos = QueryPos.getInstance(q);
1286
1287                qPos.add(companyId);
1288
1289                count = (Long)q.uniqueResult();
1290            }
1291            catch (Exception e) {
1292                throw processException(e);
1293            }
1294            finally {
1295                if (count == null) {
1296                    count = Long.valueOf(0);
1297                }
1298
1299                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
1300                    finderArgs, count);
1301
1302                closeSession(session);
1303            }
1304        }
1305
1306        return count.intValue();
1307    }
1308
1309    public int countByUserId(long userId) throws SystemException {
1310        Object[] finderArgs = new Object[] { new Long(userId) };
1311
1312        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
1313                finderArgs, this);
1314
1315        if (count == null) {
1316            Session session = null;
1317
1318            try {
1319                session = openSession();
1320
1321                StringBuilder query = new StringBuilder();
1322
1323                query.append("SELECT COUNT(userTracker) ");
1324                query.append("FROM UserTracker userTracker WHERE ");
1325
1326                query.append("userTracker.userId = ?");
1327
1328                query.append(" ");
1329
1330                Query q = session.createQuery(query.toString());
1331
1332                QueryPos qPos = QueryPos.getInstance(q);
1333
1334                qPos.add(userId);
1335
1336                count = (Long)q.uniqueResult();
1337            }
1338            catch (Exception e) {
1339                throw processException(e);
1340            }
1341            finally {
1342                if (count == null) {
1343                    count = Long.valueOf(0);
1344                }
1345
1346                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
1347                    finderArgs, count);
1348
1349                closeSession(session);
1350            }
1351        }
1352
1353        return count.intValue();
1354    }
1355
1356    public int countBySessionId(String sessionId) throws SystemException {
1357        Object[] finderArgs = new Object[] { sessionId };
1358
1359        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_SESSIONID,
1360                finderArgs, this);
1361
1362        if (count == null) {
1363            Session session = null;
1364
1365            try {
1366                session = openSession();
1367
1368                StringBuilder query = new StringBuilder();
1369
1370                query.append("SELECT COUNT(userTracker) ");
1371                query.append("FROM UserTracker userTracker WHERE ");
1372
1373                if (sessionId == null) {
1374                    query.append("userTracker.sessionId IS NULL");
1375                }
1376                else {
1377                    query.append("userTracker.sessionId = ?");
1378                }
1379
1380                query.append(" ");
1381
1382                Query q = session.createQuery(query.toString());
1383
1384                QueryPos qPos = QueryPos.getInstance(q);
1385
1386                if (sessionId != null) {
1387                    qPos.add(sessionId);
1388                }
1389
1390                count = (Long)q.uniqueResult();
1391            }
1392            catch (Exception e) {
1393                throw processException(e);
1394            }
1395            finally {
1396                if (count == null) {
1397                    count = Long.valueOf(0);
1398                }
1399
1400                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_SESSIONID,
1401                    finderArgs, count);
1402
1403                closeSession(session);
1404            }
1405        }
1406
1407        return count.intValue();
1408    }
1409
1410    public int countAll() throws SystemException {
1411        Object[] finderArgs = new Object[0];
1412
1413        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1414                finderArgs, this);
1415
1416        if (count == null) {
1417            Session session = null;
1418
1419            try {
1420                session = openSession();
1421
1422                Query q = session.createQuery(
1423                        "SELECT COUNT(userTracker) FROM UserTracker userTracker");
1424
1425                count = (Long)q.uniqueResult();
1426            }
1427            catch (Exception e) {
1428                throw processException(e);
1429            }
1430            finally {
1431                if (count == null) {
1432                    count = Long.valueOf(0);
1433                }
1434
1435                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1436                    count);
1437
1438                closeSession(session);
1439            }
1440        }
1441
1442        return count.intValue();
1443    }
1444
1445    public void afterPropertiesSet() {
1446        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1447                    com.liferay.portal.util.PropsUtil.get(
1448                        "value.object.listener.com.liferay.portal.model.UserTracker")));
1449
1450        if (listenerClassNames.length > 0) {
1451            try {
1452                List<ModelListener<UserTracker>> listenersList = new ArrayList<ModelListener<UserTracker>>();
1453
1454                for (String listenerClassName : listenerClassNames) {
1455                    listenersList.add((ModelListener<UserTracker>)Class.forName(
1456                            listenerClassName).newInstance());
1457                }
1458
1459                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1460            }
1461            catch (Exception e) {
1462                _log.error(e);
1463            }
1464        }
1465    }
1466
1467    @BeanReference(name = "com.liferay.portal.service.persistence.AccountPersistence.impl")
1468    protected com.liferay.portal.service.persistence.AccountPersistence accountPersistence;
1469    @BeanReference(name = "com.liferay.portal.service.persistence.AddressPersistence.impl")
1470    protected com.liferay.portal.service.persistence.AddressPersistence addressPersistence;
1471    @BeanReference(name = "com.liferay.portal.service.persistence.BrowserTrackerPersistence.impl")
1472    protected com.liferay.portal.service.persistence.BrowserTrackerPersistence browserTrackerPersistence;
1473    @BeanReference(name = "com.liferay.portal.service.persistence.ClassNamePersistence.impl")
1474    protected com.liferay.portal.service.persistence.ClassNamePersistence classNamePersistence;
1475    @BeanReference(name = "com.liferay.portal.service.persistence.CompanyPersistence.impl")
1476    protected com.liferay.portal.service.persistence.CompanyPersistence companyPersistence;
1477    @BeanReference(name = "com.liferay.portal.service.persistence.ContactPersistence.impl")
1478    protected com.liferay.portal.service.persistence.ContactPersistence contactPersistence;
1479    @BeanReference(name = "com.liferay.portal.service.persistence.CountryPersistence.impl")
1480    protected com.liferay.portal.service.persistence.CountryPersistence countryPersistence;
1481    @BeanReference(name = "com.liferay.portal.service.persistence.EmailAddressPersistence.impl")
1482    protected com.liferay.portal.service.persistence.EmailAddressPersistence emailAddressPersistence;
1483    @BeanReference(name = "com.liferay.portal.service.persistence.GroupPersistence.impl")
1484    protected com.liferay.portal.service.persistence.GroupPersistence groupPersistence;
1485    @BeanReference(name = "com.liferay.portal.service.persistence.ImagePersistence.impl")
1486    protected com.liferay.portal.service.persistence.ImagePersistence imagePersistence;
1487    @BeanReference(name = "com.liferay.portal.service.persistence.LayoutPersistence.impl")
1488    protected com.liferay.portal.service.persistence.LayoutPersistence layoutPersistence;
1489    @BeanReference(name = "com.liferay.portal.service.persistence.LayoutSetPersistence.impl")
1490    protected com.liferay.portal.service.persistence.LayoutSetPersistence layoutSetPersistence;
1491    @BeanReference(name = "com.liferay.portal.service.persistence.ListTypePersistence.impl")
1492    protected com.liferay.portal.service.persistence.ListTypePersistence listTypePersistence;
1493    @BeanReference(name = "com.liferay.portal.service.persistence.LockPersistence.impl")
1494    protected com.liferay.portal.service.persistence.LockPersistence lockPersistence;
1495    @BeanReference(name = "com.liferay.portal.service.persistence.MembershipRequestPersistence.impl")
1496    protected com.liferay.portal.service.persistence.MembershipRequestPersistence membershipRequestPersistence;
1497    @BeanReference(name = "com.liferay.portal.service.persistence.OrganizationPersistence.impl")
1498    protected com.liferay.portal.service.persistence.OrganizationPersistence organizationPersistence;
1499    @BeanReference(name = "com.liferay.portal.service.persistence.OrgGroupPermissionPersistence.impl")
1500    protected com.liferay.portal.service.persistence.OrgGroupPermissionPersistence orgGroupPermissionPersistence;
1501    @BeanReference(name = "com.liferay.portal.service.persistence.OrgGroupRolePersistence.impl")
1502    protected com.liferay.portal.service.persistence.OrgGroupRolePersistence orgGroupRolePersistence;
1503    @BeanReference(name = "com.liferay.portal.service.persistence.OrgLaborPersistence.impl")
1504    protected com.liferay.portal.service.persistence.OrgLaborPersistence orgLaborPersistence;
1505    @BeanReference(name = "com.liferay.portal.service.persistence.PasswordPolicyPersistence.impl")
1506    protected com.liferay.portal.service.persistence.PasswordPolicyPersistence passwordPolicyPersistence;
1507    @BeanReference(name = "com.liferay.portal.service.persistence.PasswordPolicyRelPersistence.impl")
1508    protected com.liferay.portal.service.persistence.PasswordPolicyRelPersistence passwordPolicyRelPersistence;
1509    @BeanReference(name = "com.liferay.portal.service.persistence.PasswordTrackerPersistence.impl")
1510    protected com.liferay.portal.service.persistence.PasswordTrackerPersistence passwordTrackerPersistence;
1511    @BeanReference(name = "com.liferay.portal.service.persistence.PermissionPersistence.impl")
1512    protected com.liferay.portal.service.persistence.PermissionPersistence permissionPersistence;
1513    @BeanReference(name = "com.liferay.portal.service.persistence.PhonePersistence.impl")
1514    protected com.liferay.portal.service.persistence.PhonePersistence phonePersistence;
1515    @BeanReference(name = "com.liferay.portal.service.persistence.PluginSettingPersistence.impl")
1516    protected com.liferay.portal.service.persistence.PluginSettingPersistence pluginSettingPersistence;
1517    @BeanReference(name = "com.liferay.portal.service.persistence.PortletPersistence.impl")
1518    protected com.liferay.portal.service.persistence.PortletPersistence portletPersistence;
1519    @BeanReference(name = "com.liferay.portal.service.persistence.PortletItemPersistence.impl")
1520    protected com.liferay.portal.service.persistence.PortletItemPersistence portletItemPersistence;
1521    @BeanReference(name = "com.liferay.portal.service.persistence.PortletPreferencesPersistence.impl")
1522    protected com.liferay.portal.service.persistence.PortletPreferencesPersistence portletPreferencesPersistence;
1523    @BeanReference(name = "com.liferay.portal.service.persistence.RegionPersistence.impl")
1524    protected com.liferay.portal.service.persistence.RegionPersistence regionPersistence;
1525    @BeanReference(name = "com.liferay.portal.service.persistence.ReleasePersistence.impl")
1526    protected com.liferay.portal.service.persistence.ReleasePersistence releasePersistence;
1527    @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePersistence.impl")
1528    protected com.liferay.portal.service.persistence.ResourcePersistence resourcePersistence;
1529    @BeanReference(name = "com.liferay.portal.service.persistence.ResourceActionPersistence.impl")
1530    protected com.liferay.portal.service.persistence.ResourceActionPersistence resourceActionPersistence;
1531    @BeanReference(name = "com.liferay.portal.service.persistence.ResourceCodePersistence.impl")
1532    protected com.liferay.portal.service.persistence.ResourceCodePersistence resourceCodePersistence;
1533    @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePermissionPersistence.impl")
1534    protected com.liferay.portal.service.persistence.ResourcePermissionPersistence resourcePermissionPersistence;
1535    @BeanReference(name = "com.liferay.portal.service.persistence.RolePersistence.impl")
1536    protected com.liferay.portal.service.persistence.RolePersistence rolePersistence;
1537    @BeanReference(name = "com.liferay.portal.service.persistence.ServiceComponentPersistence.impl")
1538    protected com.liferay.portal.service.persistence.ServiceComponentPersistence serviceComponentPersistence;
1539    @BeanReference(name = "com.liferay.portal.service.persistence.ShardPersistence.impl")
1540    protected com.liferay.portal.service.persistence.ShardPersistence shardPersistence;
1541    @BeanReference(name = "com.liferay.portal.service.persistence.SubscriptionPersistence.impl")
1542    protected com.liferay.portal.service.persistence.SubscriptionPersistence subscriptionPersistence;
1543    @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence.impl")
1544    protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
1545    @BeanReference(name = "com.liferay.portal.service.persistence.UserGroupPersistence.impl")
1546    protected com.liferay.portal.service.persistence.UserGroupPersistence userGroupPersistence;
1547    @BeanReference(name = "com.liferay.portal.service.persistence.UserGroupRolePersistence.impl")
1548    protected com.liferay.portal.service.persistence.UserGroupRolePersistence userGroupRolePersistence;
1549    @BeanReference(name = "com.liferay.portal.service.persistence.UserIdMapperPersistence.impl")
1550    protected com.liferay.portal.service.persistence.UserIdMapperPersistence userIdMapperPersistence;
1551    @BeanReference(name = "com.liferay.portal.service.persistence.UserTrackerPersistence.impl")
1552    protected com.liferay.portal.service.persistence.UserTrackerPersistence userTrackerPersistence;
1553    @BeanReference(name = "com.liferay.portal.service.persistence.UserTrackerPathPersistence.impl")
1554    protected com.liferay.portal.service.persistence.UserTrackerPathPersistence userTrackerPathPersistence;
1555    @BeanReference(name = "com.liferay.portal.service.persistence.WebDAVPropsPersistence.impl")
1556    protected com.liferay.portal.service.persistence.WebDAVPropsPersistence webDAVPropsPersistence;
1557    @BeanReference(name = "com.liferay.portal.service.persistence.WebsitePersistence.impl")
1558    protected com.liferay.portal.service.persistence.WebsitePersistence websitePersistence;
1559    private static Log _log = LogFactoryUtil.getLog(UserTrackerPersistenceImpl.class);
1560}