1
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
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 }