1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.NoSuchPasswordTrackerException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.exception.SystemException;
29  import com.liferay.portal.kernel.log.Log;
30  import com.liferay.portal.kernel.log.LogFactoryUtil;
31  import com.liferay.portal.kernel.util.GetterUtil;
32  import com.liferay.portal.kernel.util.OrderByComparator;
33  import com.liferay.portal.kernel.util.StringBundler;
34  import com.liferay.portal.kernel.util.StringPool;
35  import com.liferay.portal.kernel.util.StringUtil;
36  import com.liferay.portal.model.ModelListener;
37  import com.liferay.portal.model.PasswordTracker;
38  import com.liferay.portal.model.impl.PasswordTrackerImpl;
39  import com.liferay.portal.model.impl.PasswordTrackerModelImpl;
40  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
41  
42  import java.io.Serializable;
43  
44  import java.util.ArrayList;
45  import java.util.Collections;
46  import java.util.List;
47  
48  /**
49   * <a href="PasswordTrackerPersistenceImpl.java.html"><b><i>View Source</i></b></a>
50   *
51   * <p>
52   * ServiceBuilder generated this class. Modifications in this class will be
53   * overwritten the next time is generated.
54   * </p>
55   *
56   * @author    Brian Wing Shun Chan
57   * @see       PasswordTrackerPersistence
58   * @see       PasswordTrackerUtil
59   * @generated
60   */
61  public class PasswordTrackerPersistenceImpl extends BasePersistenceImpl<PasswordTracker>
62      implements PasswordTrackerPersistence {
63      public static final String FINDER_CLASS_NAME_ENTITY = PasswordTrackerImpl.class.getName();
64      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
65          ".List";
66      public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
67              PasswordTrackerModelImpl.FINDER_CACHE_ENABLED,
68              FINDER_CLASS_NAME_LIST, "findByUserId",
69              new String[] { Long.class.getName() });
70      public static final FinderPath FINDER_PATH_FIND_BY_OBC_USERID = new FinderPath(PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
71              PasswordTrackerModelImpl.FINDER_CACHE_ENABLED,
72              FINDER_CLASS_NAME_LIST, "findByUserId",
73              new String[] {
74                  Long.class.getName(),
75                  
76              "java.lang.Integer", "java.lang.Integer",
77                  "com.liferay.portal.kernel.util.OrderByComparator"
78              });
79      public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
80              PasswordTrackerModelImpl.FINDER_CACHE_ENABLED,
81              FINDER_CLASS_NAME_LIST, "countByUserId",
82              new String[] { Long.class.getName() });
83      public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
84              PasswordTrackerModelImpl.FINDER_CACHE_ENABLED,
85              FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
86      public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
87              PasswordTrackerModelImpl.FINDER_CACHE_ENABLED,
88              FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
89  
90      public void cacheResult(PasswordTracker passwordTracker) {
91          EntityCacheUtil.putResult(PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
92              PasswordTrackerImpl.class, passwordTracker.getPrimaryKey(),
93              passwordTracker);
94      }
95  
96      public void cacheResult(List<PasswordTracker> passwordTrackers) {
97          for (PasswordTracker passwordTracker : passwordTrackers) {
98              if (EntityCacheUtil.getResult(
99                          PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
100                         PasswordTrackerImpl.class,
101                         passwordTracker.getPrimaryKey(), this) == null) {
102                 cacheResult(passwordTracker);
103             }
104         }
105     }
106 
107     public void clearCache() {
108         CacheRegistry.clear(PasswordTrackerImpl.class.getName());
109         EntityCacheUtil.clearCache(PasswordTrackerImpl.class.getName());
110         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
111         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
112     }
113 
114     public PasswordTracker create(long passwordTrackerId) {
115         PasswordTracker passwordTracker = new PasswordTrackerImpl();
116 
117         passwordTracker.setNew(true);
118         passwordTracker.setPrimaryKey(passwordTrackerId);
119 
120         return passwordTracker;
121     }
122 
123     public PasswordTracker remove(Serializable primaryKey)
124         throws NoSuchModelException, SystemException {
125         return remove(((Long)primaryKey).longValue());
126     }
127 
128     public PasswordTracker remove(long passwordTrackerId)
129         throws NoSuchPasswordTrackerException, SystemException {
130         Session session = null;
131 
132         try {
133             session = openSession();
134 
135             PasswordTracker passwordTracker = (PasswordTracker)session.get(PasswordTrackerImpl.class,
136                     new Long(passwordTrackerId));
137 
138             if (passwordTracker == null) {
139                 if (_log.isWarnEnabled()) {
140                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
141                         passwordTrackerId);
142                 }
143 
144                 throw new NoSuchPasswordTrackerException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
145                     passwordTrackerId);
146             }
147 
148             return remove(passwordTracker);
149         }
150         catch (NoSuchPasswordTrackerException nsee) {
151             throw nsee;
152         }
153         catch (Exception e) {
154             throw processException(e);
155         }
156         finally {
157             closeSession(session);
158         }
159     }
160 
161     public PasswordTracker remove(PasswordTracker passwordTracker)
162         throws SystemException {
163         for (ModelListener<PasswordTracker> listener : listeners) {
164             listener.onBeforeRemove(passwordTracker);
165         }
166 
167         passwordTracker = removeImpl(passwordTracker);
168 
169         for (ModelListener<PasswordTracker> listener : listeners) {
170             listener.onAfterRemove(passwordTracker);
171         }
172 
173         return passwordTracker;
174     }
175 
176     protected PasswordTracker removeImpl(PasswordTracker passwordTracker)
177         throws SystemException {
178         passwordTracker = toUnwrappedModel(passwordTracker);
179 
180         Session session = null;
181 
182         try {
183             session = openSession();
184 
185             if (passwordTracker.isCachedModel() ||
186                     BatchSessionUtil.isEnabled()) {
187                 Object staleObject = session.get(PasswordTrackerImpl.class,
188                         passwordTracker.getPrimaryKeyObj());
189 
190                 if (staleObject != null) {
191                     session.evict(staleObject);
192                 }
193             }
194 
195             session.delete(passwordTracker);
196 
197             session.flush();
198         }
199         catch (Exception e) {
200             throw processException(e);
201         }
202         finally {
203             closeSession(session);
204         }
205 
206         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
207 
208         EntityCacheUtil.removeResult(PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
209             PasswordTrackerImpl.class, passwordTracker.getPrimaryKey());
210 
211         return passwordTracker;
212     }
213 
214     public PasswordTracker updateImpl(
215         com.liferay.portal.model.PasswordTracker passwordTracker, boolean merge)
216         throws SystemException {
217         passwordTracker = toUnwrappedModel(passwordTracker);
218 
219         Session session = null;
220 
221         try {
222             session = openSession();
223 
224             BatchSessionUtil.update(session, passwordTracker, merge);
225 
226             passwordTracker.setNew(false);
227         }
228         catch (Exception e) {
229             throw processException(e);
230         }
231         finally {
232             closeSession(session);
233         }
234 
235         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
236 
237         EntityCacheUtil.putResult(PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
238             PasswordTrackerImpl.class, passwordTracker.getPrimaryKey(),
239             passwordTracker);
240 
241         return passwordTracker;
242     }
243 
244     protected PasswordTracker toUnwrappedModel(PasswordTracker passwordTracker) {
245         if (passwordTracker instanceof PasswordTrackerImpl) {
246             return passwordTracker;
247         }
248 
249         PasswordTrackerImpl passwordTrackerImpl = new PasswordTrackerImpl();
250 
251         passwordTrackerImpl.setNew(passwordTracker.isNew());
252         passwordTrackerImpl.setPrimaryKey(passwordTracker.getPrimaryKey());
253 
254         passwordTrackerImpl.setPasswordTrackerId(passwordTracker.getPasswordTrackerId());
255         passwordTrackerImpl.setUserId(passwordTracker.getUserId());
256         passwordTrackerImpl.setCreateDate(passwordTracker.getCreateDate());
257         passwordTrackerImpl.setPassword(passwordTracker.getPassword());
258 
259         return passwordTrackerImpl;
260     }
261 
262     public PasswordTracker findByPrimaryKey(Serializable primaryKey)
263         throws NoSuchModelException, SystemException {
264         return findByPrimaryKey(((Long)primaryKey).longValue());
265     }
266 
267     public PasswordTracker findByPrimaryKey(long passwordTrackerId)
268         throws NoSuchPasswordTrackerException, SystemException {
269         PasswordTracker passwordTracker = fetchByPrimaryKey(passwordTrackerId);
270 
271         if (passwordTracker == null) {
272             if (_log.isWarnEnabled()) {
273                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + passwordTrackerId);
274             }
275 
276             throw new NoSuchPasswordTrackerException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
277                 passwordTrackerId);
278         }
279 
280         return passwordTracker;
281     }
282 
283     public PasswordTracker fetchByPrimaryKey(Serializable primaryKey)
284         throws SystemException {
285         return fetchByPrimaryKey(((Long)primaryKey).longValue());
286     }
287 
288     public PasswordTracker fetchByPrimaryKey(long passwordTrackerId)
289         throws SystemException {
290         PasswordTracker passwordTracker = (PasswordTracker)EntityCacheUtil.getResult(PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
291                 PasswordTrackerImpl.class, passwordTrackerId, this);
292 
293         if (passwordTracker == null) {
294             Session session = null;
295 
296             try {
297                 session = openSession();
298 
299                 passwordTracker = (PasswordTracker)session.get(PasswordTrackerImpl.class,
300                         new Long(passwordTrackerId));
301             }
302             catch (Exception e) {
303                 throw processException(e);
304             }
305             finally {
306                 if (passwordTracker != null) {
307                     cacheResult(passwordTracker);
308                 }
309 
310                 closeSession(session);
311             }
312         }
313 
314         return passwordTracker;
315     }
316 
317     public List<PasswordTracker> findByUserId(long userId)
318         throws SystemException {
319         Object[] finderArgs = new Object[] { new Long(userId) };
320 
321         List<PasswordTracker> list = (List<PasswordTracker>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
322                 finderArgs, this);
323 
324         if (list == null) {
325             Session session = null;
326 
327             try {
328                 session = openSession();
329 
330                 StringBundler query = new StringBundler(3);
331 
332                 query.append(_SQL_SELECT_PASSWORDTRACKER_WHERE);
333 
334                 query.append(_FINDER_COLUMN_USERID_USERID_2);
335 
336                 query.append(PasswordTrackerModelImpl.ORDER_BY_JPQL);
337 
338                 String sql = query.toString();
339 
340                 Query q = session.createQuery(sql);
341 
342                 QueryPos qPos = QueryPos.getInstance(q);
343 
344                 qPos.add(userId);
345 
346                 list = q.list();
347             }
348             catch (Exception e) {
349                 throw processException(e);
350             }
351             finally {
352                 if (list == null) {
353                     list = new ArrayList<PasswordTracker>();
354                 }
355 
356                 cacheResult(list);
357 
358                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
359                     finderArgs, list);
360 
361                 closeSession(session);
362             }
363         }
364 
365         return list;
366     }
367 
368     public List<PasswordTracker> findByUserId(long userId, int start, int end)
369         throws SystemException {
370         return findByUserId(userId, start, end, null);
371     }
372 
373     public List<PasswordTracker> findByUserId(long userId, int start, int end,
374         OrderByComparator orderByComparator) throws SystemException {
375         Object[] finderArgs = new Object[] {
376                 new Long(userId),
377                 
378                 String.valueOf(start), String.valueOf(end),
379                 String.valueOf(orderByComparator)
380             };
381 
382         List<PasswordTracker> list = (List<PasswordTracker>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_USERID,
383                 finderArgs, this);
384 
385         if (list == null) {
386             Session session = null;
387 
388             try {
389                 session = openSession();
390 
391                 StringBundler query = null;
392 
393                 if (orderByComparator != null) {
394                     query = new StringBundler(3 +
395                             (orderByComparator.getOrderByFields().length * 3));
396                 }
397                 else {
398                     query = new StringBundler(3);
399                 }
400 
401                 query.append(_SQL_SELECT_PASSWORDTRACKER_WHERE);
402 
403                 query.append(_FINDER_COLUMN_USERID_USERID_2);
404 
405                 if (orderByComparator != null) {
406                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
407                         orderByComparator);
408                 }
409 
410                 else {
411                     query.append(PasswordTrackerModelImpl.ORDER_BY_JPQL);
412                 }
413 
414                 String sql = query.toString();
415 
416                 Query q = session.createQuery(sql);
417 
418                 QueryPos qPos = QueryPos.getInstance(q);
419 
420                 qPos.add(userId);
421 
422                 list = (List<PasswordTracker>)QueryUtil.list(q, getDialect(),
423                         start, end);
424             }
425             catch (Exception e) {
426                 throw processException(e);
427             }
428             finally {
429                 if (list == null) {
430                     list = new ArrayList<PasswordTracker>();
431                 }
432 
433                 cacheResult(list);
434 
435                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_USERID,
436                     finderArgs, list);
437 
438                 closeSession(session);
439             }
440         }
441 
442         return list;
443     }
444 
445     public PasswordTracker findByUserId_First(long userId,
446         OrderByComparator orderByComparator)
447         throws NoSuchPasswordTrackerException, SystemException {
448         List<PasswordTracker> list = findByUserId(userId, 0, 1,
449                 orderByComparator);
450 
451         if (list.isEmpty()) {
452             StringBundler msg = new StringBundler(4);
453 
454             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
455 
456             msg.append("userId=");
457             msg.append(userId);
458 
459             msg.append(StringPool.CLOSE_CURLY_BRACE);
460 
461             throw new NoSuchPasswordTrackerException(msg.toString());
462         }
463         else {
464             return list.get(0);
465         }
466     }
467 
468     public PasswordTracker findByUserId_Last(long userId,
469         OrderByComparator orderByComparator)
470         throws NoSuchPasswordTrackerException, SystemException {
471         int count = countByUserId(userId);
472 
473         List<PasswordTracker> list = findByUserId(userId, count - 1, count,
474                 orderByComparator);
475 
476         if (list.isEmpty()) {
477             StringBundler msg = new StringBundler(4);
478 
479             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
480 
481             msg.append("userId=");
482             msg.append(userId);
483 
484             msg.append(StringPool.CLOSE_CURLY_BRACE);
485 
486             throw new NoSuchPasswordTrackerException(msg.toString());
487         }
488         else {
489             return list.get(0);
490         }
491     }
492 
493     public PasswordTracker[] findByUserId_PrevAndNext(long passwordTrackerId,
494         long userId, OrderByComparator orderByComparator)
495         throws NoSuchPasswordTrackerException, SystemException {
496         PasswordTracker passwordTracker = findByPrimaryKey(passwordTrackerId);
497 
498         int count = countByUserId(userId);
499 
500         Session session = null;
501 
502         try {
503             session = openSession();
504 
505             StringBundler query = null;
506 
507             if (orderByComparator != null) {
508                 query = new StringBundler(3 +
509                         (orderByComparator.getOrderByFields().length * 3));
510             }
511             else {
512                 query = new StringBundler(3);
513             }
514 
515             query.append(_SQL_SELECT_PASSWORDTRACKER_WHERE);
516 
517             query.append(_FINDER_COLUMN_USERID_USERID_2);
518 
519             if (orderByComparator != null) {
520                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
521                     orderByComparator);
522             }
523 
524             else {
525                 query.append(PasswordTrackerModelImpl.ORDER_BY_JPQL);
526             }
527 
528             String sql = query.toString();
529 
530             Query q = session.createQuery(sql);
531 
532             QueryPos qPos = QueryPos.getInstance(q);
533 
534             qPos.add(userId);
535 
536             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
537                     orderByComparator, passwordTracker);
538 
539             PasswordTracker[] array = new PasswordTrackerImpl[3];
540 
541             array[0] = (PasswordTracker)objArray[0];
542             array[1] = (PasswordTracker)objArray[1];
543             array[2] = (PasswordTracker)objArray[2];
544 
545             return array;
546         }
547         catch (Exception e) {
548             throw processException(e);
549         }
550         finally {
551             closeSession(session);
552         }
553     }
554 
555     public List<PasswordTracker> findAll() throws SystemException {
556         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
557     }
558 
559     public List<PasswordTracker> findAll(int start, int end)
560         throws SystemException {
561         return findAll(start, end, null);
562     }
563 
564     public List<PasswordTracker> findAll(int start, int end,
565         OrderByComparator orderByComparator) throws SystemException {
566         Object[] finderArgs = new Object[] {
567                 String.valueOf(start), String.valueOf(end),
568                 String.valueOf(orderByComparator)
569             };
570 
571         List<PasswordTracker> list = (List<PasswordTracker>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
572                 finderArgs, this);
573 
574         if (list == null) {
575             Session session = null;
576 
577             try {
578                 session = openSession();
579 
580                 StringBundler query = null;
581                 String sql = null;
582 
583                 if (orderByComparator != null) {
584                     query = new StringBundler(2 +
585                             (orderByComparator.getOrderByFields().length * 3));
586 
587                     query.append(_SQL_SELECT_PASSWORDTRACKER);
588 
589                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
590                         orderByComparator);
591 
592                     sql = query.toString();
593                 }
594 
595                 else {
596                     sql = _SQL_SELECT_PASSWORDTRACKER.concat(PasswordTrackerModelImpl.ORDER_BY_JPQL);
597                 }
598 
599                 Query q = session.createQuery(sql);
600 
601                 if (orderByComparator == null) {
602                     list = (List<PasswordTracker>)QueryUtil.list(q,
603                             getDialect(), start, end, false);
604 
605                     Collections.sort(list);
606                 }
607                 else {
608                     list = (List<PasswordTracker>)QueryUtil.list(q,
609                             getDialect(), start, end);
610                 }
611             }
612             catch (Exception e) {
613                 throw processException(e);
614             }
615             finally {
616                 if (list == null) {
617                     list = new ArrayList<PasswordTracker>();
618                 }
619 
620                 cacheResult(list);
621 
622                 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
623 
624                 closeSession(session);
625             }
626         }
627 
628         return list;
629     }
630 
631     public void removeByUserId(long userId) throws SystemException {
632         for (PasswordTracker passwordTracker : findByUserId(userId)) {
633             remove(passwordTracker);
634         }
635     }
636 
637     public void removeAll() throws SystemException {
638         for (PasswordTracker passwordTracker : findAll()) {
639             remove(passwordTracker);
640         }
641     }
642 
643     public int countByUserId(long userId) throws SystemException {
644         Object[] finderArgs = new Object[] { new Long(userId) };
645 
646         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
647                 finderArgs, this);
648 
649         if (count == null) {
650             Session session = null;
651 
652             try {
653                 session = openSession();
654 
655                 StringBundler query = new StringBundler(2);
656 
657                 query.append(_SQL_COUNT_PASSWORDTRACKER_WHERE);
658 
659                 query.append(_FINDER_COLUMN_USERID_USERID_2);
660 
661                 String sql = query.toString();
662 
663                 Query q = session.createQuery(sql);
664 
665                 QueryPos qPos = QueryPos.getInstance(q);
666 
667                 qPos.add(userId);
668 
669                 count = (Long)q.uniqueResult();
670             }
671             catch (Exception e) {
672                 throw processException(e);
673             }
674             finally {
675                 if (count == null) {
676                     count = Long.valueOf(0);
677                 }
678 
679                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
680                     finderArgs, count);
681 
682                 closeSession(session);
683             }
684         }
685 
686         return count.intValue();
687     }
688 
689     public int countAll() throws SystemException {
690         Object[] finderArgs = new Object[0];
691 
692         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
693                 finderArgs, this);
694 
695         if (count == null) {
696             Session session = null;
697 
698             try {
699                 session = openSession();
700 
701                 Query q = session.createQuery(_SQL_COUNT_PASSWORDTRACKER);
702 
703                 count = (Long)q.uniqueResult();
704             }
705             catch (Exception e) {
706                 throw processException(e);
707             }
708             finally {
709                 if (count == null) {
710                     count = Long.valueOf(0);
711                 }
712 
713                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
714                     count);
715 
716                 closeSession(session);
717             }
718         }
719 
720         return count.intValue();
721     }
722 
723     public void afterPropertiesSet() {
724         String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
725                     com.liferay.portal.util.PropsUtil.get(
726                         "value.object.listener.com.liferay.portal.model.PasswordTracker")));
727 
728         if (listenerClassNames.length > 0) {
729             try {
730                 List<ModelListener<PasswordTracker>> listenersList = new ArrayList<ModelListener<PasswordTracker>>();
731 
732                 for (String listenerClassName : listenerClassNames) {
733                     listenersList.add((ModelListener<PasswordTracker>)Class.forName(
734                             listenerClassName).newInstance());
735                 }
736 
737                 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
738             }
739             catch (Exception e) {
740                 _log.error(e);
741             }
742         }
743     }
744 
745     @BeanReference(type = AccountPersistence.class)
746     protected AccountPersistence accountPersistence;
747     @BeanReference(type = AddressPersistence.class)
748     protected AddressPersistence addressPersistence;
749     @BeanReference(type = BrowserTrackerPersistence.class)
750     protected BrowserTrackerPersistence browserTrackerPersistence;
751     @BeanReference(type = ClassNamePersistence.class)
752     protected ClassNamePersistence classNamePersistence;
753     @BeanReference(type = CompanyPersistence.class)
754     protected CompanyPersistence companyPersistence;
755     @BeanReference(type = ContactPersistence.class)
756     protected ContactPersistence contactPersistence;
757     @BeanReference(type = CountryPersistence.class)
758     protected CountryPersistence countryPersistence;
759     @BeanReference(type = EmailAddressPersistence.class)
760     protected EmailAddressPersistence emailAddressPersistence;
761     @BeanReference(type = GroupPersistence.class)
762     protected GroupPersistence groupPersistence;
763     @BeanReference(type = ImagePersistence.class)
764     protected ImagePersistence imagePersistence;
765     @BeanReference(type = LayoutPersistence.class)
766     protected LayoutPersistence layoutPersistence;
767     @BeanReference(type = LayoutPrototypePersistence.class)
768     protected LayoutPrototypePersistence layoutPrototypePersistence;
769     @BeanReference(type = LayoutSetPersistence.class)
770     protected LayoutSetPersistence layoutSetPersistence;
771     @BeanReference(type = LayoutSetPrototypePersistence.class)
772     protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
773     @BeanReference(type = ListTypePersistence.class)
774     protected ListTypePersistence listTypePersistence;
775     @BeanReference(type = LockPersistence.class)
776     protected LockPersistence lockPersistence;
777     @BeanReference(type = MembershipRequestPersistence.class)
778     protected MembershipRequestPersistence membershipRequestPersistence;
779     @BeanReference(type = OrganizationPersistence.class)
780     protected OrganizationPersistence organizationPersistence;
781     @BeanReference(type = OrgGroupPermissionPersistence.class)
782     protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
783     @BeanReference(type = OrgGroupRolePersistence.class)
784     protected OrgGroupRolePersistence orgGroupRolePersistence;
785     @BeanReference(type = OrgLaborPersistence.class)
786     protected OrgLaborPersistence orgLaborPersistence;
787     @BeanReference(type = PasswordPolicyPersistence.class)
788     protected PasswordPolicyPersistence passwordPolicyPersistence;
789     @BeanReference(type = PasswordPolicyRelPersistence.class)
790     protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
791     @BeanReference(type = PasswordTrackerPersistence.class)
792     protected PasswordTrackerPersistence passwordTrackerPersistence;
793     @BeanReference(type = PermissionPersistence.class)
794     protected PermissionPersistence permissionPersistence;
795     @BeanReference(type = PhonePersistence.class)
796     protected PhonePersistence phonePersistence;
797     @BeanReference(type = PluginSettingPersistence.class)
798     protected PluginSettingPersistence pluginSettingPersistence;
799     @BeanReference(type = PortletPersistence.class)
800     protected PortletPersistence portletPersistence;
801     @BeanReference(type = PortletItemPersistence.class)
802     protected PortletItemPersistence portletItemPersistence;
803     @BeanReference(type = PortletPreferencesPersistence.class)
804     protected PortletPreferencesPersistence portletPreferencesPersistence;
805     @BeanReference(type = RegionPersistence.class)
806     protected RegionPersistence regionPersistence;
807     @BeanReference(type = ReleasePersistence.class)
808     protected ReleasePersistence releasePersistence;
809     @BeanReference(type = ResourcePersistence.class)
810     protected ResourcePersistence resourcePersistence;
811     @BeanReference(type = ResourceActionPersistence.class)
812     protected ResourceActionPersistence resourceActionPersistence;
813     @BeanReference(type = ResourceCodePersistence.class)
814     protected ResourceCodePersistence resourceCodePersistence;
815     @BeanReference(type = ResourcePermissionPersistence.class)
816     protected ResourcePermissionPersistence resourcePermissionPersistence;
817     @BeanReference(type = RolePersistence.class)
818     protected RolePersistence rolePersistence;
819     @BeanReference(type = ServiceComponentPersistence.class)
820     protected ServiceComponentPersistence serviceComponentPersistence;
821     @BeanReference(type = ShardPersistence.class)
822     protected ShardPersistence shardPersistence;
823     @BeanReference(type = SubscriptionPersistence.class)
824     protected SubscriptionPersistence subscriptionPersistence;
825     @BeanReference(type = TeamPersistence.class)
826     protected TeamPersistence teamPersistence;
827     @BeanReference(type = UserPersistence.class)
828     protected UserPersistence userPersistence;
829     @BeanReference(type = UserGroupPersistence.class)
830     protected UserGroupPersistence userGroupPersistence;
831     @BeanReference(type = UserGroupGroupRolePersistence.class)
832     protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
833     @BeanReference(type = UserGroupRolePersistence.class)
834     protected UserGroupRolePersistence userGroupRolePersistence;
835     @BeanReference(type = UserIdMapperPersistence.class)
836     protected UserIdMapperPersistence userIdMapperPersistence;
837     @BeanReference(type = UserTrackerPersistence.class)
838     protected UserTrackerPersistence userTrackerPersistence;
839     @BeanReference(type = UserTrackerPathPersistence.class)
840     protected UserTrackerPathPersistence userTrackerPathPersistence;
841     @BeanReference(type = WebDAVPropsPersistence.class)
842     protected WebDAVPropsPersistence webDAVPropsPersistence;
843     @BeanReference(type = WebsitePersistence.class)
844     protected WebsitePersistence websitePersistence;
845     @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
846     protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
847     @BeanReference(type = WorkflowInstanceLinkPersistence.class)
848     protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
849     private static final String _SQL_SELECT_PASSWORDTRACKER = "SELECT passwordTracker FROM PasswordTracker passwordTracker";
850     private static final String _SQL_SELECT_PASSWORDTRACKER_WHERE = "SELECT passwordTracker FROM PasswordTracker passwordTracker WHERE ";
851     private static final String _SQL_COUNT_PASSWORDTRACKER = "SELECT COUNT(passwordTracker) FROM PasswordTracker passwordTracker";
852     private static final String _SQL_COUNT_PASSWORDTRACKER_WHERE = "SELECT COUNT(passwordTracker) FROM PasswordTracker passwordTracker WHERE ";
853     private static final String _FINDER_COLUMN_USERID_USERID_2 = "passwordTracker.userId = ?";
854     private static final String _ORDER_BY_ENTITY_ALIAS = "passwordTracker.";
855     private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No PasswordTracker exists with the primary key ";
856     private static final String _NO_SUCH_ENTITY_WITH_KEY = "No PasswordTracker exists with the key {";
857     private static Log _log = LogFactoryUtil.getLog(PasswordTrackerPersistenceImpl.class);
858 }