1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
12   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
14   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
15   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
16   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17   * SOFTWARE.
18   */
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  /**
48   * <a href="PasswordTrackerPersistenceImpl.java.html"><b><i>View Source</i></b></a>
49   *
50   * @author Brian Wing Shun Chan
51   *
52   */
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     /**
146      * @deprecated Use <code>update(PasswordTracker passwordTracker, boolean merge)</code>.
147      */
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     /**
159      * Add, update, or merge, the entity. This method also calls the model
160      * listeners to trigger the proper events associated with adding, deleting,
161      * or updating an entity.
162      *
163      * @param        passwordTracker the entity to add, update, or merge
164      * @param        merge boolean value for whether to merge the entity. The
165      *                default value is false. Setting merge to true is more
166      *                expensive and should only be true when passwordTracker is
167      *                transient. See LEP-5473 for a detailed discussion of this
168      *                method.
169      * @return        true if the portlet can be displayed via Ajax
170      */
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 }