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