1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portlet.tasks.service.persistence;
24  
25  import com.liferay.portal.SystemException;
26  import com.liferay.portal.kernel.bean.InitializingBean;
27  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
28  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
29  import com.liferay.portal.kernel.dao.orm.Query;
30  import com.liferay.portal.kernel.dao.orm.QueryPos;
31  import com.liferay.portal.kernel.dao.orm.QueryUtil;
32  import com.liferay.portal.kernel.dao.orm.Session;
33  import com.liferay.portal.kernel.util.GetterUtil;
34  import com.liferay.portal.kernel.util.ListUtil;
35  import com.liferay.portal.kernel.util.OrderByComparator;
36  import com.liferay.portal.kernel.util.StringPool;
37  import com.liferay.portal.kernel.util.StringUtil;
38  import com.liferay.portal.model.ModelListener;
39  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
40  
41  import com.liferay.portlet.tasks.NoSuchReviewException;
42  import com.liferay.portlet.tasks.model.TasksReview;
43  import com.liferay.portlet.tasks.model.impl.TasksReviewImpl;
44  import com.liferay.portlet.tasks.model.impl.TasksReviewModelImpl;
45  
46  import org.apache.commons.logging.Log;
47  import org.apache.commons.logging.LogFactory;
48  
49  import java.util.ArrayList;
50  import java.util.Collections;
51  import java.util.Iterator;
52  import java.util.List;
53  
54  /**
55   * <a href="TasksReviewPersistenceImpl.java.html"><b><i>View Source</i></b></a>
56   *
57   * @author Brian Wing Shun Chan
58   *
59   */
60  public class TasksReviewPersistenceImpl extends BasePersistenceImpl
61      implements TasksReviewPersistence, InitializingBean {
62      public TasksReview create(long reviewId) {
63          TasksReview tasksReview = new TasksReviewImpl();
64  
65          tasksReview.setNew(true);
66          tasksReview.setPrimaryKey(reviewId);
67  
68          return tasksReview;
69      }
70  
71      public TasksReview remove(long reviewId)
72          throws NoSuchReviewException, SystemException {
73          Session session = null;
74  
75          try {
76              session = openSession();
77  
78              TasksReview tasksReview = (TasksReview)session.get(TasksReviewImpl.class,
79                      new Long(reviewId));
80  
81              if (tasksReview == null) {
82                  if (_log.isWarnEnabled()) {
83                      _log.warn("No TasksReview exists with the primary key " +
84                          reviewId);
85                  }
86  
87                  throw new NoSuchReviewException(
88                      "No TasksReview exists with the primary key " + reviewId);
89              }
90  
91              return remove(tasksReview);
92          }
93          catch (NoSuchReviewException nsee) {
94              throw nsee;
95          }
96          catch (Exception e) {
97              throw processException(e);
98          }
99          finally {
100             closeSession(session);
101         }
102     }
103 
104     public TasksReview remove(TasksReview tasksReview)
105         throws SystemException {
106         if (_listeners.length > 0) {
107             for (ModelListener listener : _listeners) {
108                 listener.onBeforeRemove(tasksReview);
109             }
110         }
111 
112         tasksReview = removeImpl(tasksReview);
113 
114         if (_listeners.length > 0) {
115             for (ModelListener listener : _listeners) {
116                 listener.onAfterRemove(tasksReview);
117             }
118         }
119 
120         return tasksReview;
121     }
122 
123     protected TasksReview removeImpl(TasksReview tasksReview)
124         throws SystemException {
125         Session session = null;
126 
127         try {
128             session = openSession();
129 
130             session.delete(tasksReview);
131 
132             session.flush();
133 
134             return tasksReview;
135         }
136         catch (Exception e) {
137             throw processException(e);
138         }
139         finally {
140             closeSession(session);
141 
142             FinderCacheUtil.clearCache(TasksReview.class.getName());
143         }
144     }
145 
146     /**
147      * @deprecated Use <code>update(TasksReview tasksReview, boolean merge)</code>.
148      */
149     public TasksReview update(TasksReview tasksReview)
150         throws SystemException {
151         if (_log.isWarnEnabled()) {
152             _log.warn(
153                 "Using the deprecated update(TasksReview tasksReview) method. Use update(TasksReview tasksReview, boolean merge) instead.");
154         }
155 
156         return update(tasksReview, false);
157     }
158 
159     /**
160      * Add, update, or merge, the entity. This method also calls the model
161      * listeners to trigger the proper events associated with adding, deleting,
162      * or updating an entity.
163      *
164      * @param        tasksReview the entity to add, update, or merge
165      * @param        merge boolean value for whether to merge the entity. The
166      *                default value is false. Setting merge to true is more
167      *                expensive and should only be true when tasksReview is
168      *                transient. See LEP-5473 for a detailed discussion of this
169      *                method.
170      * @return        true if the portlet can be displayed via Ajax
171      */
172     public TasksReview update(TasksReview tasksReview, boolean merge)
173         throws SystemException {
174         boolean isNew = tasksReview.isNew();
175 
176         if (_listeners.length > 0) {
177             for (ModelListener listener : _listeners) {
178                 if (isNew) {
179                     listener.onBeforeCreate(tasksReview);
180                 }
181                 else {
182                     listener.onBeforeUpdate(tasksReview);
183                 }
184             }
185         }
186 
187         tasksReview = updateImpl(tasksReview, merge);
188 
189         if (_listeners.length > 0) {
190             for (ModelListener listener : _listeners) {
191                 if (isNew) {
192                     listener.onAfterCreate(tasksReview);
193                 }
194                 else {
195                     listener.onAfterUpdate(tasksReview);
196                 }
197             }
198         }
199 
200         return tasksReview;
201     }
202 
203     public TasksReview updateImpl(
204         com.liferay.portlet.tasks.model.TasksReview tasksReview, boolean merge)
205         throws SystemException {
206         Session session = null;
207 
208         try {
209             session = openSession();
210 
211             if (merge) {
212                 session.merge(tasksReview);
213             }
214             else {
215                 if (tasksReview.isNew()) {
216                     session.save(tasksReview);
217                 }
218             }
219 
220             session.flush();
221 
222             tasksReview.setNew(false);
223 
224             return tasksReview;
225         }
226         catch (Exception e) {
227             throw processException(e);
228         }
229         finally {
230             closeSession(session);
231 
232             FinderCacheUtil.clearCache(TasksReview.class.getName());
233         }
234     }
235 
236     public TasksReview findByPrimaryKey(long reviewId)
237         throws NoSuchReviewException, SystemException {
238         TasksReview tasksReview = fetchByPrimaryKey(reviewId);
239 
240         if (tasksReview == null) {
241             if (_log.isWarnEnabled()) {
242                 _log.warn("No TasksReview exists with the primary key " +
243                     reviewId);
244             }
245 
246             throw new NoSuchReviewException(
247                 "No TasksReview exists with the primary key " + reviewId);
248         }
249 
250         return tasksReview;
251     }
252 
253     public TasksReview fetchByPrimaryKey(long reviewId)
254         throws SystemException {
255         Session session = null;
256 
257         try {
258             session = openSession();
259 
260             return (TasksReview)session.get(TasksReviewImpl.class,
261                 new Long(reviewId));
262         }
263         catch (Exception e) {
264             throw processException(e);
265         }
266         finally {
267             closeSession(session);
268         }
269     }
270 
271     public List<TasksReview> findByUserId(long userId)
272         throws SystemException {
273         boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
274         String finderClassName = TasksReview.class.getName();
275         String finderMethodName = "findByUserId";
276         String[] finderParams = new String[] { Long.class.getName() };
277         Object[] finderArgs = new Object[] { new Long(userId) };
278 
279         Object result = null;
280 
281         if (finderClassNameCacheEnabled) {
282             result = FinderCacheUtil.getResult(finderClassName,
283                     finderMethodName, finderParams, finderArgs, this);
284         }
285 
286         if (result == null) {
287             Session session = null;
288 
289             try {
290                 session = openSession();
291 
292                 StringBuilder query = new StringBuilder();
293 
294                 query.append(
295                     "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
296 
297                 query.append("userId = ?");
298 
299                 query.append(" ");
300 
301                 query.append("ORDER BY ");
302 
303                 query.append("createDate ASC");
304 
305                 Query q = session.createQuery(query.toString());
306 
307                 QueryPos qPos = QueryPos.getInstance(q);
308 
309                 qPos.add(userId);
310 
311                 List<TasksReview> list = q.list();
312 
313                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
314                     finderClassName, finderMethodName, finderParams,
315                     finderArgs, list);
316 
317                 return list;
318             }
319             catch (Exception e) {
320                 throw processException(e);
321             }
322             finally {
323                 closeSession(session);
324             }
325         }
326         else {
327             return (List<TasksReview>)result;
328         }
329     }
330 
331     public List<TasksReview> findByUserId(long userId, int start, int end)
332         throws SystemException {
333         return findByUserId(userId, start, end, null);
334     }
335 
336     public List<TasksReview> findByUserId(long userId, int start, int end,
337         OrderByComparator obc) throws SystemException {
338         boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
339         String finderClassName = TasksReview.class.getName();
340         String finderMethodName = "findByUserId";
341         String[] finderParams = new String[] {
342                 Long.class.getName(),
343                 
344                 "java.lang.Integer", "java.lang.Integer",
345                 "com.liferay.portal.kernel.util.OrderByComparator"
346             };
347         Object[] finderArgs = new Object[] {
348                 new Long(userId),
349                 
350                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
351             };
352 
353         Object result = null;
354 
355         if (finderClassNameCacheEnabled) {
356             result = FinderCacheUtil.getResult(finderClassName,
357                     finderMethodName, finderParams, finderArgs, this);
358         }
359 
360         if (result == null) {
361             Session session = null;
362 
363             try {
364                 session = openSession();
365 
366                 StringBuilder query = new StringBuilder();
367 
368                 query.append(
369                     "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
370 
371                 query.append("userId = ?");
372 
373                 query.append(" ");
374 
375                 if (obc != null) {
376                     query.append("ORDER BY ");
377                     query.append(obc.getOrderBy());
378                 }
379 
380                 else {
381                     query.append("ORDER BY ");
382 
383                     query.append("createDate ASC");
384                 }
385 
386                 Query q = session.createQuery(query.toString());
387 
388                 QueryPos qPos = QueryPos.getInstance(q);
389 
390                 qPos.add(userId);
391 
392                 List<TasksReview> list = (List<TasksReview>)QueryUtil.list(q,
393                         getDialect(), start, end);
394 
395                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
396                     finderClassName, finderMethodName, finderParams,
397                     finderArgs, list);
398 
399                 return list;
400             }
401             catch (Exception e) {
402                 throw processException(e);
403             }
404             finally {
405                 closeSession(session);
406             }
407         }
408         else {
409             return (List<TasksReview>)result;
410         }
411     }
412 
413     public TasksReview findByUserId_First(long userId, OrderByComparator obc)
414         throws NoSuchReviewException, SystemException {
415         List<TasksReview> list = findByUserId(userId, 0, 1, obc);
416 
417         if (list.size() == 0) {
418             StringBuilder msg = new StringBuilder();
419 
420             msg.append("No TasksReview exists with the key {");
421 
422             msg.append("userId=" + userId);
423 
424             msg.append(StringPool.CLOSE_CURLY_BRACE);
425 
426             throw new NoSuchReviewException(msg.toString());
427         }
428         else {
429             return list.get(0);
430         }
431     }
432 
433     public TasksReview findByUserId_Last(long userId, OrderByComparator obc)
434         throws NoSuchReviewException, SystemException {
435         int count = countByUserId(userId);
436 
437         List<TasksReview> list = findByUserId(userId, count - 1, count, obc);
438 
439         if (list.size() == 0) {
440             StringBuilder msg = new StringBuilder();
441 
442             msg.append("No TasksReview exists with the key {");
443 
444             msg.append("userId=" + userId);
445 
446             msg.append(StringPool.CLOSE_CURLY_BRACE);
447 
448             throw new NoSuchReviewException(msg.toString());
449         }
450         else {
451             return list.get(0);
452         }
453     }
454 
455     public TasksReview[] findByUserId_PrevAndNext(long reviewId, long userId,
456         OrderByComparator obc) throws NoSuchReviewException, SystemException {
457         TasksReview tasksReview = findByPrimaryKey(reviewId);
458 
459         int count = countByUserId(userId);
460 
461         Session session = null;
462 
463         try {
464             session = openSession();
465 
466             StringBuilder query = new StringBuilder();
467 
468             query.append(
469                 "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
470 
471             query.append("userId = ?");
472 
473             query.append(" ");
474 
475             if (obc != null) {
476                 query.append("ORDER BY ");
477                 query.append(obc.getOrderBy());
478             }
479 
480             else {
481                 query.append("ORDER BY ");
482 
483                 query.append("createDate ASC");
484             }
485 
486             Query q = session.createQuery(query.toString());
487 
488             QueryPos qPos = QueryPos.getInstance(q);
489 
490             qPos.add(userId);
491 
492             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
493                     tasksReview);
494 
495             TasksReview[] array = new TasksReviewImpl[3];
496 
497             array[0] = (TasksReview)objArray[0];
498             array[1] = (TasksReview)objArray[1];
499             array[2] = (TasksReview)objArray[2];
500 
501             return array;
502         }
503         catch (Exception e) {
504             throw processException(e);
505         }
506         finally {
507             closeSession(session);
508         }
509     }
510 
511     public List<TasksReview> findByProposalId(long proposalId)
512         throws SystemException {
513         boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
514         String finderClassName = TasksReview.class.getName();
515         String finderMethodName = "findByProposalId";
516         String[] finderParams = new String[] { Long.class.getName() };
517         Object[] finderArgs = new Object[] { new Long(proposalId) };
518 
519         Object result = null;
520 
521         if (finderClassNameCacheEnabled) {
522             result = FinderCacheUtil.getResult(finderClassName,
523                     finderMethodName, finderParams, finderArgs, this);
524         }
525 
526         if (result == null) {
527             Session session = null;
528 
529             try {
530                 session = openSession();
531 
532                 StringBuilder query = new StringBuilder();
533 
534                 query.append(
535                     "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
536 
537                 query.append("proposalId = ?");
538 
539                 query.append(" ");
540 
541                 query.append("ORDER BY ");
542 
543                 query.append("createDate ASC");
544 
545                 Query q = session.createQuery(query.toString());
546 
547                 QueryPos qPos = QueryPos.getInstance(q);
548 
549                 qPos.add(proposalId);
550 
551                 List<TasksReview> list = q.list();
552 
553                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
554                     finderClassName, finderMethodName, finderParams,
555                     finderArgs, list);
556 
557                 return list;
558             }
559             catch (Exception e) {
560                 throw processException(e);
561             }
562             finally {
563                 closeSession(session);
564             }
565         }
566         else {
567             return (List<TasksReview>)result;
568         }
569     }
570 
571     public List<TasksReview> findByProposalId(long proposalId, int start,
572         int end) throws SystemException {
573         return findByProposalId(proposalId, start, end, null);
574     }
575 
576     public List<TasksReview> findByProposalId(long proposalId, int start,
577         int end, OrderByComparator obc) throws SystemException {
578         boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
579         String finderClassName = TasksReview.class.getName();
580         String finderMethodName = "findByProposalId";
581         String[] finderParams = new String[] {
582                 Long.class.getName(),
583                 
584                 "java.lang.Integer", "java.lang.Integer",
585                 "com.liferay.portal.kernel.util.OrderByComparator"
586             };
587         Object[] finderArgs = new Object[] {
588                 new Long(proposalId),
589                 
590                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
591             };
592 
593         Object result = null;
594 
595         if (finderClassNameCacheEnabled) {
596             result = FinderCacheUtil.getResult(finderClassName,
597                     finderMethodName, finderParams, finderArgs, this);
598         }
599 
600         if (result == null) {
601             Session session = null;
602 
603             try {
604                 session = openSession();
605 
606                 StringBuilder query = new StringBuilder();
607 
608                 query.append(
609                     "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
610 
611                 query.append("proposalId = ?");
612 
613                 query.append(" ");
614 
615                 if (obc != null) {
616                     query.append("ORDER BY ");
617                     query.append(obc.getOrderBy());
618                 }
619 
620                 else {
621                     query.append("ORDER BY ");
622 
623                     query.append("createDate ASC");
624                 }
625 
626                 Query q = session.createQuery(query.toString());
627 
628                 QueryPos qPos = QueryPos.getInstance(q);
629 
630                 qPos.add(proposalId);
631 
632                 List<TasksReview> list = (List<TasksReview>)QueryUtil.list(q,
633                         getDialect(), start, end);
634 
635                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
636                     finderClassName, finderMethodName, finderParams,
637                     finderArgs, list);
638 
639                 return list;
640             }
641             catch (Exception e) {
642                 throw processException(e);
643             }
644             finally {
645                 closeSession(session);
646             }
647         }
648         else {
649             return (List<TasksReview>)result;
650         }
651     }
652 
653     public TasksReview findByProposalId_First(long proposalId,
654         OrderByComparator obc) throws NoSuchReviewException, SystemException {
655         List<TasksReview> list = findByProposalId(proposalId, 0, 1, obc);
656 
657         if (list.size() == 0) {
658             StringBuilder msg = new StringBuilder();
659 
660             msg.append("No TasksReview exists with the key {");
661 
662             msg.append("proposalId=" + proposalId);
663 
664             msg.append(StringPool.CLOSE_CURLY_BRACE);
665 
666             throw new NoSuchReviewException(msg.toString());
667         }
668         else {
669             return list.get(0);
670         }
671     }
672 
673     public TasksReview findByProposalId_Last(long proposalId,
674         OrderByComparator obc) throws NoSuchReviewException, SystemException {
675         int count = countByProposalId(proposalId);
676 
677         List<TasksReview> list = findByProposalId(proposalId, count - 1, count,
678                 obc);
679 
680         if (list.size() == 0) {
681             StringBuilder msg = new StringBuilder();
682 
683             msg.append("No TasksReview exists with the key {");
684 
685             msg.append("proposalId=" + proposalId);
686 
687             msg.append(StringPool.CLOSE_CURLY_BRACE);
688 
689             throw new NoSuchReviewException(msg.toString());
690         }
691         else {
692             return list.get(0);
693         }
694     }
695 
696     public TasksReview[] findByProposalId_PrevAndNext(long reviewId,
697         long proposalId, OrderByComparator obc)
698         throws NoSuchReviewException, SystemException {
699         TasksReview tasksReview = findByPrimaryKey(reviewId);
700 
701         int count = countByProposalId(proposalId);
702 
703         Session session = null;
704 
705         try {
706             session = openSession();
707 
708             StringBuilder query = new StringBuilder();
709 
710             query.append(
711                 "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
712 
713             query.append("proposalId = ?");
714 
715             query.append(" ");
716 
717             if (obc != null) {
718                 query.append("ORDER BY ");
719                 query.append(obc.getOrderBy());
720             }
721 
722             else {
723                 query.append("ORDER BY ");
724 
725                 query.append("createDate ASC");
726             }
727 
728             Query q = session.createQuery(query.toString());
729 
730             QueryPos qPos = QueryPos.getInstance(q);
731 
732             qPos.add(proposalId);
733 
734             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
735                     tasksReview);
736 
737             TasksReview[] array = new TasksReviewImpl[3];
738 
739             array[0] = (TasksReview)objArray[0];
740             array[1] = (TasksReview)objArray[1];
741             array[2] = (TasksReview)objArray[2];
742 
743             return array;
744         }
745         catch (Exception e) {
746             throw processException(e);
747         }
748         finally {
749             closeSession(session);
750         }
751     }
752 
753     public TasksReview findByU_P(long userId, long proposalId)
754         throws NoSuchReviewException, SystemException {
755         TasksReview tasksReview = fetchByU_P(userId, proposalId);
756 
757         if (tasksReview == null) {
758             StringBuilder msg = new StringBuilder();
759 
760             msg.append("No TasksReview exists with the key {");
761 
762             msg.append("userId=" + userId);
763 
764             msg.append(", ");
765             msg.append("proposalId=" + proposalId);
766 
767             msg.append(StringPool.CLOSE_CURLY_BRACE);
768 
769             if (_log.isWarnEnabled()) {
770                 _log.warn(msg.toString());
771             }
772 
773             throw new NoSuchReviewException(msg.toString());
774         }
775 
776         return tasksReview;
777     }
778 
779     public TasksReview fetchByU_P(long userId, long proposalId)
780         throws SystemException {
781         boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
782         String finderClassName = TasksReview.class.getName();
783         String finderMethodName = "fetchByU_P";
784         String[] finderParams = new String[] {
785                 Long.class.getName(), Long.class.getName()
786             };
787         Object[] finderArgs = new Object[] {
788                 new Long(userId), new Long(proposalId)
789             };
790 
791         Object result = null;
792 
793         if (finderClassNameCacheEnabled) {
794             result = FinderCacheUtil.getResult(finderClassName,
795                     finderMethodName, finderParams, finderArgs, this);
796         }
797 
798         if (result == null) {
799             Session session = null;
800 
801             try {
802                 session = openSession();
803 
804                 StringBuilder query = new StringBuilder();
805 
806                 query.append(
807                     "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
808 
809                 query.append("userId = ?");
810 
811                 query.append(" AND ");
812 
813                 query.append("proposalId = ?");
814 
815                 query.append(" ");
816 
817                 query.append("ORDER BY ");
818 
819                 query.append("createDate ASC");
820 
821                 Query q = session.createQuery(query.toString());
822 
823                 QueryPos qPos = QueryPos.getInstance(q);
824 
825                 qPos.add(userId);
826 
827                 qPos.add(proposalId);
828 
829                 List<TasksReview> list = q.list();
830 
831                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
832                     finderClassName, finderMethodName, finderParams,
833                     finderArgs, list);
834 
835                 if (list.size() == 0) {
836                     return null;
837                 }
838                 else {
839                     return list.get(0);
840                 }
841             }
842             catch (Exception e) {
843                 throw processException(e);
844             }
845             finally {
846                 closeSession(session);
847             }
848         }
849         else {
850             List<TasksReview> list = (List<TasksReview>)result;
851 
852             if (list.size() == 0) {
853                 return null;
854             }
855             else {
856                 return list.get(0);
857             }
858         }
859     }
860 
861     public List<TasksReview> findByP_S(long proposalId, int stage)
862         throws SystemException {
863         boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
864         String finderClassName = TasksReview.class.getName();
865         String finderMethodName = "findByP_S";
866         String[] finderParams = new String[] {
867                 Long.class.getName(), Integer.class.getName()
868             };
869         Object[] finderArgs = new Object[] {
870                 new Long(proposalId), new Integer(stage)
871             };
872 
873         Object result = null;
874 
875         if (finderClassNameCacheEnabled) {
876             result = FinderCacheUtil.getResult(finderClassName,
877                     finderMethodName, finderParams, finderArgs, this);
878         }
879 
880         if (result == null) {
881             Session session = null;
882 
883             try {
884                 session = openSession();
885 
886                 StringBuilder query = new StringBuilder();
887 
888                 query.append(
889                     "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
890 
891                 query.append("proposalId = ?");
892 
893                 query.append(" AND ");
894 
895                 query.append("stage = ?");
896 
897                 query.append(" ");
898 
899                 query.append("ORDER BY ");
900 
901                 query.append("createDate ASC");
902 
903                 Query q = session.createQuery(query.toString());
904 
905                 QueryPos qPos = QueryPos.getInstance(q);
906 
907                 qPos.add(proposalId);
908 
909                 qPos.add(stage);
910 
911                 List<TasksReview> list = q.list();
912 
913                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
914                     finderClassName, finderMethodName, finderParams,
915                     finderArgs, list);
916 
917                 return list;
918             }
919             catch (Exception e) {
920                 throw processException(e);
921             }
922             finally {
923                 closeSession(session);
924             }
925         }
926         else {
927             return (List<TasksReview>)result;
928         }
929     }
930 
931     public List<TasksReview> findByP_S(long proposalId, int stage, int start,
932         int end) throws SystemException {
933         return findByP_S(proposalId, stage, start, end, null);
934     }
935 
936     public List<TasksReview> findByP_S(long proposalId, int stage, int start,
937         int end, OrderByComparator obc) throws SystemException {
938         boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
939         String finderClassName = TasksReview.class.getName();
940         String finderMethodName = "findByP_S";
941         String[] finderParams = new String[] {
942                 Long.class.getName(), Integer.class.getName(),
943                 
944                 "java.lang.Integer", "java.lang.Integer",
945                 "com.liferay.portal.kernel.util.OrderByComparator"
946             };
947         Object[] finderArgs = new Object[] {
948                 new Long(proposalId), new Integer(stage),
949                 
950                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
951             };
952 
953         Object result = null;
954 
955         if (finderClassNameCacheEnabled) {
956             result = FinderCacheUtil.getResult(finderClassName,
957                     finderMethodName, finderParams, finderArgs, this);
958         }
959 
960         if (result == null) {
961             Session session = null;
962 
963             try {
964                 session = openSession();
965 
966                 StringBuilder query = new StringBuilder();
967 
968                 query.append(
969                     "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
970 
971                 query.append("proposalId = ?");
972 
973                 query.append(" AND ");
974 
975                 query.append("stage = ?");
976 
977                 query.append(" ");
978 
979                 if (obc != null) {
980                     query.append("ORDER BY ");
981                     query.append(obc.getOrderBy());
982                 }
983 
984                 else {
985                     query.append("ORDER BY ");
986 
987                     query.append("createDate ASC");
988                 }
989 
990                 Query q = session.createQuery(query.toString());
991 
992                 QueryPos qPos = QueryPos.getInstance(q);
993 
994                 qPos.add(proposalId);
995 
996                 qPos.add(stage);
997 
998                 List<TasksReview> list = (List<TasksReview>)QueryUtil.list(q,
999                         getDialect(), start, end);
1000
1001                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1002                    finderClassName, finderMethodName, finderParams,
1003                    finderArgs, list);
1004
1005                return list;
1006            }
1007            catch (Exception e) {
1008                throw processException(e);
1009            }
1010            finally {
1011                closeSession(session);
1012            }
1013        }
1014        else {
1015            return (List<TasksReview>)result;
1016        }
1017    }
1018
1019    public TasksReview findByP_S_First(long proposalId, int stage,
1020        OrderByComparator obc) throws NoSuchReviewException, SystemException {
1021        List<TasksReview> list = findByP_S(proposalId, stage, 0, 1, obc);
1022
1023        if (list.size() == 0) {
1024            StringBuilder msg = new StringBuilder();
1025
1026            msg.append("No TasksReview exists with the key {");
1027
1028            msg.append("proposalId=" + proposalId);
1029
1030            msg.append(", ");
1031            msg.append("stage=" + stage);
1032
1033            msg.append(StringPool.CLOSE_CURLY_BRACE);
1034
1035            throw new NoSuchReviewException(msg.toString());
1036        }
1037        else {
1038            return list.get(0);
1039        }
1040    }
1041
1042    public TasksReview findByP_S_Last(long proposalId, int stage,
1043        OrderByComparator obc) throws NoSuchReviewException, SystemException {
1044        int count = countByP_S(proposalId, stage);
1045
1046        List<TasksReview> list = findByP_S(proposalId, stage, count - 1, count,
1047                obc);
1048
1049        if (list.size() == 0) {
1050            StringBuilder msg = new StringBuilder();
1051
1052            msg.append("No TasksReview exists with the key {");
1053
1054            msg.append("proposalId=" + proposalId);
1055
1056            msg.append(", ");
1057            msg.append("stage=" + stage);
1058
1059            msg.append(StringPool.CLOSE_CURLY_BRACE);
1060
1061            throw new NoSuchReviewException(msg.toString());
1062        }
1063        else {
1064            return list.get(0);
1065        }
1066    }
1067
1068    public TasksReview[] findByP_S_PrevAndNext(long reviewId, long proposalId,
1069        int stage, OrderByComparator obc)
1070        throws NoSuchReviewException, SystemException {
1071        TasksReview tasksReview = findByPrimaryKey(reviewId);
1072
1073        int count = countByP_S(proposalId, stage);
1074
1075        Session session = null;
1076
1077        try {
1078            session = openSession();
1079
1080            StringBuilder query = new StringBuilder();
1081
1082            query.append(
1083                "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
1084
1085            query.append("proposalId = ?");
1086
1087            query.append(" AND ");
1088
1089            query.append("stage = ?");
1090
1091            query.append(" ");
1092
1093            if (obc != null) {
1094                query.append("ORDER BY ");
1095                query.append(obc.getOrderBy());
1096            }
1097
1098            else {
1099                query.append("ORDER BY ");
1100
1101                query.append("createDate ASC");
1102            }
1103
1104            Query q = session.createQuery(query.toString());
1105
1106            QueryPos qPos = QueryPos.getInstance(q);
1107
1108            qPos.add(proposalId);
1109
1110            qPos.add(stage);
1111
1112            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1113                    tasksReview);
1114
1115            TasksReview[] array = new TasksReviewImpl[3];
1116
1117            array[0] = (TasksReview)objArray[0];
1118            array[1] = (TasksReview)objArray[1];
1119            array[2] = (TasksReview)objArray[2];
1120
1121            return array;
1122        }
1123        catch (Exception e) {
1124            throw processException(e);
1125        }
1126        finally {
1127            closeSession(session);
1128        }
1129    }
1130
1131    public List<TasksReview> findByP_S_C(long proposalId, int stage,
1132        boolean completed) throws SystemException {
1133        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
1134        String finderClassName = TasksReview.class.getName();
1135        String finderMethodName = "findByP_S_C";
1136        String[] finderParams = new String[] {
1137                Long.class.getName(), Integer.class.getName(),
1138                Boolean.class.getName()
1139            };
1140        Object[] finderArgs = new Object[] {
1141                new Long(proposalId), new Integer(stage),
1142                Boolean.valueOf(completed)
1143            };
1144
1145        Object result = null;
1146
1147        if (finderClassNameCacheEnabled) {
1148            result = FinderCacheUtil.getResult(finderClassName,
1149                    finderMethodName, finderParams, finderArgs, this);
1150        }
1151
1152        if (result == null) {
1153            Session session = null;
1154
1155            try {
1156                session = openSession();
1157
1158                StringBuilder query = new StringBuilder();
1159
1160                query.append(
1161                    "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
1162
1163                query.append("proposalId = ?");
1164
1165                query.append(" AND ");
1166
1167                query.append("stage = ?");
1168
1169                query.append(" AND ");
1170
1171                query.append("completed = ?");
1172
1173                query.append(" ");
1174
1175                query.append("ORDER BY ");
1176
1177                query.append("createDate ASC");
1178
1179                Query q = session.createQuery(query.toString());
1180
1181                QueryPos qPos = QueryPos.getInstance(q);
1182
1183                qPos.add(proposalId);
1184
1185                qPos.add(stage);
1186
1187                qPos.add(completed);
1188
1189                List<TasksReview> list = q.list();
1190
1191                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1192                    finderClassName, finderMethodName, finderParams,
1193                    finderArgs, list);
1194
1195                return list;
1196            }
1197            catch (Exception e) {
1198                throw processException(e);
1199            }
1200            finally {
1201                closeSession(session);
1202            }
1203        }
1204        else {
1205            return (List<TasksReview>)result;
1206        }
1207    }
1208
1209    public List<TasksReview> findByP_S_C(long proposalId, int stage,
1210        boolean completed, int start, int end) throws SystemException {
1211        return findByP_S_C(proposalId, stage, completed, start, end, null);
1212    }
1213
1214    public List<TasksReview> findByP_S_C(long proposalId, int stage,
1215        boolean completed, int start, int end, OrderByComparator obc)
1216        throws SystemException {
1217        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
1218        String finderClassName = TasksReview.class.getName();
1219        String finderMethodName = "findByP_S_C";
1220        String[] finderParams = new String[] {
1221                Long.class.getName(), Integer.class.getName(),
1222                Boolean.class.getName(),
1223                
1224                "java.lang.Integer", "java.lang.Integer",
1225                "com.liferay.portal.kernel.util.OrderByComparator"
1226            };
1227        Object[] finderArgs = new Object[] {
1228                new Long(proposalId), new Integer(stage),
1229                Boolean.valueOf(completed),
1230                
1231                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1232            };
1233
1234        Object result = null;
1235
1236        if (finderClassNameCacheEnabled) {
1237            result = FinderCacheUtil.getResult(finderClassName,
1238                    finderMethodName, finderParams, finderArgs, this);
1239        }
1240
1241        if (result == null) {
1242            Session session = null;
1243
1244            try {
1245                session = openSession();
1246
1247                StringBuilder query = new StringBuilder();
1248
1249                query.append(
1250                    "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
1251
1252                query.append("proposalId = ?");
1253
1254                query.append(" AND ");
1255
1256                query.append("stage = ?");
1257
1258                query.append(" AND ");
1259
1260                query.append("completed = ?");
1261
1262                query.append(" ");
1263
1264                if (obc != null) {
1265                    query.append("ORDER BY ");
1266                    query.append(obc.getOrderBy());
1267                }
1268
1269                else {
1270                    query.append("ORDER BY ");
1271
1272                    query.append("createDate ASC");
1273                }
1274
1275                Query q = session.createQuery(query.toString());
1276
1277                QueryPos qPos = QueryPos.getInstance(q);
1278
1279                qPos.add(proposalId);
1280
1281                qPos.add(stage);
1282
1283                qPos.add(completed);
1284
1285                List<TasksReview> list = (List<TasksReview>)QueryUtil.list(q,
1286                        getDialect(), start, end);
1287
1288                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1289                    finderClassName, finderMethodName, finderParams,
1290                    finderArgs, list);
1291
1292                return list;
1293            }
1294            catch (Exception e) {
1295                throw processException(e);
1296            }
1297            finally {
1298                closeSession(session);
1299            }
1300        }
1301        else {
1302            return (List<TasksReview>)result;
1303        }
1304    }
1305
1306    public TasksReview findByP_S_C_First(long proposalId, int stage,
1307        boolean completed, OrderByComparator obc)
1308        throws NoSuchReviewException, SystemException {
1309        List<TasksReview> list = findByP_S_C(proposalId, stage, completed, 0,
1310                1, obc);
1311
1312        if (list.size() == 0) {
1313            StringBuilder msg = new StringBuilder();
1314
1315            msg.append("No TasksReview exists with the key {");
1316
1317            msg.append("proposalId=" + proposalId);
1318
1319            msg.append(", ");
1320            msg.append("stage=" + stage);
1321
1322            msg.append(", ");
1323            msg.append("completed=" + completed);
1324
1325            msg.append(StringPool.CLOSE_CURLY_BRACE);
1326
1327            throw new NoSuchReviewException(msg.toString());
1328        }
1329        else {
1330            return list.get(0);
1331        }
1332    }
1333
1334    public TasksReview findByP_S_C_Last(long proposalId, int stage,
1335        boolean completed, OrderByComparator obc)
1336        throws NoSuchReviewException, SystemException {
1337        int count = countByP_S_C(proposalId, stage, completed);
1338
1339        List<TasksReview> list = findByP_S_C(proposalId, stage, completed,
1340                count - 1, count, obc);
1341
1342        if (list.size() == 0) {
1343            StringBuilder msg = new StringBuilder();
1344
1345            msg.append("No TasksReview exists with the key {");
1346
1347            msg.append("proposalId=" + proposalId);
1348
1349            msg.append(", ");
1350            msg.append("stage=" + stage);
1351
1352            msg.append(", ");
1353            msg.append("completed=" + completed);
1354
1355            msg.append(StringPool.CLOSE_CURLY_BRACE);
1356
1357            throw new NoSuchReviewException(msg.toString());
1358        }
1359        else {
1360            return list.get(0);
1361        }
1362    }
1363
1364    public TasksReview[] findByP_S_C_PrevAndNext(long reviewId,
1365        long proposalId, int stage, boolean completed, OrderByComparator obc)
1366        throws NoSuchReviewException, SystemException {
1367        TasksReview tasksReview = findByPrimaryKey(reviewId);
1368
1369        int count = countByP_S_C(proposalId, stage, completed);
1370
1371        Session session = null;
1372
1373        try {
1374            session = openSession();
1375
1376            StringBuilder query = new StringBuilder();
1377
1378            query.append(
1379                "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
1380
1381            query.append("proposalId = ?");
1382
1383            query.append(" AND ");
1384
1385            query.append("stage = ?");
1386
1387            query.append(" AND ");
1388
1389            query.append("completed = ?");
1390
1391            query.append(" ");
1392
1393            if (obc != null) {
1394                query.append("ORDER BY ");
1395                query.append(obc.getOrderBy());
1396            }
1397
1398            else {
1399                query.append("ORDER BY ");
1400
1401                query.append("createDate ASC");
1402            }
1403
1404            Query q = session.createQuery(query.toString());
1405
1406            QueryPos qPos = QueryPos.getInstance(q);
1407
1408            qPos.add(proposalId);
1409
1410            qPos.add(stage);
1411
1412            qPos.add(completed);
1413
1414            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1415                    tasksReview);
1416
1417            TasksReview[] array = new TasksReviewImpl[3];
1418
1419            array[0] = (TasksReview)objArray[0];
1420            array[1] = (TasksReview)objArray[1];
1421            array[2] = (TasksReview)objArray[2];
1422
1423            return array;
1424        }
1425        catch (Exception e) {
1426            throw processException(e);
1427        }
1428        finally {
1429            closeSession(session);
1430        }
1431    }
1432
1433    public List<TasksReview> findByP_S_C_R(long proposalId, int stage,
1434        boolean completed, boolean rejected) throws SystemException {
1435        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
1436        String finderClassName = TasksReview.class.getName();
1437        String finderMethodName = "findByP_S_C_R";
1438        String[] finderParams = new String[] {
1439                Long.class.getName(), Integer.class.getName(),
1440                Boolean.class.getName(), Boolean.class.getName()
1441            };
1442        Object[] finderArgs = new Object[] {
1443                new Long(proposalId), new Integer(stage),
1444                Boolean.valueOf(completed), Boolean.valueOf(rejected)
1445            };
1446
1447        Object result = null;
1448
1449        if (finderClassNameCacheEnabled) {
1450            result = FinderCacheUtil.getResult(finderClassName,
1451                    finderMethodName, finderParams, finderArgs, this);
1452        }
1453
1454        if (result == null) {
1455            Session session = null;
1456
1457            try {
1458                session = openSession();
1459
1460                StringBuilder query = new StringBuilder();
1461
1462                query.append(
1463                    "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
1464
1465                query.append("proposalId = ?");
1466
1467                query.append(" AND ");
1468
1469                query.append("stage = ?");
1470
1471                query.append(" AND ");
1472
1473                query.append("completed = ?");
1474
1475                query.append(" AND ");
1476
1477                query.append("rejected = ?");
1478
1479                query.append(" ");
1480
1481                query.append("ORDER BY ");
1482
1483                query.append("createDate ASC");
1484
1485                Query q = session.createQuery(query.toString());
1486
1487                QueryPos qPos = QueryPos.getInstance(q);
1488
1489                qPos.add(proposalId);
1490
1491                qPos.add(stage);
1492
1493                qPos.add(completed);
1494
1495                qPos.add(rejected);
1496
1497                List<TasksReview> list = q.list();
1498
1499                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1500                    finderClassName, finderMethodName, finderParams,
1501                    finderArgs, list);
1502
1503                return list;
1504            }
1505            catch (Exception e) {
1506                throw processException(e);
1507            }
1508            finally {
1509                closeSession(session);
1510            }
1511        }
1512        else {
1513            return (List<TasksReview>)result;
1514        }
1515    }
1516
1517    public List<TasksReview> findByP_S_C_R(long proposalId, int stage,
1518        boolean completed, boolean rejected, int start, int end)
1519        throws SystemException {
1520        return findByP_S_C_R(proposalId, stage, completed, rejected, start,
1521            end, null);
1522    }
1523
1524    public List<TasksReview> findByP_S_C_R(long proposalId, int stage,
1525        boolean completed, boolean rejected, int start, int end,
1526        OrderByComparator obc) throws SystemException {
1527        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
1528        String finderClassName = TasksReview.class.getName();
1529        String finderMethodName = "findByP_S_C_R";
1530        String[] finderParams = new String[] {
1531                Long.class.getName(), Integer.class.getName(),
1532                Boolean.class.getName(), Boolean.class.getName(),
1533                
1534                "java.lang.Integer", "java.lang.Integer",
1535                "com.liferay.portal.kernel.util.OrderByComparator"
1536            };
1537        Object[] finderArgs = new Object[] {
1538                new Long(proposalId), new Integer(stage),
1539                Boolean.valueOf(completed), Boolean.valueOf(rejected),
1540                
1541                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1542            };
1543
1544        Object result = null;
1545
1546        if (finderClassNameCacheEnabled) {
1547            result = FinderCacheUtil.getResult(finderClassName,
1548                    finderMethodName, finderParams, finderArgs, this);
1549        }
1550
1551        if (result == null) {
1552            Session session = null;
1553
1554            try {
1555                session = openSession();
1556
1557                StringBuilder query = new StringBuilder();
1558
1559                query.append(
1560                    "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
1561
1562                query.append("proposalId = ?");
1563
1564                query.append(" AND ");
1565
1566                query.append("stage = ?");
1567
1568                query.append(" AND ");
1569
1570                query.append("completed = ?");
1571
1572                query.append(" AND ");
1573
1574                query.append("rejected = ?");
1575
1576                query.append(" ");
1577
1578                if (obc != null) {
1579                    query.append("ORDER BY ");
1580                    query.append(obc.getOrderBy());
1581                }
1582
1583                else {
1584                    query.append("ORDER BY ");
1585
1586                    query.append("createDate ASC");
1587                }
1588
1589                Query q = session.createQuery(query.toString());
1590
1591                QueryPos qPos = QueryPos.getInstance(q);
1592
1593                qPos.add(proposalId);
1594
1595                qPos.add(stage);
1596
1597                qPos.add(completed);
1598
1599                qPos.add(rejected);
1600
1601                List<TasksReview> list = (List<TasksReview>)QueryUtil.list(q,
1602                        getDialect(), start, end);
1603
1604                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1605                    finderClassName, finderMethodName, finderParams,
1606                    finderArgs, list);
1607
1608                return list;
1609            }
1610            catch (Exception e) {
1611                throw processException(e);
1612            }
1613            finally {
1614                closeSession(session);
1615            }
1616        }
1617        else {
1618            return (List<TasksReview>)result;
1619        }
1620    }
1621
1622    public TasksReview findByP_S_C_R_First(long proposalId, int stage,
1623        boolean completed, boolean rejected, OrderByComparator obc)
1624        throws NoSuchReviewException, SystemException {
1625        List<TasksReview> list = findByP_S_C_R(proposalId, stage, completed,
1626                rejected, 0, 1, obc);
1627
1628        if (list.size() == 0) {
1629            StringBuilder msg = new StringBuilder();
1630
1631            msg.append("No TasksReview exists with the key {");
1632
1633            msg.append("proposalId=" + proposalId);
1634
1635            msg.append(", ");
1636            msg.append("stage=" + stage);
1637
1638            msg.append(", ");
1639            msg.append("completed=" + completed);
1640
1641            msg.append(", ");
1642            msg.append("rejected=" + rejected);
1643
1644            msg.append(StringPool.CLOSE_CURLY_BRACE);
1645
1646            throw new NoSuchReviewException(msg.toString());
1647        }
1648        else {
1649            return list.get(0);
1650        }
1651    }
1652
1653    public TasksReview findByP_S_C_R_Last(long proposalId, int stage,
1654        boolean completed, boolean rejected, OrderByComparator obc)
1655        throws NoSuchReviewException, SystemException {
1656        int count = countByP_S_C_R(proposalId, stage, completed, rejected);
1657
1658        List<TasksReview> list = findByP_S_C_R(proposalId, stage, completed,
1659                rejected, count - 1, count, obc);
1660
1661        if (list.size() == 0) {
1662            StringBuilder msg = new StringBuilder();
1663
1664            msg.append("No TasksReview exists with the key {");
1665
1666            msg.append("proposalId=" + proposalId);
1667
1668            msg.append(", ");
1669            msg.append("stage=" + stage);
1670
1671            msg.append(", ");
1672            msg.append("completed=" + completed);
1673
1674            msg.append(", ");
1675            msg.append("rejected=" + rejected);
1676
1677            msg.append(StringPool.CLOSE_CURLY_BRACE);
1678
1679            throw new NoSuchReviewException(msg.toString());
1680        }
1681        else {
1682            return list.get(0);
1683        }
1684    }
1685
1686    public TasksReview[] findByP_S_C_R_PrevAndNext(long reviewId,
1687        long proposalId, int stage, boolean completed, boolean rejected,
1688        OrderByComparator obc) throws NoSuchReviewException, SystemException {
1689        TasksReview tasksReview = findByPrimaryKey(reviewId);
1690
1691        int count = countByP_S_C_R(proposalId, stage, completed, rejected);
1692
1693        Session session = null;
1694
1695        try {
1696            session = openSession();
1697
1698            StringBuilder query = new StringBuilder();
1699
1700            query.append(
1701                "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
1702
1703            query.append("proposalId = ?");
1704
1705            query.append(" AND ");
1706
1707            query.append("stage = ?");
1708
1709            query.append(" AND ");
1710
1711            query.append("completed = ?");
1712
1713            query.append(" AND ");
1714
1715            query.append("rejected = ?");
1716
1717            query.append(" ");
1718
1719            if (obc != null) {
1720                query.append("ORDER BY ");
1721                query.append(obc.getOrderBy());
1722            }
1723
1724            else {
1725                query.append("ORDER BY ");
1726
1727                query.append("createDate ASC");
1728            }
1729
1730            Query q = session.createQuery(query.toString());
1731
1732            QueryPos qPos = QueryPos.getInstance(q);
1733
1734            qPos.add(proposalId);
1735
1736            qPos.add(stage);
1737
1738            qPos.add(completed);
1739
1740            qPos.add(rejected);
1741
1742            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1743                    tasksReview);
1744
1745            TasksReview[] array = new TasksReviewImpl[3];
1746
1747            array[0] = (TasksReview)objArray[0];
1748            array[1] = (TasksReview)objArray[1];
1749            array[2] = (TasksReview)objArray[2];
1750
1751            return array;
1752        }
1753        catch (Exception e) {
1754            throw processException(e);
1755        }
1756        finally {
1757            closeSession(session);
1758        }
1759    }
1760
1761    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1762        throws SystemException {
1763        Session session = null;
1764
1765        try {
1766            session = openSession();
1767
1768            dynamicQuery.compile(session);
1769
1770            return dynamicQuery.list();
1771        }
1772        catch (Exception e) {
1773            throw processException(e);
1774        }
1775        finally {
1776            closeSession(session);
1777        }
1778    }
1779
1780    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1781        int start, int end) throws SystemException {
1782        Session session = null;
1783
1784        try {
1785            session = openSession();
1786
1787            dynamicQuery.setLimit(start, end);
1788
1789            dynamicQuery.compile(session);
1790
1791            return dynamicQuery.list();
1792        }
1793        catch (Exception e) {
1794            throw processException(e);
1795        }
1796        finally {
1797            closeSession(session);
1798        }
1799    }
1800
1801    public List<TasksReview> findAll() throws SystemException {
1802        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1803    }
1804
1805    public List<TasksReview> findAll(int start, int end)
1806        throws SystemException {
1807        return findAll(start, end, null);
1808    }
1809
1810    public List<TasksReview> findAll(int start, int end, OrderByComparator obc)
1811        throws SystemException {
1812        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
1813        String finderClassName = TasksReview.class.getName();
1814        String finderMethodName = "findAll";
1815        String[] finderParams = new String[] {
1816                "java.lang.Integer", "java.lang.Integer",
1817                "com.liferay.portal.kernel.util.OrderByComparator"
1818            };
1819        Object[] finderArgs = new Object[] {
1820                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1821            };
1822
1823        Object result = null;
1824
1825        if (finderClassNameCacheEnabled) {
1826            result = FinderCacheUtil.getResult(finderClassName,
1827                    finderMethodName, finderParams, finderArgs, this);
1828        }
1829
1830        if (result == null) {
1831            Session session = null;
1832
1833            try {
1834                session = openSession();
1835
1836                StringBuilder query = new StringBuilder();
1837
1838                query.append(
1839                    "FROM com.liferay.portlet.tasks.model.TasksReview ");
1840
1841                if (obc != null) {
1842                    query.append("ORDER BY ");
1843                    query.append(obc.getOrderBy());
1844                }
1845
1846                else {
1847                    query.append("ORDER BY ");
1848
1849                    query.append("createDate ASC");
1850                }
1851
1852                Query q = session.createQuery(query.toString());
1853
1854                List<TasksReview> list = (List<TasksReview>)QueryUtil.list(q,
1855                        getDialect(), start, end);
1856
1857                if (obc == null) {
1858                    Collections.sort(list);
1859                }
1860
1861                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1862                    finderClassName, finderMethodName, finderParams,
1863                    finderArgs, list);
1864
1865                return list;
1866            }
1867            catch (Exception e) {
1868                throw processException(e);
1869            }
1870            finally {
1871                closeSession(session);
1872            }
1873        }
1874        else {
1875            return (List<TasksReview>)result;
1876        }
1877    }
1878
1879    public void removeByUserId(long userId) throws SystemException {
1880        for (TasksReview tasksReview : findByUserId(userId)) {
1881            remove(tasksReview);
1882        }
1883    }
1884
1885    public void removeByProposalId(long proposalId) throws SystemException {
1886        for (TasksReview tasksReview : findByProposalId(proposalId)) {
1887            remove(tasksReview);
1888        }
1889    }
1890
1891    public void removeByU_P(long userId, long proposalId)
1892        throws NoSuchReviewException, SystemException {
1893        TasksReview tasksReview = findByU_P(userId, proposalId);
1894
1895        remove(tasksReview);
1896    }
1897
1898    public void removeByP_S(long proposalId, int stage)
1899        throws SystemException {
1900        for (TasksReview tasksReview : findByP_S(proposalId, stage)) {
1901            remove(tasksReview);
1902        }
1903    }
1904
1905    public void removeByP_S_C(long proposalId, int stage, boolean completed)
1906        throws SystemException {
1907        for (TasksReview tasksReview : findByP_S_C(proposalId, stage, completed)) {
1908            remove(tasksReview);
1909        }
1910    }
1911
1912    public void removeByP_S_C_R(long proposalId, int stage, boolean completed,
1913        boolean rejected) throws SystemException {
1914        for (TasksReview tasksReview : findByP_S_C_R(proposalId, stage,
1915                completed, rejected)) {
1916            remove(tasksReview);
1917        }
1918    }
1919
1920    public void removeAll() throws SystemException {
1921        for (TasksReview tasksReview : findAll()) {
1922            remove(tasksReview);
1923        }
1924    }
1925
1926    public int countByUserId(long userId) throws SystemException {
1927        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
1928        String finderClassName = TasksReview.class.getName();
1929        String finderMethodName = "countByUserId";
1930        String[] finderParams = new String[] { Long.class.getName() };
1931        Object[] finderArgs = new Object[] { new Long(userId) };
1932
1933        Object result = null;
1934
1935        if (finderClassNameCacheEnabled) {
1936            result = FinderCacheUtil.getResult(finderClassName,
1937                    finderMethodName, finderParams, finderArgs, this);
1938        }
1939
1940        if (result == null) {
1941            Session session = null;
1942
1943            try {
1944                session = openSession();
1945
1946                StringBuilder query = new StringBuilder();
1947
1948                query.append("SELECT COUNT(*) ");
1949                query.append(
1950                    "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
1951
1952                query.append("userId = ?");
1953
1954                query.append(" ");
1955
1956                Query q = session.createQuery(query.toString());
1957
1958                QueryPos qPos = QueryPos.getInstance(q);
1959
1960                qPos.add(userId);
1961
1962                Long count = null;
1963
1964                Iterator<Long> itr = q.list().iterator();
1965
1966                if (itr.hasNext()) {
1967                    count = itr.next();
1968                }
1969
1970                if (count == null) {
1971                    count = new Long(0);
1972                }
1973
1974                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1975                    finderClassName, finderMethodName, finderParams,
1976                    finderArgs, count);
1977
1978                return count.intValue();
1979            }
1980            catch (Exception e) {
1981                throw processException(e);
1982            }
1983            finally {
1984                closeSession(session);
1985            }
1986        }
1987        else {
1988            return ((Long)result).intValue();
1989        }
1990    }
1991
1992    public int countByProposalId(long proposalId) throws SystemException {
1993        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
1994        String finderClassName = TasksReview.class.getName();
1995        String finderMethodName = "countByProposalId";
1996        String[] finderParams = new String[] { Long.class.getName() };
1997        Object[] finderArgs = new Object[] { new Long(proposalId) };
1998
1999        Object result = null;
2000
2001        if (finderClassNameCacheEnabled) {
2002            result = FinderCacheUtil.getResult(finderClassName,
2003                    finderMethodName, finderParams, finderArgs, this);
2004        }
2005
2006        if (result == null) {
2007            Session session = null;
2008
2009            try {
2010                session = openSession();
2011
2012                StringBuilder query = new StringBuilder();
2013
2014                query.append("SELECT COUNT(*) ");
2015                query.append(
2016                    "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
2017
2018                query.append("proposalId = ?");
2019
2020                query.append(" ");
2021
2022                Query q = session.createQuery(query.toString());
2023
2024                QueryPos qPos = QueryPos.getInstance(q);
2025
2026                qPos.add(proposalId);
2027
2028                Long count = null;
2029
2030                Iterator<Long> itr = q.list().iterator();
2031
2032                if (itr.hasNext()) {
2033                    count = itr.next();
2034                }
2035
2036                if (count == null) {
2037                    count = new Long(0);
2038                }
2039
2040                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2041                    finderClassName, finderMethodName, finderParams,
2042                    finderArgs, count);
2043
2044                return count.intValue();
2045            }
2046            catch (Exception e) {
2047                throw processException(e);
2048            }
2049            finally {
2050                closeSession(session);
2051            }
2052        }
2053        else {
2054            return ((Long)result).intValue();
2055        }
2056    }
2057
2058    public int countByU_P(long userId, long proposalId)
2059        throws SystemException {
2060        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
2061        String finderClassName = TasksReview.class.getName();
2062        String finderMethodName = "countByU_P";
2063        String[] finderParams = new String[] {
2064                Long.class.getName(), Long.class.getName()
2065            };
2066        Object[] finderArgs = new Object[] {
2067                new Long(userId), new Long(proposalId)
2068            };
2069
2070        Object result = null;
2071
2072        if (finderClassNameCacheEnabled) {
2073            result = FinderCacheUtil.getResult(finderClassName,
2074                    finderMethodName, finderParams, finderArgs, this);
2075        }
2076
2077        if (result == null) {
2078            Session session = null;
2079
2080            try {
2081                session = openSession();
2082
2083                StringBuilder query = new StringBuilder();
2084
2085                query.append("SELECT COUNT(*) ");
2086                query.append(
2087                    "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
2088
2089                query.append("userId = ?");
2090
2091                query.append(" AND ");
2092
2093                query.append("proposalId = ?");
2094
2095                query.append(" ");
2096
2097                Query q = session.createQuery(query.toString());
2098
2099                QueryPos qPos = QueryPos.getInstance(q);
2100
2101                qPos.add(userId);
2102
2103                qPos.add(proposalId);
2104
2105                Long count = null;
2106
2107                Iterator<Long> itr = q.list().iterator();
2108
2109                if (itr.hasNext()) {
2110                    count = itr.next();
2111                }
2112
2113                if (count == null) {
2114                    count = new Long(0);
2115                }
2116
2117                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2118                    finderClassName, finderMethodName, finderParams,
2119                    finderArgs, count);
2120
2121                return count.intValue();
2122            }
2123            catch (Exception e) {
2124                throw processException(e);
2125            }
2126            finally {
2127                closeSession(session);
2128            }
2129        }
2130        else {
2131            return ((Long)result).intValue();
2132        }
2133    }
2134
2135    public int countByP_S(long proposalId, int stage) throws SystemException {
2136        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
2137        String finderClassName = TasksReview.class.getName();
2138        String finderMethodName = "countByP_S";
2139        String[] finderParams = new String[] {
2140                Long.class.getName(), Integer.class.getName()
2141            };
2142        Object[] finderArgs = new Object[] {
2143                new Long(proposalId), new Integer(stage)
2144            };
2145
2146        Object result = null;
2147
2148        if (finderClassNameCacheEnabled) {
2149            result = FinderCacheUtil.getResult(finderClassName,
2150                    finderMethodName, finderParams, finderArgs, this);
2151        }
2152
2153        if (result == null) {
2154            Session session = null;
2155
2156            try {
2157                session = openSession();
2158
2159                StringBuilder query = new StringBuilder();
2160
2161                query.append("SELECT COUNT(*) ");
2162                query.append(
2163                    "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
2164
2165                query.append("proposalId = ?");
2166
2167                query.append(" AND ");
2168
2169                query.append("stage = ?");
2170
2171                query.append(" ");
2172
2173                Query q = session.createQuery(query.toString());
2174
2175                QueryPos qPos = QueryPos.getInstance(q);
2176
2177                qPos.add(proposalId);
2178
2179                qPos.add(stage);
2180
2181                Long count = null;
2182
2183                Iterator<Long> itr = q.list().iterator();
2184
2185                if (itr.hasNext()) {
2186                    count = itr.next();
2187                }
2188
2189                if (count == null) {
2190                    count = new Long(0);
2191                }
2192
2193                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2194                    finderClassName, finderMethodName, finderParams,
2195                    finderArgs, count);
2196
2197                return count.intValue();
2198            }
2199            catch (Exception e) {
2200                throw processException(e);
2201            }
2202            finally {
2203                closeSession(session);
2204            }
2205        }
2206        else {
2207            return ((Long)result).intValue();
2208        }
2209    }
2210
2211    public int countByP_S_C(long proposalId, int stage, boolean completed)
2212        throws SystemException {
2213        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
2214        String finderClassName = TasksReview.class.getName();
2215        String finderMethodName = "countByP_S_C";
2216        String[] finderParams = new String[] {
2217                Long.class.getName(), Integer.class.getName(),
2218                Boolean.class.getName()
2219            };
2220        Object[] finderArgs = new Object[] {
2221                new Long(proposalId), new Integer(stage),
2222                Boolean.valueOf(completed)
2223            };
2224
2225        Object result = null;
2226
2227        if (finderClassNameCacheEnabled) {
2228            result = FinderCacheUtil.getResult(finderClassName,
2229                    finderMethodName, finderParams, finderArgs, this);
2230        }
2231
2232        if (result == null) {
2233            Session session = null;
2234
2235            try {
2236                session = openSession();
2237
2238                StringBuilder query = new StringBuilder();
2239
2240                query.append("SELECT COUNT(*) ");
2241                query.append(
2242                    "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
2243
2244                query.append("proposalId = ?");
2245
2246                query.append(" AND ");
2247
2248                query.append("stage = ?");
2249
2250                query.append(" AND ");
2251
2252                query.append("completed = ?");
2253
2254                query.append(" ");
2255
2256                Query q = session.createQuery(query.toString());
2257
2258                QueryPos qPos = QueryPos.getInstance(q);
2259
2260                qPos.add(proposalId);
2261
2262                qPos.add(stage);
2263
2264                qPos.add(completed);
2265
2266                Long count = null;
2267
2268                Iterator<Long> itr = q.list().iterator();
2269
2270                if (itr.hasNext()) {
2271                    count = itr.next();
2272                }
2273
2274                if (count == null) {
2275                    count = new Long(0);
2276                }
2277
2278                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2279                    finderClassName, finderMethodName, finderParams,
2280                    finderArgs, count);
2281
2282                return count.intValue();
2283            }
2284            catch (Exception e) {
2285                throw processException(e);
2286            }
2287            finally {
2288                closeSession(session);
2289            }
2290        }
2291        else {
2292            return ((Long)result).intValue();
2293        }
2294    }
2295
2296    public int countByP_S_C_R(long proposalId, int stage, boolean completed,
2297        boolean rejected) throws SystemException {
2298        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
2299        String finderClassName = TasksReview.class.getName();
2300        String finderMethodName = "countByP_S_C_R";
2301        String[] finderParams = new String[] {
2302                Long.class.getName(), Integer.class.getName(),
2303                Boolean.class.getName(), Boolean.class.getName()
2304            };
2305        Object[] finderArgs = new Object[] {
2306                new Long(proposalId), new Integer(stage),
2307                Boolean.valueOf(completed), Boolean.valueOf(rejected)
2308            };
2309
2310        Object result = null;
2311
2312        if (finderClassNameCacheEnabled) {
2313            result = FinderCacheUtil.getResult(finderClassName,
2314                    finderMethodName, finderParams, finderArgs, this);
2315        }
2316
2317        if (result == null) {
2318            Session session = null;
2319
2320            try {
2321                session = openSession();
2322
2323                StringBuilder query = new StringBuilder();
2324
2325                query.append("SELECT COUNT(*) ");
2326                query.append(
2327                    "FROM com.liferay.portlet.tasks.model.TasksReview WHERE ");
2328
2329                query.append("proposalId = ?");
2330
2331                query.append(" AND ");
2332
2333                query.append("stage = ?");
2334
2335                query.append(" AND ");
2336
2337                query.append("completed = ?");
2338
2339                query.append(" AND ");
2340
2341                query.append("rejected = ?");
2342
2343                query.append(" ");
2344
2345                Query q = session.createQuery(query.toString());
2346
2347                QueryPos qPos = QueryPos.getInstance(q);
2348
2349                qPos.add(proposalId);
2350
2351                qPos.add(stage);
2352
2353                qPos.add(completed);
2354
2355                qPos.add(rejected);
2356
2357                Long count = null;
2358
2359                Iterator<Long> itr = q.list().iterator();
2360
2361                if (itr.hasNext()) {
2362                    count = itr.next();
2363                }
2364
2365                if (count == null) {
2366                    count = new Long(0);
2367                }
2368
2369                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2370                    finderClassName, finderMethodName, finderParams,
2371                    finderArgs, count);
2372
2373                return count.intValue();
2374            }
2375            catch (Exception e) {
2376                throw processException(e);
2377            }
2378            finally {
2379                closeSession(session);
2380            }
2381        }
2382        else {
2383            return ((Long)result).intValue();
2384        }
2385    }
2386
2387    public int countAll() throws SystemException {
2388        boolean finderClassNameCacheEnabled = TasksReviewModelImpl.CACHE_ENABLED;
2389        String finderClassName = TasksReview.class.getName();
2390        String finderMethodName = "countAll";
2391        String[] finderParams = new String[] {  };
2392        Object[] finderArgs = new Object[] {  };
2393
2394        Object result = null;
2395
2396        if (finderClassNameCacheEnabled) {
2397            result = FinderCacheUtil.getResult(finderClassName,
2398                    finderMethodName, finderParams, finderArgs, this);
2399        }
2400
2401        if (result == null) {
2402            Session session = null;
2403
2404            try {
2405                session = openSession();
2406
2407                Query q = session.createQuery(
2408                        "SELECT COUNT(*) FROM com.liferay.portlet.tasks.model.TasksReview");
2409
2410                Long count = null;
2411
2412                Iterator<Long> itr = q.list().iterator();
2413
2414                if (itr.hasNext()) {
2415                    count = itr.next();
2416                }
2417
2418                if (count == null) {
2419                    count = new Long(0);
2420                }
2421
2422                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2423                    finderClassName, finderMethodName, finderParams,
2424                    finderArgs, count);
2425
2426                return count.intValue();
2427            }
2428            catch (Exception e) {
2429                throw processException(e);
2430            }
2431            finally {
2432                closeSession(session);
2433            }
2434        }
2435        else {
2436            return ((Long)result).intValue();
2437        }
2438    }
2439
2440    public void registerListener(ModelListener listener) {
2441        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2442
2443        listeners.add(listener);
2444
2445        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2446    }
2447
2448    public void unregisterListener(ModelListener listener) {
2449        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2450
2451        listeners.remove(listener);
2452
2453        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2454    }
2455
2456    public void afterPropertiesSet() {
2457        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2458                    com.liferay.portal.util.PropsUtil.get(
2459                        "value.object.listener.com.liferay.portlet.tasks.model.TasksReview")));
2460
2461        if (listenerClassNames.length > 0) {
2462            try {
2463                List<ModelListener> listeners = new ArrayList<ModelListener>();
2464
2465                for (String listenerClassName : listenerClassNames) {
2466                    listeners.add((ModelListener)Class.forName(
2467                            listenerClassName).newInstance());
2468                }
2469
2470                _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2471            }
2472            catch (Exception e) {
2473                _log.error(e);
2474            }
2475        }
2476    }
2477
2478    private static Log _log = LogFactory.getLog(TasksReviewPersistenceImpl.class);
2479    private ModelListener[] _listeners = new ModelListener[0];
2480}