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