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