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