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