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