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