1
19
20 package com.liferay.portal.service.persistence;
21
22 import com.liferay.portal.NoSuchPasswordTrackerException;
23 import com.liferay.portal.SystemException;
24 import com.liferay.portal.kernel.dao.orm.DynamicQuery;
25 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
26 import com.liferay.portal.kernel.dao.orm.Query;
27 import com.liferay.portal.kernel.dao.orm.QueryPos;
28 import com.liferay.portal.kernel.dao.orm.QueryUtil;
29 import com.liferay.portal.kernel.dao.orm.Session;
30 import com.liferay.portal.kernel.log.Log;
31 import com.liferay.portal.kernel.log.LogFactoryUtil;
32 import com.liferay.portal.kernel.util.GetterUtil;
33 import com.liferay.portal.kernel.util.OrderByComparator;
34 import com.liferay.portal.kernel.util.StringPool;
35 import com.liferay.portal.kernel.util.StringUtil;
36 import com.liferay.portal.model.ModelListener;
37 import com.liferay.portal.model.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.util.ArrayList;
43 import java.util.Collections;
44 import java.util.Iterator;
45 import java.util.List;
46
47
53 public class PasswordTrackerPersistenceImpl extends BasePersistenceImpl
54 implements PasswordTrackerPersistence {
55 public PasswordTracker create(long passwordTrackerId) {
56 PasswordTracker passwordTracker = new PasswordTrackerImpl();
57
58 passwordTracker.setNew(true);
59 passwordTracker.setPrimaryKey(passwordTrackerId);
60
61 return passwordTracker;
62 }
63
64 public PasswordTracker remove(long passwordTrackerId)
65 throws NoSuchPasswordTrackerException, SystemException {
66 Session session = null;
67
68 try {
69 session = openSession();
70
71 PasswordTracker passwordTracker = (PasswordTracker)session.get(PasswordTrackerImpl.class,
72 new Long(passwordTrackerId));
73
74 if (passwordTracker == null) {
75 if (_log.isWarnEnabled()) {
76 _log.warn("No PasswordTracker exists with the primary key " +
77 passwordTrackerId);
78 }
79
80 throw new NoSuchPasswordTrackerException(
81 "No PasswordTracker exists with the primary key " +
82 passwordTrackerId);
83 }
84
85 return remove(passwordTracker);
86 }
87 catch (NoSuchPasswordTrackerException nsee) {
88 throw nsee;
89 }
90 catch (Exception e) {
91 throw processException(e);
92 }
93 finally {
94 closeSession(session);
95 }
96 }
97
98 public PasswordTracker remove(PasswordTracker passwordTracker)
99 throws SystemException {
100 for (ModelListener listener : listeners) {
101 listener.onBeforeRemove(passwordTracker);
102 }
103
104 passwordTracker = removeImpl(passwordTracker);
105
106 for (ModelListener listener : listeners) {
107 listener.onAfterRemove(passwordTracker);
108 }
109
110 return passwordTracker;
111 }
112
113 protected PasswordTracker removeImpl(PasswordTracker passwordTracker)
114 throws SystemException {
115 Session session = null;
116
117 try {
118 session = openSession();
119
120 if (BatchSessionUtil.isEnabled()) {
121 Object staleObject = session.get(PasswordTrackerImpl.class,
122 passwordTracker.getPrimaryKeyObj());
123
124 if (staleObject != null) {
125 session.evict(staleObject);
126 }
127 }
128
129 session.delete(passwordTracker);
130
131 session.flush();
132
133 return passwordTracker;
134 }
135 catch (Exception e) {
136 throw processException(e);
137 }
138 finally {
139 closeSession(session);
140
141 FinderCacheUtil.clearCache(PasswordTracker.class.getName());
142 }
143 }
144
145
148 public PasswordTracker update(PasswordTracker passwordTracker)
149 throws SystemException {
150 if (_log.isWarnEnabled()) {
151 _log.warn(
152 "Using the deprecated update(PasswordTracker passwordTracker) method. Use update(PasswordTracker passwordTracker, boolean merge) instead.");
153 }
154
155 return update(passwordTracker, false);
156 }
157
158
171 public PasswordTracker update(PasswordTracker passwordTracker, boolean merge)
172 throws SystemException {
173 boolean isNew = passwordTracker.isNew();
174
175 for (ModelListener listener : listeners) {
176 if (isNew) {
177 listener.onBeforeCreate(passwordTracker);
178 }
179 else {
180 listener.onBeforeUpdate(passwordTracker);
181 }
182 }
183
184 passwordTracker = updateImpl(passwordTracker, merge);
185
186 for (ModelListener listener : listeners) {
187 if (isNew) {
188 listener.onAfterCreate(passwordTracker);
189 }
190 else {
191 listener.onAfterUpdate(passwordTracker);
192 }
193 }
194
195 return passwordTracker;
196 }
197
198 public PasswordTracker updateImpl(
199 com.liferay.portal.model.PasswordTracker passwordTracker, boolean merge)
200 throws SystemException {
201 Session session = null;
202
203 try {
204 session = openSession();
205
206 BatchSessionUtil.update(session, passwordTracker, merge);
207
208 passwordTracker.setNew(false);
209
210 return passwordTracker;
211 }
212 catch (Exception e) {
213 throw processException(e);
214 }
215 finally {
216 closeSession(session);
217
218 FinderCacheUtil.clearCache(PasswordTracker.class.getName());
219 }
220 }
221
222 public PasswordTracker findByPrimaryKey(long passwordTrackerId)
223 throws NoSuchPasswordTrackerException, SystemException {
224 PasswordTracker passwordTracker = fetchByPrimaryKey(passwordTrackerId);
225
226 if (passwordTracker == null) {
227 if (_log.isWarnEnabled()) {
228 _log.warn("No PasswordTracker exists with the primary key " +
229 passwordTrackerId);
230 }
231
232 throw new NoSuchPasswordTrackerException(
233 "No PasswordTracker exists with the primary key " +
234 passwordTrackerId);
235 }
236
237 return passwordTracker;
238 }
239
240 public PasswordTracker fetchByPrimaryKey(long passwordTrackerId)
241 throws SystemException {
242 Session session = null;
243
244 try {
245 session = openSession();
246
247 return (PasswordTracker)session.get(PasswordTrackerImpl.class,
248 new Long(passwordTrackerId));
249 }
250 catch (Exception e) {
251 throw processException(e);
252 }
253 finally {
254 closeSession(session);
255 }
256 }
257
258 public List<PasswordTracker> findByUserId(long userId)
259 throws SystemException {
260 boolean finderClassNameCacheEnabled = PasswordTrackerModelImpl.CACHE_ENABLED;
261 String finderClassName = PasswordTracker.class.getName();
262 String finderMethodName = "findByUserId";
263 String[] finderParams = new String[] { Long.class.getName() };
264 Object[] finderArgs = new Object[] { new Long(userId) };
265
266 Object result = null;
267
268 if (finderClassNameCacheEnabled) {
269 result = FinderCacheUtil.getResult(finderClassName,
270 finderMethodName, finderParams, finderArgs, this);
271 }
272
273 if (result == null) {
274 Session session = null;
275
276 try {
277 session = openSession();
278
279 StringBuilder query = new StringBuilder();
280
281 query.append(
282 "FROM com.liferay.portal.model.PasswordTracker WHERE ");
283
284 query.append("userId = ?");
285
286 query.append(" ");
287
288 query.append("ORDER BY ");
289
290 query.append("userId DESC, ");
291 query.append("createDate DESC");
292
293 Query q = session.createQuery(query.toString());
294
295 QueryPos qPos = QueryPos.getInstance(q);
296
297 qPos.add(userId);
298
299 List<PasswordTracker> list = q.list();
300
301 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
302 finderClassName, finderMethodName, finderParams,
303 finderArgs, list);
304
305 return list;
306 }
307 catch (Exception e) {
308 throw processException(e);
309 }
310 finally {
311 closeSession(session);
312 }
313 }
314 else {
315 return (List<PasswordTracker>)result;
316 }
317 }
318
319 public List<PasswordTracker> findByUserId(long userId, int start, int end)
320 throws SystemException {
321 return findByUserId(userId, start, end, null);
322 }
323
324 public List<PasswordTracker> findByUserId(long userId, int start, int end,
325 OrderByComparator obc) throws SystemException {
326 boolean finderClassNameCacheEnabled = PasswordTrackerModelImpl.CACHE_ENABLED;
327 String finderClassName = PasswordTracker.class.getName();
328 String finderMethodName = "findByUserId";
329 String[] finderParams = new String[] {
330 Long.class.getName(),
331
332 "java.lang.Integer", "java.lang.Integer",
333 "com.liferay.portal.kernel.util.OrderByComparator"
334 };
335 Object[] finderArgs = new Object[] {
336 new Long(userId),
337
338 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
339 };
340
341 Object result = null;
342
343 if (finderClassNameCacheEnabled) {
344 result = FinderCacheUtil.getResult(finderClassName,
345 finderMethodName, finderParams, finderArgs, this);
346 }
347
348 if (result == null) {
349 Session session = null;
350
351 try {
352 session = openSession();
353
354 StringBuilder query = new StringBuilder();
355
356 query.append(
357 "FROM com.liferay.portal.model.PasswordTracker WHERE ");
358
359 query.append("userId = ?");
360
361 query.append(" ");
362
363 if (obc != null) {
364 query.append("ORDER BY ");
365 query.append(obc.getOrderBy());
366 }
367
368 else {
369 query.append("ORDER BY ");
370
371 query.append("userId DESC, ");
372 query.append("createDate DESC");
373 }
374
375 Query q = session.createQuery(query.toString());
376
377 QueryPos qPos = QueryPos.getInstance(q);
378
379 qPos.add(userId);
380
381 List<PasswordTracker> list = (List<PasswordTracker>)QueryUtil.list(q,
382 getDialect(), start, end);
383
384 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
385 finderClassName, finderMethodName, finderParams,
386 finderArgs, list);
387
388 return list;
389 }
390 catch (Exception e) {
391 throw processException(e);
392 }
393 finally {
394 closeSession(session);
395 }
396 }
397 else {
398 return (List<PasswordTracker>)result;
399 }
400 }
401
402 public PasswordTracker findByUserId_First(long userId, OrderByComparator obc)
403 throws NoSuchPasswordTrackerException, SystemException {
404 List<PasswordTracker> list = findByUserId(userId, 0, 1, obc);
405
406 if (list.size() == 0) {
407 StringBuilder msg = new StringBuilder();
408
409 msg.append("No PasswordTracker exists with the key {");
410
411 msg.append("userId=" + userId);
412
413 msg.append(StringPool.CLOSE_CURLY_BRACE);
414
415 throw new NoSuchPasswordTrackerException(msg.toString());
416 }
417 else {
418 return list.get(0);
419 }
420 }
421
422 public PasswordTracker findByUserId_Last(long userId, OrderByComparator obc)
423 throws NoSuchPasswordTrackerException, SystemException {
424 int count = countByUserId(userId);
425
426 List<PasswordTracker> list = findByUserId(userId, count - 1, count, obc);
427
428 if (list.size() == 0) {
429 StringBuilder msg = new StringBuilder();
430
431 msg.append("No PasswordTracker exists with the key {");
432
433 msg.append("userId=" + userId);
434
435 msg.append(StringPool.CLOSE_CURLY_BRACE);
436
437 throw new NoSuchPasswordTrackerException(msg.toString());
438 }
439 else {
440 return list.get(0);
441 }
442 }
443
444 public PasswordTracker[] findByUserId_PrevAndNext(long passwordTrackerId,
445 long userId, OrderByComparator obc)
446 throws NoSuchPasswordTrackerException, SystemException {
447 PasswordTracker passwordTracker = findByPrimaryKey(passwordTrackerId);
448
449 int count = countByUserId(userId);
450
451 Session session = null;
452
453 try {
454 session = openSession();
455
456 StringBuilder query = new StringBuilder();
457
458 query.append("FROM com.liferay.portal.model.PasswordTracker WHERE ");
459
460 query.append("userId = ?");
461
462 query.append(" ");
463
464 if (obc != null) {
465 query.append("ORDER BY ");
466 query.append(obc.getOrderBy());
467 }
468
469 else {
470 query.append("ORDER BY ");
471
472 query.append("userId DESC, ");
473 query.append("createDate DESC");
474 }
475
476 Query q = session.createQuery(query.toString());
477
478 QueryPos qPos = QueryPos.getInstance(q);
479
480 qPos.add(userId);
481
482 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
483 passwordTracker);
484
485 PasswordTracker[] array = new PasswordTrackerImpl[3];
486
487 array[0] = (PasswordTracker)objArray[0];
488 array[1] = (PasswordTracker)objArray[1];
489 array[2] = (PasswordTracker)objArray[2];
490
491 return array;
492 }
493 catch (Exception e) {
494 throw processException(e);
495 }
496 finally {
497 closeSession(session);
498 }
499 }
500
501 public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
502 throws SystemException {
503 Session session = null;
504
505 try {
506 session = openSession();
507
508 dynamicQuery.compile(session);
509
510 return dynamicQuery.list();
511 }
512 catch (Exception e) {
513 throw processException(e);
514 }
515 finally {
516 closeSession(session);
517 }
518 }
519
520 public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
521 int start, int end) throws SystemException {
522 Session session = null;
523
524 try {
525 session = openSession();
526
527 dynamicQuery.setLimit(start, end);
528
529 dynamicQuery.compile(session);
530
531 return dynamicQuery.list();
532 }
533 catch (Exception e) {
534 throw processException(e);
535 }
536 finally {
537 closeSession(session);
538 }
539 }
540
541 public List<PasswordTracker> findAll() throws SystemException {
542 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
543 }
544
545 public List<PasswordTracker> findAll(int start, int end)
546 throws SystemException {
547 return findAll(start, end, null);
548 }
549
550 public List<PasswordTracker> findAll(int start, int end,
551 OrderByComparator obc) throws SystemException {
552 boolean finderClassNameCacheEnabled = PasswordTrackerModelImpl.CACHE_ENABLED;
553 String finderClassName = PasswordTracker.class.getName();
554 String finderMethodName = "findAll";
555 String[] finderParams = new String[] {
556 "java.lang.Integer", "java.lang.Integer",
557 "com.liferay.portal.kernel.util.OrderByComparator"
558 };
559 Object[] finderArgs = new Object[] {
560 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
561 };
562
563 Object result = null;
564
565 if (finderClassNameCacheEnabled) {
566 result = FinderCacheUtil.getResult(finderClassName,
567 finderMethodName, finderParams, finderArgs, this);
568 }
569
570 if (result == null) {
571 Session session = null;
572
573 try {
574 session = openSession();
575
576 StringBuilder query = new StringBuilder();
577
578 query.append("FROM com.liferay.portal.model.PasswordTracker ");
579
580 if (obc != null) {
581 query.append("ORDER BY ");
582 query.append(obc.getOrderBy());
583 }
584
585 else {
586 query.append("ORDER BY ");
587
588 query.append("userId DESC, ");
589 query.append("createDate DESC");
590 }
591
592 Query q = session.createQuery(query.toString());
593
594 List<PasswordTracker> list = null;
595
596 if (obc == null) {
597 list = (List<PasswordTracker>)QueryUtil.list(q,
598 getDialect(), start, end, false);
599
600 Collections.sort(list);
601 }
602 else {
603 list = (List<PasswordTracker>)QueryUtil.list(q,
604 getDialect(), start, end);
605 }
606
607 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
608 finderClassName, finderMethodName, finderParams,
609 finderArgs, list);
610
611 return list;
612 }
613 catch (Exception e) {
614 throw processException(e);
615 }
616 finally {
617 closeSession(session);
618 }
619 }
620 else {
621 return (List<PasswordTracker>)result;
622 }
623 }
624
625 public void removeByUserId(long userId) throws SystemException {
626 for (PasswordTracker passwordTracker : findByUserId(userId)) {
627 remove(passwordTracker);
628 }
629 }
630
631 public void removeAll() throws SystemException {
632 for (PasswordTracker passwordTracker : findAll()) {
633 remove(passwordTracker);
634 }
635 }
636
637 public int countByUserId(long userId) throws SystemException {
638 boolean finderClassNameCacheEnabled = PasswordTrackerModelImpl.CACHE_ENABLED;
639 String finderClassName = PasswordTracker.class.getName();
640 String finderMethodName = "countByUserId";
641 String[] finderParams = new String[] { Long.class.getName() };
642 Object[] finderArgs = new Object[] { new Long(userId) };
643
644 Object result = null;
645
646 if (finderClassNameCacheEnabled) {
647 result = FinderCacheUtil.getResult(finderClassName,
648 finderMethodName, finderParams, finderArgs, this);
649 }
650
651 if (result == null) {
652 Session session = null;
653
654 try {
655 session = openSession();
656
657 StringBuilder query = new StringBuilder();
658
659 query.append("SELECT COUNT(*) ");
660 query.append(
661 "FROM com.liferay.portal.model.PasswordTracker WHERE ");
662
663 query.append("userId = ?");
664
665 query.append(" ");
666
667 Query q = session.createQuery(query.toString());
668
669 QueryPos qPos = QueryPos.getInstance(q);
670
671 qPos.add(userId);
672
673 Long count = null;
674
675 Iterator<Long> itr = q.list().iterator();
676
677 if (itr.hasNext()) {
678 count = itr.next();
679 }
680
681 if (count == null) {
682 count = new Long(0);
683 }
684
685 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
686 finderClassName, finderMethodName, finderParams,
687 finderArgs, count);
688
689 return count.intValue();
690 }
691 catch (Exception e) {
692 throw processException(e);
693 }
694 finally {
695 closeSession(session);
696 }
697 }
698 else {
699 return ((Long)result).intValue();
700 }
701 }
702
703 public int countAll() throws SystemException {
704 boolean finderClassNameCacheEnabled = PasswordTrackerModelImpl.CACHE_ENABLED;
705 String finderClassName = PasswordTracker.class.getName();
706 String finderMethodName = "countAll";
707 String[] finderParams = new String[] { };
708 Object[] finderArgs = new Object[] { };
709
710 Object result = null;
711
712 if (finderClassNameCacheEnabled) {
713 result = FinderCacheUtil.getResult(finderClassName,
714 finderMethodName, finderParams, finderArgs, this);
715 }
716
717 if (result == null) {
718 Session session = null;
719
720 try {
721 session = openSession();
722
723 Query q = session.createQuery(
724 "SELECT COUNT(*) FROM com.liferay.portal.model.PasswordTracker");
725
726 Long count = null;
727
728 Iterator<Long> itr = q.list().iterator();
729
730 if (itr.hasNext()) {
731 count = itr.next();
732 }
733
734 if (count == null) {
735 count = new Long(0);
736 }
737
738 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
739 finderClassName, finderMethodName, finderParams,
740 finderArgs, count);
741
742 return count.intValue();
743 }
744 catch (Exception e) {
745 throw processException(e);
746 }
747 finally {
748 closeSession(session);
749 }
750 }
751 else {
752 return ((Long)result).intValue();
753 }
754 }
755
756 public void afterPropertiesSet() {
757 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
758 com.liferay.portal.util.PropsUtil.get(
759 "value.object.listener.com.liferay.portal.model.PasswordTracker")));
760
761 if (listenerClassNames.length > 0) {
762 try {
763 List<ModelListener> listenersList = new ArrayList<ModelListener>();
764
765 for (String listenerClassName : listenerClassNames) {
766 listenersList.add((ModelListener)Class.forName(
767 listenerClassName).newInstance());
768 }
769
770 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
771 }
772 catch (Exception e) {
773 _log.error(e);
774 }
775 }
776 }
777
778 private static Log _log = LogFactoryUtil.getLog(PasswordTrackerPersistenceImpl.class);
779 }